@algorandfoundation/puya-ts 1.0.0-alpha.76 → 1.0.0-alpha.78

package/awst_build/ast-visitors/decorator-visitor.d.ts

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import type { DecoratorData, DecoratorDataForType } from '../models/decorator-data';
+import type { DecoratorData, RoutingDecoratorData } from '../models/decorator-data';
 import { BaseVisitor } from './base-visitor';
 export declare class DecoratorVisitor extends BaseVisitor {
     private accept;
@@ -8,6 +8,6 @@ export declare class DecoratorVisitor extends BaseVisitor {
     private static buildDecoratorData;
     static buildContractData(target: ts.ClassDeclaration): import("../models/decorator-data").ContractOptionsDecoratorData | undefined;
     static buildLogicSigData(target: ts.ClassDeclaration): import("../models/decorator-data").LogicSigOptionsDecoratorData | undefined;
-    static buildContractMethodData(target: ts.MethodDeclaration): DecoratorDataForType<"arc4.baremethod" | "arc4.abimethod"> | undefined;
+    static buildContractMethodData(target: ts.MethodDeclaration): RoutingDecoratorData | undefined;
     private static filterDecoratorData;
 }

package/awst_build/eb/arc4/util.d.ts

@@ -20,7 +20,7 @@ export declare class MethodSelectorFunctionBuilder extends FunctionBuilder {
     readonly ptype: import("../../ptypes").LibFunctionType;
     call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
 }
-export declare class Arc4EncodedLengthFunctionBuilder extends FunctionBuilder {
+export declare class SizeOfFunctionBuilder extends FunctionBuilder {
     readonly ptype: import("../../ptypes").LibFunctionType;
     call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
 }

package/awst_build/eb/arc4-method-decorator-builder.d.ts

@@ -1,11 +1,15 @@
 import type { SourceLocation } from '../../awst/source-location';
 import type { PType } from '../ptypes';
-import { NodeBuilder } from './index';
+import { DecoratorDataBuilder, NodeBuilder } from './index';
 export declare class Arc4BareMethodDecoratorBuilder extends NodeBuilder {
-    get ptype(): PType;
+    readonly ptype: import("../ptypes").LibFunctionType;
     call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
 }
+export declare class ReadonlyDecoratorBuilder extends DecoratorDataBuilder {
+    readonly ptype: import("../ptypes").LibFunctionType;
+    constructor(sourceLocation: SourceLocation);
+}
 export declare class Arc4AbiMethodDecoratorBuilder extends NodeBuilder {
-    get ptype(): PType;
+    readonly ptype: import("../ptypes").LibFunctionType;
     call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
 }

package/awst_build/eb/index.d.ts

@@ -132,7 +132,7 @@ export declare function isReferableExpression(expr: awst.Expression): boolean;
 export declare function requireLValue(expr: awst.Expression): awst.LValue;
 export declare class DecoratorDataBuilder extends NodeBuilder {
     private readonly data;
-    get ptype(): PType | undefined;
+    readonly ptype: PType | undefined;
     constructor(sourceLocation: SourceLocation, data: DecoratorData);
     resolveDecoratorData(): DecoratorData;
 }

package/awst_build/models/decorator-data.d.ts

@@ -11,7 +11,7 @@ export type Arc4AbiDecoratorData = {
     allowedCompletionTypes?: OnCompletionAction[];
     allowedCompletionTypesLocation?: SourceLocation;
     sourceLocation: SourceLocation;
-    readonly: boolean;
+    readonly: boolean | undefined;
     nameOverride: string | undefined;
     resourceEncoding?: ResourceEncoding;
     defaultArguments: Record<string, {
@@ -30,6 +30,11 @@ export type Arc4BareDecoratorData = {
     allowedCompletionTypesLocation?: SourceLocation;
     sourceLocation: SourceLocation;
 };
+export type ReadonlyDecoratorData = {
+    type: typeof Constants.symbolNames.readonlyDecoratorName;
+    sourceLocation: SourceLocation;
+    readonly: true;
+};
 export type LogicSigOptionsDecoratorData = {
     type: typeof Constants.symbolNames.logicSigOptionsDecoratorName;
     sourceLocation: SourceLocation;
@@ -50,8 +55,8 @@ export type ContractOptionsDecoratorData = {
         localBytes?: bigint;
     };
 };
-export type DecoratorData = Arc4BareDecoratorData | Arc4AbiDecoratorData | LogicSigOptionsDecoratorData | ContractOptionsDecoratorData;
-export type RoutingDecoratorData = Arc4AbiDecoratorData | Arc4BareDecoratorData;
+export type DecoratorData = Arc4BareDecoratorData | Arc4AbiDecoratorData | LogicSigOptionsDecoratorData | ContractOptionsDecoratorData | ReadonlyDecoratorData;
+export type RoutingDecoratorData = Arc4AbiDecoratorData | Arc4BareDecoratorData | ReadonlyDecoratorData;
 export type DecoratorType = DecoratorData['type'];
 export type DecoratorDataForType<TType extends DecoratorType> = DecoratorData extends infer TDec ? TDec extends {
     type: TType;

package/awst_build/ptypes/arc4-types.d.ts

@@ -191,7 +191,7 @@ export declare const DynamicBytesConstructor: LibClassType;
 export declare const DynamicBytesType: DynamicArrayType;
 export declare const interpretAsArc4Function: LibFunctionType;
 export declare const encodeArc4Function: LibFunctionType;
-export declare const arc4EncodedLengthFunction: LibFunctionType;
+export declare const sizeOfFunction: LibFunctionType;
 export declare const decodeArc4Function: LibFunctionType;
 export declare const methodSelectorFunction: LibFunctionType;
 export declare const abiCallFunction: LibFunctionType;

package/awst_build/ptypes/index.d.ts

@@ -592,6 +592,7 @@ export declare const arc4BaseContractType: BaseContractClassType;
 export declare const itoaMethod: LibFunctionType;
 export declare const arc4BareMethodDecorator: LibFunctionType;
 export declare const arc4AbiMethodDecorator: LibFunctionType;
+export declare const readonlyDecorator: LibFunctionType;
 export declare const contractOptionsDecorator: LibFunctionType;
 export declare const logicSigOptionsDecorator: LibFunctionType;
 export declare class GroupTransactionPType extends PType implements ABICompatiblePType {

package/bin/download-puya-binary.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { l as logger, L as LogLevel, r as resolvePuyaPath } from '../resolve-puya-path-BhHWvo7r.js';
-import { C as ConsoleLogSink } from '../console-log-sink-CfAhr7OE.js';
+import { l as logger, L as LogLevel, r as resolvePuyaPath } from '../resolve-puya-path-CaVLCfDd.js';
+import { C as ConsoleLogSink } from '../console-log-sink-BTGmdQzW.js';
 import 'tslib';
 import 'fs';
 import 'node:async_hooks';

package/bin/puyats-ls.mjs

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import { ArgumentParser } from 'argparse';
-import { c as checkNodeVersion, a as appVersion } from '../check-node-version-ZyGkyCLd.js';
+import { c as checkNodeVersion, a as appVersion } from '../check-node-version-8aEfSGwC.js';
 import { Observable, debounceTime, map, concatMap } from 'rxjs';
 import { TextDocument } from 'vscode-languageserver-textdocument';
 import { TextDocuments, TextDocumentSyncKind, createConnection, ProposedFeatures, createClientSocketTransport } from 'vscode-languageserver/node.js';
 import { URI } from 'vscode-uri';
-import { a as LoggingContext, L as LogLevel, C as Constants } from '../resolve-puya-path-BhHWvo7r.js';
+import { a as LoggingContext, L as LogLevel, C as Constants } from '../resolve-puya-path-CaVLCfDd.js';
 import upath from 'upath';
 import { DiagnosticSeverity } from 'vscode-languageserver';
-import { cI as processInputPaths, cH as compile, cJ as CompileOptions } from '../options-Bl9Dfnsn.js';
+import { cJ as processInputPaths, cI as compile, cK as CompileOptions } from '../options--REGWlBH.js';
 import 'fs';
 import 'node:url';
 import 'chalk';

package/bin/run-cli.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import '../cli.mjs';
 import 'argparse';
-import '../check-node-version-ZyGkyCLd.js';
+import '../check-node-version-8aEfSGwC.js';
 import 'fs';
 import 'node:url';
 import 'upath';
-import '../resolve-puya-path-BhHWvo7r.js';
+import '../resolve-puya-path-CaVLCfDd.js';
 import 'tslib';
 import 'node:async_hooks';
 import 'typescript';
@@ -19,7 +19,7 @@ import 'glob';
 import 'node:zlib';
 import 'os';
 import 'chalk';
-import '../options-Bl9Dfnsn.js';
+import '../options--REGWlBH.js';
 import 'polytype';
 import 'change-case';
 import 'node:path';
@@ -29,5 +29,5 @@ import 'arcsecond';
 import 'cross-spawn';
 import 'zod';
 import 'minimatch';
-import '../console-log-sink-CfAhr7OE.js';
+import '../console-log-sink-BTGmdQzW.js';
 //# sourceMappingURL=run-cli.mjs.map

package/{check-node-version-ZyGkyCLd.js → check-node-version-8aEfSGwC.js}

@@ -1,7 +1,7 @@
 import fs__default from 'fs';
 import { fileURLToPath } from 'node:url';
 import upath from 'upath';
-import { C as Constants, p as parseSemVer } from './resolve-puya-path-BhHWvo7r.js';
+import { C as Constants, p as parseSemVer } from './resolve-puya-path-CaVLCfDd.js';
 import chalk from 'chalk';
 
 function appVersion(name = 'puya-ts') {
@@ -40,4 +40,4 @@ function checkNodeVersion() {
 }
 
 export { appVersion as a, checkNodeVersion as c };
-//# sourceMappingURL=check-node-version-ZyGkyCLd.js.map
+//# sourceMappingURL=check-node-version-8aEfSGwC.js.map

package/{check-node-version-ZyGkyCLd.js.map → check-node-version-8aEfSGwC.js.map}

@@ -1 +1 @@
-{"version":3,"file":"check-node-version-ZyGkyCLd.js","sources":["../src/cli/app-version.ts","../src/cli/check-node-version.ts"],"sourcesContent":["import fs from 'fs'\nimport { fileURLToPath } from 'node:url'\nimport upath from 'upath'\nimport { Constants } from '../constants'\n\nexport function appVersion(name: string = 'puya-ts') {\n  let dirName = upath.dirname(fileURLToPath(import.meta.url))\n\n  while (true) {\n    const packageJsonPath = upath.join(dirName, 'package.json')\n    if (fs.existsSync(packageJsonPath)) {\n      const version = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8')).version\n      return [\n        `${name} ${version}`,\n        '',\n        'Targets:',\n        `puya ${Constants.targetedPuyaVersion}`,\n        `AVM ${Constants.supportedAvmVersions.join(', ')}`,\n      ].join('\\r\\n')\n    }\n    if (dirName === upath.dirname(dirName)) break\n    dirName = upath.dirname(dirName)\n  }\n  return `Cannot determine puya-ts version`\n}\n","import chalk from 'chalk'\nimport { Constants } from '../constants'\nimport { parseSemVer } from '../puya/semver'\n\nfunction writeError(text: string) {\n  // eslint-disable-next-line no-console\n  console.error(chalk.red(text))\n}\n\nexport function checkNodeVersion() {\n  const min = parseSemVer(Constants.minNodeVersion)\n  const actual = parseSemVer(process.versions.node)\n\n  if (\n    actual.major < min.major ||\n    (actual.major === min.major && actual.minor < min.minor) ||\n    (actual.major === min.major && actual.minor === min.minor && actual.rev < min.rev)\n  ) {\n    writeError(\n      `Installed node version ${process.versions.node} is older than the minimum required version ${Constants.minNodeVersion}. You may experience compatability issues.`,\n    )\n  }\n}\n"],"names":["fs"],"mappings":";;;;;;AAKM,SAAU,UAAU,CAAC,IAAA,GAAe,SAAS,EAAA;AACjD,IAAA,IAAI,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAE3D,OAAO,IAAI,EAAE;QACX,MAAM,eAAe,GAAG,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,cAAc,CAAC;AAC3D,QAAA,IAAIA,WAAE,CAAC,UAAU,CAAC,eAAe,CAAC,EAAE;AAClC,YAAA,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAACA,WAAE,CAAC,YAAY,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC,CAAC,OAAO;YAC5E,OAAO;gBACL,CAAA,EAAG,IAAI,CAAA,CAAA,EAAI,OAAO,CAAA,CAAE;gBACpB,EAAE;gBACF,UAAU;gBACV,CAAA,KAAA,EAAQ,SAAS,CAAC,mBAAmB,CAAA,CAAE;gBACvC,CAAA,IAAA,EAAO,SAAS,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA,CAAE;AACnD,aAAA,CAAC,IAAI,CAAC,MAAM,CAAC;QAChB;AACA,QAAA,IAAI,OAAO,KAAK,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;YAAE;AACxC,QAAA,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;IAClC;AACA,IAAA,OAAO,kCAAkC;AAC3C;;ACpBA,SAAS,UAAU,CAAC,IAAY,EAAA;;IAE9B,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AAChC;SAEgB,gBAAgB,GAAA;IAC9B,MAAM,GAAG,GAAG,WAAW,CAAC,SAAS,CAAC,cAAc,CAAC;IACjD,MAAM,MAAM,GAAG,WAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC;AAEjD,IAAA,IACE,MAAM,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK;AACxB,SAAC,MAAM,CAAC,KAAK,KAAK,GAAG,CAAC,KAAK,IAAI,MAAM,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC;SACvD,MAAM,CAAC,KAAK,KAAK,GAAG,CAAC,KAAK,IAAI,MAAM,CAAC,KAAK,KAAK,GAAG,CAAC,KAAK,IAAI,MAAM,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,EAClF;AACA,QAAA,UAAU,CACR,CAAA,uBAAA,EAA0B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAA,4CAAA,EAA+C,SAAS,CAAC,cAAc,CAAA,0CAAA,CAA4C,CACnK;IACH;AACF;;;;"}
+{"version":3,"file":"check-node-version-8aEfSGwC.js","sources":["../src/cli/app-version.ts","../src/cli/check-node-version.ts"],"sourcesContent":["import fs from 'fs'\nimport { fileURLToPath } from 'node:url'\nimport upath from 'upath'\nimport { Constants } from '../constants'\n\nexport function appVersion(name: string = 'puya-ts') {\n  let dirName = upath.dirname(fileURLToPath(import.meta.url))\n\n  while (true) {\n    const packageJsonPath = upath.join(dirName, 'package.json')\n    if (fs.existsSync(packageJsonPath)) {\n      const version = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8')).version\n      return [\n        `${name} ${version}`,\n        '',\n        'Targets:',\n        `puya ${Constants.targetedPuyaVersion}`,\n        `AVM ${Constants.supportedAvmVersions.join(', ')}`,\n      ].join('\\r\\n')\n    }\n    if (dirName === upath.dirname(dirName)) break\n    dirName = upath.dirname(dirName)\n  }\n  return `Cannot determine puya-ts version`\n}\n","import chalk from 'chalk'\nimport { Constants } from '../constants'\nimport { parseSemVer } from '../puya/semver'\n\nfunction writeError(text: string) {\n  // eslint-disable-next-line no-console\n  console.error(chalk.red(text))\n}\n\nexport function checkNodeVersion() {\n  const min = parseSemVer(Constants.minNodeVersion)\n  const actual = parseSemVer(process.versions.node)\n\n  if (\n    actual.major < min.major ||\n    (actual.major === min.major && actual.minor < min.minor) ||\n    (actual.major === min.major && actual.minor === min.minor && actual.rev < min.rev)\n  ) {\n    writeError(\n      `Installed node version ${process.versions.node} is older than the minimum required version ${Constants.minNodeVersion}. You may experience compatability issues.`,\n    )\n  }\n}\n"],"names":["fs"],"mappings":";;;;;;AAKM,SAAU,UAAU,CAAC,IAAA,GAAe,SAAS,EAAA;AACjD,IAAA,IAAI,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAE3D,OAAO,IAAI,EAAE;QACX,MAAM,eAAe,GAAG,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,cAAc,CAAC;AAC3D,QAAA,IAAIA,WAAE,CAAC,UAAU,CAAC,eAAe,CAAC,EAAE;AAClC,YAAA,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAACA,WAAE,CAAC,YAAY,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC,CAAC,OAAO;YAC5E,OAAO;gBACL,CAAA,EAAG,IAAI,CAAA,CAAA,EAAI,OAAO,CAAA,CAAE;gBACpB,EAAE;gBACF,UAAU;gBACV,CAAA,KAAA,EAAQ,SAAS,CAAC,mBAAmB,CAAA,CAAE;gBACvC,CAAA,IAAA,EAAO,SAAS,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA,CAAE;AACnD,aAAA,CAAC,IAAI,CAAC,MAAM,CAAC;QAChB;AACA,QAAA,IAAI,OAAO,KAAK,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;YAAE;AACxC,QAAA,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;IAClC;AACA,IAAA,OAAO,kCAAkC;AAC3C;;ACpBA,SAAS,UAAU,CAAC,IAAY,EAAA;;IAE9B,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AAChC;SAEgB,gBAAgB,GAAA;IAC9B,MAAM,GAAG,GAAG,WAAW,CAAC,SAAS,CAAC,cAAc,CAAC;IACjD,MAAM,MAAM,GAAG,WAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC;AAEjD,IAAA,IACE,MAAM,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK;AACxB,SAAC,MAAM,CAAC,KAAK,KAAK,GAAG,CAAC,KAAK,IAAI,MAAM,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC;SACvD,MAAM,CAAC,KAAK,KAAK,GAAG,CAAC,KAAK,IAAI,MAAM,CAAC,KAAK,KAAK,GAAG,CAAC,KAAK,IAAI,MAAM,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,EAClF;AACA,QAAA,UAAU,CACR,CAAA,uBAAA,EAA0B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAA,4CAAA,EAA+C,SAAS,CAAC,cAAc,CAAA,0CAAA,CAA4C,CACnK;IACH;AACF;;;;"}

package/cli.mjs

@@ -1,8 +1,8 @@
 import { BooleanOptionalAction, ArgumentParser } from 'argparse';
-import { c as checkNodeVersion, a as appVersion } from './check-node-version-ZyGkyCLd.js';
-import { cK as defaultPuyaOptions, cI as processInputPaths, cH as compile, cJ as CompileOptions, cL as parseCliTemplateVar, cM as LocalsCoalescingStrategy } from './options-Bl9Dfnsn.js';
-import { j as enumFromValue, a as LoggingContext, l as logger, L as LogLevel } from './resolve-puya-path-BhHWvo7r.js';
-import { C as ConsoleLogSink } from './console-log-sink-CfAhr7OE.js';
+import { c as checkNodeVersion, a as appVersion } from './check-node-version-8aEfSGwC.js';
+import { cL as defaultPuyaOptions, cJ as processInputPaths, cI as compile, cK as CompileOptions, cM as parseCliTemplateVar, cN as LocalsCoalescingStrategy } from './options--REGWlBH.js';
+import { j as enumFromValue, a as LoggingContext, l as logger, L as LogLevel } from './resolve-puya-path-CaVLCfDd.js';
+import { C as ConsoleLogSink } from './console-log-sink-BTGmdQzW.js';
 import 'fs';
 import 'node:url';
 import 'upath';

package/{console-log-sink-CfAhr7OE.js → console-log-sink-BTGmdQzW.js}

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { i as isMinLevel, L as LogLevel, a as LoggingContext } from './resolve-puya-path-BhHWvo7r.js';
+import { i as isMinLevel, L as LogLevel, a as LoggingContext } from './resolve-puya-path-CaVLCfDd.js';
 
 const levelConfig = {
     /* eslint-disable no-console */
@@ -42,4 +42,4 @@ class ConsoleLogSink {
 }
 
 export { ConsoleLogSink as C };
-//# sourceMappingURL=console-log-sink-CfAhr7OE.js.map
+//# sourceMappingURL=console-log-sink-BTGmdQzW.js.map

package/{console-log-sink-CfAhr7OE.js.map → console-log-sink-BTGmdQzW.js.map}

@@ -1 +1 @@
-{"version":3,"file":"console-log-sink-CfAhr7OE.js","sources":["../src/logger/sinks/console-log-sink.ts"],"sourcesContent":["import chalk from 'chalk'\nimport type { SourceLocation } from '../../awst/source-location'\nimport type { LogEvent } from '../index'\nimport { isMinLevel, LoggingContext, LogLevel } from '../index'\nimport type { LogSink } from './index'\n\ntype ColorFn = (text: string) => string\nconst levelConfig: Record<LogEvent['level'], { colorFn: ColorFn; writeFn: (...args: unknown[]) => void }> = {\n  /* eslint-disable no-console */\n  debug: { colorFn: chalk.green, writeFn: console.debug },\n  info: { colorFn: chalk.green, writeFn: console.info },\n  warning: { colorFn: chalk.yellow, writeFn: console.warn },\n  error: { colorFn: chalk.red, writeFn: console.error },\n  critical: { colorFn: chalk.red, writeFn: console.error },\n  /* eslint-enable no-console */\n}\n\nexport class ConsoleLogSink implements LogSink {\n  constructor(public readonly minLogLevel: LogLevel) {}\n\n  add(logEvent: LogEvent): void {\n    const config = levelConfig[logEvent.level]\n\n    let logText = `${config.colorFn(logEvent.level)}: ${logEvent.message}`\n    if (logEvent.sourceLocation) {\n      const sourceLocationText = logEvent.sourceLocation.toString()\n      const indentSize = sourceLocationText.length + logEvent.level.length + 4\n\n      const sourceSummary = isMinLevel(logEvent.level, LogLevel.Warning) ? this.getSourceSummary(logEvent.sourceLocation, indentSize) : ''\n      logText = `${sourceLocationText} ${logText}${sourceSummary}`\n    }\n    if (isMinLevel(LogLevel.Debug, this.minLogLevel) && logEvent.stack) {\n      logText += `\\n ${logEvent.stack}`\n    }\n    config.writeFn(logText)\n  }\n\n  getSourceSummary(sourceLocation: SourceLocation, indent: number): string {\n    const sourceFile = sourceLocation.file && LoggingContext.current.sourcesByPath[sourceLocation.file]\n    if (!sourceFile || sourceLocation.scope === 'file') return ''\n\n    const line = sourceFile[sourceLocation.line - 1]\n    const trimmedLine = line.trimStart()\n    const marker = `${''.padStart(sourceLocation.column - (line.length - trimmedLine.length))}^${''.padStart(Math.max(sourceLocation.endColumn - sourceLocation.column - 1, 0), '~')}`\n    const indentChars = ''.padStart(indent, ' ')\n    return `\\n${indentChars}${trimmedLine}\\n${indentChars}${marker}`\n  }\n}\n"],"names":[],"mappings":";;;AAOA,MAAM,WAAW,GAA2F;;AAE1G,IAAA,KAAK,EAAE,EAAE,OAAO,EAAE,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,KAAK,EAAE;AACvD,IAAA,IAAI,EAAE,EAAE,OAAO,EAAE,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,IAAI,EAAE;AACrD,IAAA,OAAO,EAAE,EAAE,OAAO,EAAE,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,IAAI,EAAE;AACzD,IAAA,KAAK,EAAE,EAAE,OAAO,EAAE,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,KAAK,EAAE;AACrD,IAAA,QAAQ,EAAE,EAAE,OAAO,EAAE,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,KAAK,EAAE;;CAEzD;MAEY,cAAc,CAAA;AACG,IAAA,WAAA;AAA5B,IAAA,WAAA,CAA4B,WAAqB,EAAA;QAArB,IAAA,CAAA,WAAW,GAAX,WAAW;IAAa;AAEpD,IAAA,GAAG,CAAC,QAAkB,EAAA;QACpB,MAAM,MAAM,GAAG,WAAW,CAAC,QAAQ,CAAC,KAAK,CAAC;AAE1C,QAAA,IAAI,OAAO,GAAG,CAAA,EAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA,EAAA,EAAK,QAAQ,CAAC,OAAO,EAAE;AACtE,QAAA,IAAI,QAAQ,CAAC,cAAc,EAAE;YAC3B,MAAM,kBAAkB,GAAG,QAAQ,CAAC,cAAc,CAAC,QAAQ,EAAE;AAC7D,YAAA,MAAM,UAAU,GAAG,kBAAkB,CAAC,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC;AAExE,YAAA,MAAM,aAAa,GAAG,UAAU,CAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,cAAc,EAAE,UAAU,CAAC,GAAG,EAAE;YACpI,OAAO,GAAG,GAAG,kBAAkB,CAAA,CAAA,EAAI,OAAO,CAAA,EAAG,aAAa,EAAE;QAC9D;AACA,QAAA,IAAI,UAAU,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,QAAQ,CAAC,KAAK,EAAE;AAClE,YAAA,OAAO,IAAI,CAAA,GAAA,EAAM,QAAQ,CAAC,KAAK,EAAE;QACnC;AACA,QAAA,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC;IACzB;IAEA,gBAAgB,CAAC,cAA8B,EAAE,MAAc,EAAA;AAC7D,QAAA,MAAM,UAAU,GAAG,cAAc,CAAC,IAAI,IAAI,cAAc,CAAC,OAAO,CAAC,aAAa,CAAC,cAAc,CAAC,IAAI,CAAC;AACnG,QAAA,IAAI,CAAC,UAAU,IAAI,cAAc,CAAC,KAAK,KAAK,MAAM;AAAE,YAAA,OAAO,EAAE;QAE7D,MAAM,IAAI,GAAG,UAAU,CAAC,cAAc,CAAC,IAAI,GAAG,CAAC,CAAC;AAChD,QAAA,MAAM,WAAW,GAAG,IAAI,CAAC,SAAS,EAAE;QACpC,MAAM,MAAM,GAAG,CAAA,EAAG,EAAE,CAAC,QAAQ,CAAC,cAAc,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,CAAA,CAAA,EAAI,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,SAAS,GAAG,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAA,CAAE;QAClL,MAAM,WAAW,GAAG,EAAE,CAAC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC;QAC5C,OAAO,CAAA,EAAA,EAAK,WAAW,CAAA,EAAG,WAAW,KAAK,WAAW,CAAA,EAAG,MAAM,CAAA,CAAE;IAClE;AACD;;;;"}
+{"version":3,"file":"console-log-sink-BTGmdQzW.js","sources":["../src/logger/sinks/console-log-sink.ts"],"sourcesContent":["import chalk from 'chalk'\nimport type { SourceLocation } from '../../awst/source-location'\nimport type { LogEvent } from '../index'\nimport { isMinLevel, LoggingContext, LogLevel } from '../index'\nimport type { LogSink } from './index'\n\ntype ColorFn = (text: string) => string\nconst levelConfig: Record<LogEvent['level'], { colorFn: ColorFn; writeFn: (...args: unknown[]) => void }> = {\n  /* eslint-disable no-console */\n  debug: { colorFn: chalk.green, writeFn: console.debug },\n  info: { colorFn: chalk.green, writeFn: console.info },\n  warning: { colorFn: chalk.yellow, writeFn: console.warn },\n  error: { colorFn: chalk.red, writeFn: console.error },\n  critical: { colorFn: chalk.red, writeFn: console.error },\n  /* eslint-enable no-console */\n}\n\nexport class ConsoleLogSink implements LogSink {\n  constructor(public readonly minLogLevel: LogLevel) {}\n\n  add(logEvent: LogEvent): void {\n    const config = levelConfig[logEvent.level]\n\n    let logText = `${config.colorFn(logEvent.level)}: ${logEvent.message}`\n    if (logEvent.sourceLocation) {\n      const sourceLocationText = logEvent.sourceLocation.toString()\n      const indentSize = sourceLocationText.length + logEvent.level.length + 4\n\n      const sourceSummary = isMinLevel(logEvent.level, LogLevel.Warning) ? this.getSourceSummary(logEvent.sourceLocation, indentSize) : ''\n      logText = `${sourceLocationText} ${logText}${sourceSummary}`\n    }\n    if (isMinLevel(LogLevel.Debug, this.minLogLevel) && logEvent.stack) {\n      logText += `\\n ${logEvent.stack}`\n    }\n    config.writeFn(logText)\n  }\n\n  getSourceSummary(sourceLocation: SourceLocation, indent: number): string {\n    const sourceFile = sourceLocation.file && LoggingContext.current.sourcesByPath[sourceLocation.file]\n    if (!sourceFile || sourceLocation.scope === 'file') return ''\n\n    const line = sourceFile[sourceLocation.line - 1]\n    const trimmedLine = line.trimStart()\n    const marker = `${''.padStart(sourceLocation.column - (line.length - trimmedLine.length))}^${''.padStart(Math.max(sourceLocation.endColumn - sourceLocation.column - 1, 0), '~')}`\n    const indentChars = ''.padStart(indent, ' ')\n    return `\\n${indentChars}${trimmedLine}\\n${indentChars}${marker}`\n  }\n}\n"],"names":[],"mappings":"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"}

package/constants.d.ts

@@ -35,6 +35,7 @@ export declare const Constants: {
     readonly symbolNames: {
         readonly approvalProgramMethodName: "approvalProgram";
         readonly clearStateProgramMethodName: "clearStateProgram";
+        readonly readonlyDecoratorName: "arc4.readonly";
         readonly arc4BareDecoratorName: "arc4.baremethod";
         readonly arc4AbiDecoratorName: "arc4.abimethod";
         readonly contractOptionsDecoratorName: "contract";

package/index.mjs

@@ -1,7 +1,7 @@
-import { u as uint8ArrayToBigInt, b as uint8ArrayToBase64, c as uint8ArrayToBase32, d as uint8ArrayToUtf8, e as base64ToUint8Array, f as base32ToUint8Array, g as bigIntToUint8Array, h as utf8ToUint8Array } from './resolve-puya-path-BhHWvo7r.js';
-export { a as LoggingContext, S as SourceLocation } from './resolve-puya-path-BhHWvo7r.js';
-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, C as BooleanFunction, D as BoxGeneric, E as BoxMapGeneric, F as BoxMapPType, G as BoxPType, H as BoxRefFunction, I as BoxRefPType, J as ByteClass, K as BytesFunction, L as BytesGeneric, M as BytesPType, N as ClassMethodDecoratorContext, O as ClearStateProgram, P as ClusteredContractClassType, Q as ClusteredPrototype, R as ContractClassPType, S as ContractProxyGeneric, T as ContractProxyType, U as DynamicArrayGeneric, V as DynamicArrayType, W as DynamicBytesConstructor, X as DynamicBytesType, Y as FixedArrayGeneric, Z as FixedArrayPType, _ as FunctionPType, $ as GeneratorGeneric, a0 as GeneratorType, a1 as GenericPType, a2 as GlobalStateGeneric, a3 as GlobalStateType, a4 as GroupTransactionPType, a5 as ImmutableObjectPType, a6 as InnerTransactionPType, a7 as InstanceType, a8 as InternalType, a9 as IntersectionPType, aa as IntrinsicEnumType, ab as IntrinsicFunctionGroupType, ac as IntrinsicFunctionGroupTypeType, ad as IntrinsicFunctionType, ae as IntrinsicFunctionTypeType, af as IterableIteratorGeneric, ag as IterableIteratorType, ah as ItxnParamsPType, ai as KeyRegistrationTxnFunction, aj as LibClassType, ak as LibFunctionType, al as LibObjType, am as LocalStateGeneric, an as LocalStateType, ao as LogicSigPType, ap as MutableObjectPType, aq as MutableTuplePType, ar as NamespacePType, as as NumberPType, at as NumericLiteralPType, au as ObjectLiteralPType, av as ObjectWithOptionalFieldsType, aw as PType, ax as PaymentTxnFunction, ay as PolytypeClassMethodHelper, az as PromiseGeneric, aA as PromiseType, aB as ReadonlyArrayGeneric, aC as ReadonlyArrayPType, aD as ReadonlyGeneric, aE as ReadonlyTuplePType, aF as ReferenceArrayGeneric, aG as ReferenceArrayType, aH as StaticArrayGeneric, aI as StaticArrayType, aJ as StaticBytesGeneric, aK as StaticBytesType, aL as StringFunction, aM as SuperPrototypeSelector, aN as SuperPrototypeSelectorGeneric, aO as TemplateVarFunction, aP as TransactionFunction, aQ as TransactionFunctionType, aR as TransientType, aS as TypeParameterType, aT as TypedApplicationCallResponseGeneric, aU as TypedApplicationCallResponseType, aV as UFixedNxMGeneric, aW as UFixedNxMType, aX as Uint64EnumMemberLiteralType, aY as Uint64EnumMemberType, aZ as Uint64EnumType, a_ as Uint64Function, a$ as UintN128Class, b0 as UintN16Class, b1 as UintN256Class, b2 as UintN32Class, b3 as UintN64Class, b4 as UintN8Class, b5 as UintNGeneric, b6 as UintNType, b7 as UnionPType, b8 as UnsupportedType, b9 as abiCallFunction, ba as accountPType, bb as anyGtxnType, bc as anyItxnParamsType, bd as anyItxnType, be as anyPType, bf as applicationCallGtxnType, bg as applicationCallItxnFn, bh as applicationCallItxnParamsType, bi as applicationItxnType, bj as applicationPType, bk as arc28EmitFunction, bl as arc4AbiMethodDecorator, bm as arc4AddressAlias, bn as arc4BareMethodDecorator, bo as arc4BaseContractType, bp as arc4BooleanType, bq as arc4ByteAlias, br as arc4EncodedLengthFunction, bs as arc4StringType, bt as arc4StructBaseType, bu as arc4Uint64, bv as assertFunction, bw as assertMatchFunction, bx as assetConfigGtxnType, by as assetConfigItxnFn, bz as assetConfigItxnParamsType, bA as assetConfigItxnType, bB as assetFreezeGtxnType, bC as assetFreezeItxnFn, bD as assetFreezeItxnParamsType, bE as assetFreezeItxnType, bF as assetPType, bG as assetTransferGtxnType, bH as assetTransferItxnFn, bI as assetTransferItxnParamsType, bJ as assetTransferItxnType, bK as base64PType, bL as baseContractType, bM as bigIntPType, bN as biguintPType, bO as boolPType, bP as boxRefType, bQ as bytesPType, bR as cloneFunctionPType, bS as compileArc4Function, bT as compileFunctionType, bU as compiledContractType, bV as compiledLogicSigType, bW as contractOptionsDecorator, bX as decodeArc4Function, bY as ecPType, bZ as ecdsaPType, b_ as encodeArc4Function, b$ as ensureBudgetFunction, c0 as errFunction, c1 as esSymbol, c2 as inputOnlyObjects, c3 as interpretAsArc4Function, c4 as isArrayType, c5 as isObjectType, c6 as isTupleLike, c7 as itoaMethod, c8 as itxnComposePType, c9 as keyRegistrationGtxnType, ca as keyRegistrationItxnFn, cb as keyRegistrationItxnParamsType, cc as keyRegistrationItxnType, cd as logFunction, ce as logicSigBaseType, cf as logicSigOptionsDecorator, cg as matchFunction, ch as methodSelectorFunction, ci as mimcConfigurationsPType, cj as neverPType, ck as nullPType, cl as numberPType, cm as onCompleteActionType, cn as opUpFeeSourceType, co as paymentGtxnType, cp as paymentItxnFn, cq as paymentItxnParamsType, cr as paymentItxnType, cs as ptypeToArc4EncodedType, ct as stringPType, cu as submitGroupItxnFunction, cv as transactionTypeType, cw as uint64PType, cx as undefinedPType, cy as unknownPType, cz as urangeFunction, cA as voidPType, cB as vrfVerifyPType, cC as uint8ArrayToHex, cD as hexToUint8Array } from './options-Bl9Dfnsn.js';
-export { cJ as CompileOptions, cG as TypeResolver, cH as compile, cI as processInputPaths, cE as registerPTypes, cF as typeRegistry } from './options-Bl9Dfnsn.js';
+import { u as uint8ArrayToBigInt, b as uint8ArrayToBase64, c as uint8ArrayToBase32, d as uint8ArrayToUtf8, e as base64ToUint8Array, f as base32ToUint8Array, g as bigIntToUint8Array, h as utf8ToUint8Array } from './resolve-puya-path-CaVLCfDd.js';
+export { a as LoggingContext, S as SourceLocation } from './resolve-puya-path-CaVLCfDd.js';
+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, C as BooleanFunction, D as BoxGeneric, E as BoxMapGeneric, F as BoxMapPType, G as BoxPType, H as BoxRefFunction, I as BoxRefPType, J as ByteClass, K as BytesFunction, L as BytesGeneric, M as BytesPType, N as ClassMethodDecoratorContext, O as ClearStateProgram, P as ClusteredContractClassType, Q as ClusteredPrototype, R as ContractClassPType, S as ContractProxyGeneric, T as ContractProxyType, U as DynamicArrayGeneric, V as DynamicArrayType, W as DynamicBytesConstructor, X as DynamicBytesType, Y as FixedArrayGeneric, Z as FixedArrayPType, _ as FunctionPType, $ as GeneratorGeneric, a0 as GeneratorType, a1 as GenericPType, a2 as GlobalStateGeneric, a3 as GlobalStateType, a4 as GroupTransactionPType, a5 as ImmutableObjectPType, a6 as InnerTransactionPType, a7 as InstanceType, a8 as InternalType, a9 as IntersectionPType, aa as IntrinsicEnumType, ab as IntrinsicFunctionGroupType, ac as IntrinsicFunctionGroupTypeType, ad as IntrinsicFunctionType, ae as IntrinsicFunctionTypeType, af as IterableIteratorGeneric, ag as IterableIteratorType, ah as ItxnParamsPType, ai as KeyRegistrationTxnFunction, aj as LibClassType, ak as LibFunctionType, al as LibObjType, am as LocalStateGeneric, an as LocalStateType, ao as LogicSigPType, ap as MutableObjectPType, aq as MutableTuplePType, ar as NamespacePType, as as NumberPType, at as NumericLiteralPType, au as ObjectLiteralPType, av as ObjectWithOptionalFieldsType, aw as PType, ax as PaymentTxnFunction, ay as PolytypeClassMethodHelper, az as PromiseGeneric, aA as PromiseType, aB as ReadonlyArrayGeneric, aC as ReadonlyArrayPType, aD as ReadonlyGeneric, aE as ReadonlyTuplePType, aF as ReferenceArrayGeneric, aG as ReferenceArrayType, aH as StaticArrayGeneric, aI as StaticArrayType, aJ as StaticBytesGeneric, aK as StaticBytesType, aL as StringFunction, aM as SuperPrototypeSelector, aN as SuperPrototypeSelectorGeneric, aO as TemplateVarFunction, aP as TransactionFunction, aQ as TransactionFunctionType, aR as TransientType, aS as TypeParameterType, aT as TypedApplicationCallResponseGeneric, aU as TypedApplicationCallResponseType, aV as UFixedNxMGeneric, aW as UFixedNxMType, aX as Uint64EnumMemberLiteralType, aY as Uint64EnumMemberType, aZ as Uint64EnumType, a_ as Uint64Function, a$ as UintN128Class, b0 as UintN16Class, b1 as UintN256Class, b2 as UintN32Class, b3 as UintN64Class, b4 as UintN8Class, b5 as UintNGeneric, b6 as UintNType, b7 as UnionPType, b8 as UnsupportedType, b9 as abiCallFunction, ba as accountPType, bb as anyGtxnType, bc as anyItxnParamsType, bd as anyItxnType, be as anyPType, bf as applicationCallGtxnType, bg as applicationCallItxnFn, bh as applicationCallItxnParamsType, bi as applicationItxnType, bj as applicationPType, bk as arc28EmitFunction, bl as arc4AbiMethodDecorator, bm as arc4AddressAlias, bn as arc4BareMethodDecorator, bo as arc4BaseContractType, bp as arc4BooleanType, bq as arc4ByteAlias, br as arc4StringType, bs as arc4StructBaseType, bt as arc4Uint64, bu as assertFunction, bv as assertMatchFunction, bw as assetConfigGtxnType, bx as assetConfigItxnFn, by as assetConfigItxnParamsType, bz as assetConfigItxnType, bA as assetFreezeGtxnType, bB as assetFreezeItxnFn, bC as assetFreezeItxnParamsType, bD as assetFreezeItxnType, bE as assetPType, bF as assetTransferGtxnType, bG as assetTransferItxnFn, bH as assetTransferItxnParamsType, bI as assetTransferItxnType, bJ as base64PType, bK as baseContractType, bL as bigIntPType, bM as biguintPType, bN as boolPType, bO as boxRefType, bP as bytesPType, bQ as cloneFunctionPType, bR as compileArc4Function, bS as compileFunctionType, bT as compiledContractType, bU as compiledLogicSigType, bV as contractOptionsDecorator, 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 interpretAsArc4Function, c3 as isArrayType, c4 as isObjectType, c5 as isTupleLike, c6 as itoaMethod, c7 as itxnComposePType, c8 as keyRegistrationGtxnType, c9 as keyRegistrationItxnFn, ca as keyRegistrationItxnParamsType, cb as keyRegistrationItxnType, cc as logFunction, cd as logicSigBaseType, ce as logicSigOptionsDecorator, cf as matchFunction, cg as methodSelectorFunction, ch as mimcConfigurationsPType, ci as neverPType, cj as nullPType, ck as numberPType, cl as onCompleteActionType, cm as opUpFeeSourceType, cn as paymentGtxnType, co as paymentItxnFn, cp as paymentItxnParamsType, cq as paymentItxnType, cr as ptypeToArc4EncodedType, cs as readonlyDecorator, ct as sizeOfFunction, cu as stringPType, cv as submitGroupItxnFunction, cw as transactionTypeType, cx as uint64PType, cy as undefinedPType, cz as unknownPType, cA as urangeFunction, cB as voidPType, cC as vrfVerifyPType, cD as uint8ArrayToHex, cE as hexToUint8Array } from './options--REGWlBH.js';
+export { cK as CompileOptions, cH as TypeResolver, cI as compile, cJ as processInputPaths, cF as registerPTypes, cG as typeRegistry } from './options--REGWlBH.js';
 import 'tslib';
 import 'fs';
 import 'node:async_hooks';
@@ -176,7 +176,6 @@ var forExport = /*#__PURE__*/Object.freeze({
     arc4BaseContractType: arc4BaseContractType,
     arc4BooleanType: arc4BooleanType,
     arc4ByteAlias: arc4ByteAlias,
-    arc4EncodedLengthFunction: arc4EncodedLengthFunction,
     arc4StringType: arc4StringType,
     arc4StructBaseType: arc4StructBaseType,
     arc4Uint64: arc4Uint64,
@@ -242,6 +241,8 @@ var forExport = /*#__PURE__*/Object.freeze({
     paymentItxnParamsType: paymentItxnParamsType,
     paymentItxnType: paymentItxnType,
     ptypeToArc4EncodedType: ptypeToArc4EncodedType,
+    readonlyDecorator: readonlyDecorator,
+    sizeOfFunction: sizeOfFunction,
     stringPType: stringPType,
     submitGroupItxnFunction: submitGroupItxnFunction,
     transactionTypeType: transactionTypeType,

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'\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'\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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACuBO,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 { 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'\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'\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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACuBO,MAAM,YAAY,GAAG;IAC1B,gBAAgB;IAChB,kBAAkB;IAClB,eAAe;IACf,kBAAkB;IAClB,kBAAkB;IAClB,gBAAgB;IAChB,eAAe;IACf,kBAAkB;IAClB,kBAAkB;IAClB,kBAAkB;;;;;"}

package/{options-Bl9Dfnsn.js → options--REGWlBH.js}

@@ -1,4 +1,4 @@
-import { k as invariant, m as CodeError, z as zipStrict, C as Constants, S as SourceLocation, n as codeInvariant, N as NotSupported, t as throwError, I as InternalError, o as distinctByEquality, s as sortBy, q as instanceOfAny, l as logger, g as bigIntToUint8Array, v as tryConvertEnum, w as wrapInCodeError, f as base32ToUint8Array, x as hasFlags, y as isIn, A as intersectsFlags, B as normalisePath, D as toSubScript, j as enumFromValue, h as utf8ToUint8Array, d as uint8ArrayToUtf8, e as base64ToUint8Array, E as enumKeyFromValue, c as uint8ArrayToBase32, F as mkDirIfNotExists, G as patchErrorLocation, H as sameSets, J as expandMaybeArray, a as LoggingContext, L as LogLevel, r as resolvePuyaPath, K as generateTempDir, P as PuyaError } from './resolve-puya-path-BhHWvo7r.js';
+import { k as invariant, m as CodeError, z as zipStrict, C as Constants, S as SourceLocation, n as codeInvariant, N as NotSupported, t as throwError, I as InternalError, o as distinctByEquality, s as sortBy, q as instanceOfAny, l as logger, g as bigIntToUint8Array, v as tryConvertEnum, w as wrapInCodeError, f as base32ToUint8Array, x as hasFlags, y as isIn, A as intersectsFlags, B as normalisePath, D as toSubScript, j as enumFromValue, h as utf8ToUint8Array, d as uint8ArrayToUtf8, e as base64ToUint8Array, E as enumKeyFromValue, c as uint8ArrayToBase32, F as mkDirIfNotExists, G as patchErrorLocation, H as sameSets, J as expandMaybeArray, a as LoggingContext, L as LogLevel, r as resolvePuyaPath, K as generateTempDir, P as PuyaError } from './resolve-puya-path-CaVLCfDd.js';
 import { classes } from 'polytype';
 import { snakeCase } from 'change-case';
 import path from 'node:path';
@@ -1850,6 +1850,10 @@ const arc4AbiMethodDecorator = new LibFunctionType({
     module: Constants.moduleNames.algoTs.arc4.index,
     name: 'abimethod',
 });
+const readonlyDecorator = new LibFunctionType({
+    module: Constants.moduleNames.algoTs.arc4.index,
+    name: 'readonly',
+});
 const contractOptionsDecorator = new LibFunctionType({
     module: Constants.moduleNames.algoTs.baseContract,
     name: 'contract',
@@ -4713,8 +4717,8 @@ const encodeArc4Function = new LibFunctionType({
     name: 'encodeArc4',
     module: Constants.moduleNames.algoTs.arc4.index,
 });
-const arc4EncodedLengthFunction = new LibFunctionType({
-    name: 'arc4EncodedLength',
+const sizeOfFunction = new LibFunctionType({
+    name: 'sizeOf',
     module: Constants.moduleNames.algoTs.arc4.index,
 });
 const decodeArc4Function = new LibFunctionType({
@@ -5848,9 +5852,7 @@ function requireLValue(expr) {
 }
 class DecoratorDataBuilder extends NodeBuilder {
     data;
-    get ptype() {
-        return undefined;
-    }
+    ptype = undefined;
     constructor(sourceLocation, data) {
         super(sourceLocation);
         this.data = data;
@@ -6771,16 +6773,14 @@ const resourceEncodingMap = {
     value: 'value',
 };
 class Arc4BareMethodDecoratorBuilder extends NodeBuilder {
-    get ptype() {
-        return arc4BareMethodDecorator;
-    }
+    ptype = arc4BareMethodDecorator;
     call(args, typeArgs, sourceLocation) {
         const { args: [{ allowActions, onCreate }], } = parseFunctionArgs({
             args,
             typeArgs,
             genericTypeArgs: 1,
             callLocation: sourceLocation,
-            funcName: 'arc4.baremethod',
+            funcName: this.typeDescription,
             argSpec: (a) => [
                 a.obj({
                     allowActions: a.optional(stringPType, new ReadonlyArrayPType({ elementType: stringPType })),
@@ -6798,10 +6798,18 @@ class Arc4BareMethodDecoratorBuilder extends NodeBuilder {
         });
     }
 }
-class Arc4AbiMethodDecoratorBuilder extends NodeBuilder {
-    get ptype() {
-        return arc4AbiMethodDecorator;
+class ReadonlyDecoratorBuilder extends DecoratorDataBuilder {
+    ptype = readonlyDecorator;
+    constructor(sourceLocation) {
+        super(sourceLocation, {
+            type: Constants.symbolNames.readonlyDecoratorName,
+            readonly: true,
+            sourceLocation,
+        });
     }
+}
+class Arc4AbiMethodDecoratorBuilder extends NodeBuilder {
+    ptype = arc4AbiMethodDecorator;
     call(args, typeArgs, sourceLocation) {
         const { args: [{ allowActions, onCreate, readonly, name, resourceEncoding, defaultArguments }], } = parseFunctionArgs({
             args,
@@ -6829,7 +6837,7 @@ class Arc4AbiMethodDecoratorBuilder extends NodeBuilder {
             sourceLocation: sourceLocation,
             nameOverride: name ? requireStringConstant(name).value : undefined,
             resourceEncoding: resourceEncoding && mapStringConstant(resourceEncodingMap, resourceEncoding.resolve()),
-            readonly: readonly ? requireBooleanConstant(readonly).value : false,
+            readonly: readonly ? requireBooleanConstant(readonly).value : undefined,
             defaultArguments: resolveDefaultArguments(defaultArguments, sourceLocation),
         });
     }
@@ -10825,8 +10833,8 @@ class MethodSelectorFunctionBuilder extends FunctionBuilder {
         }
     }
 }
-class Arc4EncodedLengthFunctionBuilder extends FunctionBuilder {
-    ptype = arc4EncodedLengthFunction;
+class SizeOfFunctionBuilder extends FunctionBuilder {
+    ptype = sizeOfFunction;
     call(args, typeArgs, sourceLocation) {
         const { ptypes: [typeToEncode], } = parseFunctionArgs({
             args,
@@ -12848,6 +12856,10 @@ function bytesToFixed(builder, fixedType, sourceLocation) {
         }),
     }), fixedType);
 }
+const fixedConversionStrategyMap = {
+    'assert-length': 'assert-length',
+    'unsafe-cast': 'unsafe-cast',
+};
 class ToFixedLengthFunctionBuilder extends FunctionBuilder {
     builder;
     constructor(builder) {
@@ -12855,7 +12867,7 @@ class ToFixedLengthFunctionBuilder extends FunctionBuilder {
         this.builder = builder;
     }
     call(args, typeArgs, sourceLocation) {
-        const { args: [{ length, checked }], } = parseFunctionArgs({
+        const { args: [{ length, strategy }], } = parseFunctionArgs({
             args,
             typeArgs,
             callLocation: sourceLocation,
@@ -12864,14 +12876,14 @@ class ToFixedLengthFunctionBuilder extends FunctionBuilder {
             argSpec: (a) => [
                 a.obj({
                     length: a.required(NumericLiteralPType),
-                    checked: a.optional(boolPType),
+                    strategy: a.optional(stringPType),
                 }),
             ],
         });
         const sizeConst = requireIntegerConstant(length);
-        const assertLength = checked === undefined ? true : requireBooleanConstant(checked);
+        const parsedStrategy = strategy === undefined ? 'assert-length' : mapStringConstant(fixedConversionStrategyMap, strategy.resolve());
         const ptype = new BytesPType({ length: sizeConst.value });
-        if (assertLength) {
+        if (parsedStrategy === 'assert-length') {
             return bytesToFixed(this.builder, ptype, sourceLocation);
         }
         else {
@@ -20507,6 +20519,7 @@ function registerPTypes(typeRegistry) {
     typeRegistry.register({ ptype: AssetFunction, singletonEb: AssetFunctionBuilder });
     typeRegistry.register({ ptype: assetPType, instanceEb: AssetExpressionBuilder });
     // ARC4 encoded
+    typeRegistry.register({ ptype: readonlyDecorator, singletonEb: ReadonlyDecoratorBuilder });
     typeRegistry.register({ ptype: arc4AbiMethodDecorator, singletonEb: Arc4AbiMethodDecoratorBuilder });
     typeRegistry.register({ ptype: arc4BareMethodDecorator, singletonEb: Arc4BareMethodDecoratorBuilder });
     typeRegistry.register({ ptype: ByteClass, singletonEb: classBuilderForUintNAlias(ByteClass, arc4ByteAlias) });
@@ -20571,7 +20584,7 @@ function registerPTypes(typeRegistry) {
     typeRegistry.register({ ptype: encodeArc4Function, singletonEb: EncodeArc4FunctionBuilder });
     typeRegistry.register({ ptype: decodeArc4Function, singletonEb: DecodeArc4FunctionBuilder });
     typeRegistry.register({ ptype: methodSelectorFunction, singletonEb: MethodSelectorFunctionBuilder });
-    typeRegistry.register({ ptype: arc4EncodedLengthFunction, singletonEb: Arc4EncodedLengthFunctionBuilder });
+    typeRegistry.register({ ptype: sizeOfFunction, singletonEb: SizeOfFunctionBuilder });
     typeRegistry.register({ ptype: compileArc4Function, singletonEb: CompileArc4FunctionBuilder });
     typeRegistry.register({ ptype: abiCallFunction, singletonEb: AbiCallFunctionBuilder });
     typeRegistry.registerGeneric({ ptype: ContractProxyType, generic: ContractProxyGeneric, instanceEb: ContractProxyExpressionBuilder });
@@ -22580,8 +22593,66 @@ class DecoratorVisitor extends BaseVisitor {
         return DecoratorVisitor.filterDecoratorData(data, ['logicsig'], (t) => `${t} is not supported on logic signatures`, 'Only one decorator is allowed per logic signature.');
     }
     static buildContractMethodData(target) {
-        const data = DecoratorVisitor.buildDecoratorData(target);
-        return DecoratorVisitor.filterDecoratorData(data, ['arc4.abimethod', 'arc4.baremethod'], (t) => `${t} is not supported on contract methods`, 'Only one decorator is allowed per method. Multiple on complete actions can be provided in a single decorator');
+        let abiDecorator = undefined;
+        let bareDecorator = undefined;
+        let readonlyDecorator = undefined;
+        for (const data of DecoratorVisitor.buildDecoratorData(target)) {
+            switch (data.type) {
+                case 'arc4.abimethod':
+                    if (abiDecorator) {
+                        logger.error(data.sourceLocation, 'Only one abimethod decorator is allowed per method. Multiple on complete actions can be provided in a single decorator');
+                    }
+                    else if (bareDecorator) {
+                        logger.error(data.sourceLocation, 'abimethod and baremethod decorators can not be combined on the one method');
+                    }
+                    else {
+                        abiDecorator = data;
+                    }
+                    break;
+                case 'arc4.baremethod':
+                    if (bareDecorator) {
+                        logger.error(data.sourceLocation, 'Only one baremethod decorator is allowed per method. Multiple on complete actions can be provided in a single decorator');
+                    }
+                    else if (abiDecorator) {
+                        logger.error(data.sourceLocation, 'abimethod and baremethod decorators can not be combined on the one method');
+                    }
+                    else {
+                        bareDecorator = data;
+                    }
+                    break;
+                case 'arc4.readonly':
+                    if (readonlyDecorator) {
+                        logger.error(data.sourceLocation, 'Only one readonly decorator is allowed per method');
+                    }
+                    else {
+                        readonlyDecorator = data;
+                    }
+                    break;
+                default:
+                    logger.error(data.sourceLocation, `${data.type} is not supported on contract methods`);
+            }
+        }
+        if (abiDecorator) {
+            if (readonlyDecorator) {
+                if (abiDecorator.readonly === false) {
+                    logger.error(readonlyDecorator.sourceLocation, 'abimethod decorator readonly config conflicts with presence of readonly decorator');
+                }
+                else {
+                    abiDecorator.readonly = true;
+                }
+            }
+            return abiDecorator;
+        }
+        else if (bareDecorator) {
+            if (readonlyDecorator) {
+                logger.error(readonlyDecorator.sourceLocation, 'baremethod cannot be annotated with readonly decorator');
+            }
+            return bareDecorator;
+        }
+        else if (readonlyDecorator) {
+            return readonlyDecorator;
+        }
+        return undefined;
     }
     static filterDecoratorData(decoratorData, types, notSupportedMessage, duplicateMessage) {
         let data;
@@ -23144,7 +23215,7 @@ class ContractMethodVisitor extends ContractMethodBaseVisitor {
         if (decorator?.type === 'arc4.abimethod') {
             this.checkABIMethodTypes(functionType, decorator.resourceEncoding ?? 'value', methodLocation);
             return new ARC4ABIMethodConfig({
-                readonly: decorator.readonly,
+                readonly: decorator.readonly ?? false,
                 sourceLocation: decorator.sourceLocation,
                 allowedCompletionTypes: decorator.allowedCompletionTypes ?? conventionalDefaults?.allowedCompletionTypes ?? unspecifiedDefaults.allowedCompletionTypes,
                 create: decorator.create ?? conventionalDefaults?.create ?? unspecifiedDefaults.create,
@@ -23169,14 +23240,14 @@ class ContractMethodVisitor extends ContractMethodBaseVisitor {
                 sourceLocation: methodLocation,
                 name: functionType.name,
                 resourceEncoding: 'value',
-                readonly: false,
+                readonly: decorator?.readonly ?? false,
                 defaultArgs: new Map(),
             });
         }
         return null;
     }
     validateDecoratorRoutingData(functionType, decorator, impliedByConvention) {
-        if (!decorator || !impliedByConvention)
+        if (!decorator || !impliedByConvention || decorator.type === 'arc4.readonly')
             return;
         if (decorator.allowedCompletionTypes !== undefined &&
             impliedByConvention.allowedCompletionTypes !== undefined &&
@@ -24487,5 +24558,5 @@ class PuyaOptions {
     }
 }
 
-export { GeneratorGeneric as $, ABICompatibleInstanceType as A, BaseContractClassType as B, BooleanFunction as C, BoxGeneric as D, BoxMapGeneric as E, BoxMapPType as F, BoxPType as G, BoxRefFunction as H, BoxRefPType as I, ByteClass as J, BytesFunction as K, BytesGeneric as L, BytesPType as M, ClassMethodDecoratorContext as N, ClearStateProgram as O, ClusteredContractClassType as P, ClusteredPrototype as Q, ContractClassPType as R, ContractProxyGeneric as S, ContractProxyType as T, DynamicArrayGeneric as U, DynamicArrayType as V, DynamicBytesConstructor as W, DynamicBytesType as X, FixedArrayGeneric as Y, FixedArrayPType as Z, FunctionPType as _, ALL_OP_ENUMS as a, UintN128Class as a$, GeneratorType as a0, GenericPType as a1, GlobalStateGeneric as a2, GlobalStateType as a3, GroupTransactionPType as a4, ImmutableObjectPType as a5, InnerTransactionPType as a6, InstanceType as a7, InternalType as a8, IntersectionPType as a9, PromiseType as aA, ReadonlyArrayGeneric as aB, ReadonlyArrayPType as aC, ReadonlyGeneric as aD, ReadonlyTuplePType as aE, ReferenceArrayGeneric as aF, ReferenceArrayType as aG, StaticArrayGeneric as aH, StaticArrayType as aI, StaticBytesGeneric as aJ, StaticBytesType as aK, StringFunction as aL, SuperPrototypeSelector as aM, SuperPrototypeSelectorGeneric as aN, TemplateVarFunction as aO, TransactionFunction as aP, TransactionFunctionType as aQ, TransientType as aR, TypeParameterType as aS, TypedApplicationCallResponseGeneric as aT, TypedApplicationCallResponseType as aU, UFixedNxMGeneric as aV, UFixedNxMType as aW, Uint64EnumMemberLiteralType as aX, Uint64EnumMemberType as aY, Uint64EnumType as aZ, Uint64Function as a_, IntrinsicEnumType as aa, IntrinsicFunctionGroupType as ab, IntrinsicFunctionGroupTypeType as ac, IntrinsicFunctionType as ad, IntrinsicFunctionTypeType as ae, IterableIteratorGeneric as af, IterableIteratorType as ag, ItxnParamsPType as ah, KeyRegistrationTxnFunction as ai, LibClassType as aj, LibFunctionType as ak, LibObjType as al, LocalStateGeneric as am, LocalStateType as an, LogicSigPType as ao, MutableObjectPType as ap, MutableTuplePType as aq, NamespacePType as ar, NumberPType as as, NumericLiteralPType as at, ObjectLiteralPType as au, ObjectWithOptionalFieldsType as av, PType as aw, PaymentTxnFunction as ax, PolytypeClassMethodHelper as ay, PromiseGeneric as az, ARC4ArrayType as b, ensureBudgetFunction as b$, UintN16Class as b0, UintN256Class as b1, UintN32Class as b2, UintN64Class as b3, UintN8Class as b4, UintNGeneric as b5, UintNType as b6, UnionPType as b7, UnsupportedType as b8, abiCallFunction as b9, assetConfigItxnType as bA, assetFreezeGtxnType as bB, assetFreezeItxnFn as bC, assetFreezeItxnParamsType as bD, assetFreezeItxnType as bE, assetPType as bF, assetTransferGtxnType as bG, assetTransferItxnFn as bH, assetTransferItxnParamsType as bI, assetTransferItxnType as bJ, base64PType as bK, baseContractType as bL, bigIntPType as bM, biguintPType as bN, boolPType as bO, boxRefType as bP, bytesPType as bQ, cloneFunctionPType as bR, compileArc4Function as bS, compileFunctionType as bT, compiledContractType as bU, compiledLogicSigType as bV, contractOptionsDecorator as bW, decodeArc4Function as bX, ecPType as bY, ecdsaPType as bZ, encodeArc4Function as b_, accountPType as ba, anyGtxnType as bb, anyItxnParamsType as bc, anyItxnType as bd, anyPType as be, applicationCallGtxnType as bf, applicationCallItxnFn as bg, applicationCallItxnParamsType as bh, applicationItxnType as bi, applicationPType as bj, arc28EmitFunction as bk, arc4AbiMethodDecorator as bl, arc4AddressAlias as bm, arc4BareMethodDecorator as bn, arc4BaseContractType as bo, arc4BooleanType as bp, arc4ByteAlias as bq, arc4EncodedLengthFunction as br, arc4StringType as bs, arc4StructBaseType as bt, arc4Uint64 as bu, assertFunction as bv, assertMatchFunction as bw, assetConfigGtxnType as bx, assetConfigItxnFn as by, assetConfigItxnParamsType as bz, ARC4BoolClass as c, errFunction as c0, esSymbol as c1, inputOnlyObjects as c2, interpretAsArc4Function as c3, isArrayType as c4, isObjectType$1 as c5, isTupleLike as c6, itoaMethod as c7, itxnComposePType as c8, keyRegistrationGtxnType as c9, voidPType as cA, vrfVerifyPType as cB, uint8ArrayToHex as cC, hexToUint8Array as cD, registerPTypes as cE, typeRegistry as cF, TypeResolver as cG, compile as cH, processInputPaths as cI, CompileOptions as cJ, defaultPuyaOptions as cK, parseCliTemplateVar as cL, LocalsCoalescingStrategy as cM, keyRegistrationItxnFn as ca, keyRegistrationItxnParamsType as cb, keyRegistrationItxnType as cc, logFunction as cd, logicSigBaseType as ce, logicSigOptionsDecorator as cf, matchFunction as cg, methodSelectorFunction as ch, mimcConfigurationsPType as ci, neverPType as cj, nullPType as ck, numberPType as cl, onCompleteActionType as cm, opUpFeeSourceType as cn, paymentGtxnType as co, paymentItxnFn as cp, paymentItxnParamsType as cq, paymentItxnType as cr, ptypeToArc4EncodedType as cs, stringPType as ct, submitGroupItxnFunction as cu, transactionTypeType as cv, uint64PType as cw, undefinedPType as cx, unknownPType as cy, urangeFunction as cz, ARC4EncodedType as d, ARC4InstanceType as e, ARC4StrClass as f, ARC4StructClass as g, ARC4StructType as h, ARC4TupleType as i, AccountFunction as j, AddressClass as k, AnyPType as l, ApplicationFunctionType as m, ApplicationTxnFunction as n, ApprovalProgram as o, Arc4TupleGeneric as p, ArrayGeneric as q, ArrayLiteralPType as r, ArrayPType as s, AssetConfigTxnFunction as t, AssetFreezeTxnFunction as u, AssetFunction as v, AssetTransferTxnFunction as w, BigIntLiteralPType as x, BigIntPType as y, BigUintFunction as z };
-//# sourceMappingURL=options-Bl9Dfnsn.js.map
+export { GeneratorGeneric as $, ABICompatibleInstanceType as A, BaseContractClassType as B, BooleanFunction as C, BoxGeneric as D, BoxMapGeneric as E, BoxMapPType as F, BoxPType as G, BoxRefFunction as H, BoxRefPType as I, ByteClass as J, BytesFunction as K, BytesGeneric as L, BytesPType as M, ClassMethodDecoratorContext as N, ClearStateProgram as O, ClusteredContractClassType as P, ClusteredPrototype as Q, ContractClassPType as R, ContractProxyGeneric as S, ContractProxyType as T, DynamicArrayGeneric as U, DynamicArrayType as V, DynamicBytesConstructor as W, DynamicBytesType as X, FixedArrayGeneric as Y, FixedArrayPType as Z, FunctionPType as _, ALL_OP_ENUMS as a, UintN128Class as a$, GeneratorType as a0, GenericPType as a1, GlobalStateGeneric as a2, GlobalStateType as a3, GroupTransactionPType as a4, ImmutableObjectPType as a5, InnerTransactionPType as a6, InstanceType as a7, InternalType as a8, IntersectionPType as a9, PromiseType as aA, ReadonlyArrayGeneric as aB, ReadonlyArrayPType as aC, ReadonlyGeneric as aD, ReadonlyTuplePType as aE, ReferenceArrayGeneric as aF, ReferenceArrayType as aG, StaticArrayGeneric as aH, StaticArrayType as aI, StaticBytesGeneric as aJ, StaticBytesType as aK, StringFunction as aL, SuperPrototypeSelector as aM, SuperPrototypeSelectorGeneric as aN, TemplateVarFunction as aO, TransactionFunction as aP, TransactionFunctionType as aQ, TransientType as aR, TypeParameterType as aS, TypedApplicationCallResponseGeneric as aT, TypedApplicationCallResponseType as aU, UFixedNxMGeneric as aV, UFixedNxMType as aW, Uint64EnumMemberLiteralType as aX, Uint64EnumMemberType as aY, Uint64EnumType as aZ, Uint64Function as a_, IntrinsicEnumType as aa, IntrinsicFunctionGroupType as ab, IntrinsicFunctionGroupTypeType as ac, IntrinsicFunctionType as ad, IntrinsicFunctionTypeType as ae, IterableIteratorGeneric as af, IterableIteratorType as ag, ItxnParamsPType as ah, KeyRegistrationTxnFunction as ai, LibClassType as aj, LibFunctionType as ak, LibObjType as al, LocalStateGeneric as am, LocalStateType as an, LogicSigPType as ao, MutableObjectPType as ap, MutableTuplePType as aq, NamespacePType as ar, NumberPType as as, NumericLiteralPType as at, ObjectLiteralPType as au, ObjectWithOptionalFieldsType as av, PType as aw, PaymentTxnFunction as ax, PolytypeClassMethodHelper as ay, PromiseGeneric as az, ARC4ArrayType as b, errFunction as b$, UintN16Class as b0, UintN256Class as b1, UintN32Class as b2, UintN64Class as b3, UintN8Class as b4, UintNGeneric as b5, UintNType as b6, UnionPType as b7, UnsupportedType as b8, abiCallFunction as b9, assetFreezeGtxnType as bA, assetFreezeItxnFn as bB, assetFreezeItxnParamsType as bC, assetFreezeItxnType as bD, assetPType as bE, assetTransferGtxnType as bF, assetTransferItxnFn as bG, assetTransferItxnParamsType as bH, assetTransferItxnType as bI, base64PType as bJ, baseContractType as bK, bigIntPType as bL, biguintPType as bM, boolPType as bN, boxRefType as bO, bytesPType as bP, cloneFunctionPType as bQ, compileArc4Function as bR, compileFunctionType as bS, compiledContractType as bT, compiledLogicSigType as bU, contractOptionsDecorator as bV, decodeArc4Function as bW, ecPType as bX, ecdsaPType as bY, encodeArc4Function as bZ, ensureBudgetFunction as b_, accountPType as ba, anyGtxnType as bb, anyItxnParamsType as bc, anyItxnType as bd, anyPType as be, applicationCallGtxnType as bf, applicationCallItxnFn as bg, applicationCallItxnParamsType as bh, applicationItxnType as bi, applicationPType as bj, arc28EmitFunction as bk, arc4AbiMethodDecorator as bl, arc4AddressAlias as bm, arc4BareMethodDecorator as bn, arc4BaseContractType as bo, arc4BooleanType as bp, arc4ByteAlias as bq, arc4StringType as br, arc4StructBaseType as bs, arc4Uint64 as bt, assertFunction as bu, assertMatchFunction as bv, assetConfigGtxnType as bw, assetConfigItxnFn as bx, assetConfigItxnParamsType as by, assetConfigItxnType as bz, ARC4BoolClass as c, esSymbol as c0, inputOnlyObjects as c1, interpretAsArc4Function as c2, isArrayType as c3, isObjectType$1 as c4, isTupleLike as c5, itoaMethod as c6, itxnComposePType as c7, keyRegistrationGtxnType as c8, keyRegistrationItxnFn as c9, urangeFunction as cA, voidPType as cB, vrfVerifyPType as cC, uint8ArrayToHex as cD, hexToUint8Array as cE, registerPTypes as cF, typeRegistry as cG, TypeResolver as cH, compile as cI, processInputPaths as cJ, CompileOptions as cK, defaultPuyaOptions as cL, parseCliTemplateVar as cM, LocalsCoalescingStrategy as cN, keyRegistrationItxnParamsType as ca, keyRegistrationItxnType as cb, logFunction as cc, logicSigBaseType as cd, logicSigOptionsDecorator as ce, matchFunction as cf, methodSelectorFunction as cg, mimcConfigurationsPType as ch, neverPType as ci, nullPType as cj, numberPType as ck, onCompleteActionType as cl, opUpFeeSourceType as cm, paymentGtxnType as cn, paymentItxnFn as co, paymentItxnParamsType as cp, paymentItxnType as cq, ptypeToArc4EncodedType as cr, readonlyDecorator as cs, sizeOfFunction as ct, stringPType as cu, submitGroupItxnFunction as cv, transactionTypeType as cw, uint64PType as cx, undefinedPType as cy, unknownPType as cz, ARC4EncodedType as d, ARC4InstanceType as e, ARC4StrClass as f, ARC4StructClass as g, ARC4StructType as h, ARC4TupleType as i, AccountFunction as j, AddressClass as k, AnyPType as l, ApplicationFunctionType as m, ApplicationTxnFunction as n, ApprovalProgram as o, Arc4TupleGeneric as p, ArrayGeneric as q, ArrayLiteralPType as r, ArrayPType as s, AssetConfigTxnFunction as t, AssetFreezeTxnFunction as u, AssetFunction as v, AssetTransferTxnFunction as w, BigIntLiteralPType as x, BigIntPType as y, BigUintFunction as z };
+//# sourceMappingURL=options--REGWlBH.js.map