@algorandfoundation/algorand-typescript 0.0.1-alpha.1

package/index-7MfWJL4Q.js

@@ -0,0 +1,741 @@
+import { TextDecoder } from 'node:util';
+
+const BASE32_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'.split('');
+const CHAR_TO_NUM = BASE32_ALPHABET.reduce((acc, cur, index) => ((acc[cur] = index), acc), {});
+const base32ToUint8Array = (value) => {
+    let allChars = value
+        .split('')
+        .filter((c) => c !== '=')
+        .map((c) => {
+        const cUpper = c.toUpperCase();
+        if (cUpper in CHAR_TO_NUM)
+            return CHAR_TO_NUM[cUpper];
+        throw new Error(`Invalid base32 char ${c}`);
+    });
+    const bytes = new Array();
+    while (allChars.length) {
+        const [a, b, c, d, e, f, g, h, ...rest] = allChars;
+        if (a === undefined || b === undefined)
+            break;
+        bytes.push(((a << 3) | (b >>> 2)) & 255);
+        if (c === undefined || d === undefined)
+            break;
+        bytes.push(((b << 6) | (c << 1) | (d >>> 4)) & 255);
+        if (e === undefined)
+            break;
+        bytes.push(((d << 4) | (e >>> 1)) & 255);
+        if (f === undefined || g === undefined)
+            break;
+        bytes.push(((e << 7) | (f << 2) | (g >>> 3)) & 255);
+        if (h === undefined)
+            break;
+        bytes.push(((g << 5) | h) & 255);
+        allChars = rest;
+    }
+    return new Uint8Array(bytes);
+};
+const uint8ArrayToBase32 = (value) => {
+    let allBytes = Array.from(value);
+    let base32str = '';
+    while (allBytes.length) {
+        const [a, b, c, d, e, ...rest] = allBytes ?? [0, 0, 0, 0, 0];
+        if (allBytes.length < 1)
+            break;
+        base32str += BASE32_ALPHABET[a >>> 3];
+        base32str += BASE32_ALPHABET[((a << 2) | ((b || 0) >>> 6)) & 32];
+        if (allBytes.length < 2)
+            break;
+        base32str += BASE32_ALPHABET[(b >>> 1) & 31];
+        base32str += BASE32_ALPHABET[((b << 4) | (c >>> 4)) & 31];
+        if (allBytes.length < 3)
+            break;
+        base32str += BASE32_ALPHABET[((c << 1) | (d >>> 7)) & 31];
+        if (allBytes.length < 4)
+            break;
+        base32str += BASE32_ALPHABET[(d >>> 2) & 31];
+        base32str += BASE32_ALPHABET[((d << 3) | (e >>> 5)) & 31];
+        if (allBytes.length < 5)
+            break;
+        base32str += BASE32_ALPHABET[e & 31];
+        allBytes = rest;
+    }
+    return base32str;
+};
+
+/**
+ * Raised when an `err` op is encountered, or when the testing VM is asked to do something that would cause
+ * the AVM to fail.
+ */
+class AvmError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+function avmError(message) {
+    throw new AvmError(message);
+}
+/**
+ * Raised when an assertion fails
+ */
+class AssertError extends AvmError {
+    constructor(message) {
+        super(message);
+    }
+}
+/**
+ * Raised when testing code errors
+ */
+class InternalError extends Error {
+    constructor(message, options) {
+        super(message, options);
+    }
+}
+function internalError(message) {
+    throw new InternalError(message);
+}
+/**
+ * Raised when unsupported user code is encountered
+ */
+class CodeError extends Error {
+    constructor(message, options) {
+        super(message, options);
+    }
+}
+function codeError(message) {
+    throw new CodeError(message);
+}
+
+var errors = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AssertError: AssertError,
+    AvmError: AvmError,
+    CodeError: CodeError,
+    InternalError: InternalError,
+    avmError: avmError,
+    codeError: codeError,
+    internalError: internalError
+});
+
+const uint8ArrayToBigInt = (v) => {
+    // Assume big-endian
+    return Array.from(v)
+        .toReversed()
+        .map((byte_value, i) => BigInt(byte_value) << BigInt(i * 8))
+        .reduce((a, b) => a + b, 0n);
+};
+const bigIntToUint8Array = (val, fixedSize = 'dynamic') => {
+    if (val === 0n && fixedSize === 'dynamic') {
+        return new Uint8Array(0);
+    }
+    const maxBytes = fixedSize === 'dynamic' ? undefined : fixedSize;
+    let hex = val.toString(16);
+    // Pad the hex with zeros so it matches the size in bytes
+    if (fixedSize !== 'dynamic' && hex.length !== fixedSize * 2) {
+        hex = hex.padStart(fixedSize * 2, '0');
+    }
+    else if (hex.length % 2 == 1) {
+        // Pad to 'whole' byte
+        hex = `0${hex}`;
+    }
+    if (maxBytes && hex.length > maxBytes * 2) {
+        throw new AvmError(`Cannot encode ${val} as ${maxBytes} bytes as it would overflow`);
+    }
+    const byteArray = new Uint8Array(hex.length / 2);
+    for (let i = 0, j = 0; i < hex.length / 2; i++, j += 2) {
+        byteArray[i] = parseInt(hex.slice(j, j + 2), 16);
+    }
+    return byteArray;
+};
+const utf8ToUint8Array = (value) => {
+    const encoder = new TextEncoder();
+    return encoder.encode(value);
+};
+const uint8ArrayToUtf8 = (value) => {
+    const decoder = new TextDecoder();
+    return decoder.decode(value);
+};
+const uint8ArrayToHex = (value) => Buffer.from(value).toString('hex');
+const uint8ArrayToBase64 = (value) => Buffer.from(value).toString('base64');
+const uint8ArrayToBase64Url = (value) => Buffer.from(value).toString('base64url');
+
+var encodingUtil = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    bigIntToUint8Array: bigIntToUint8Array,
+    uint8ArrayToBase32: uint8ArrayToBase32,
+    uint8ArrayToBase64: uint8ArrayToBase64,
+    uint8ArrayToBase64Url: uint8ArrayToBase64Url,
+    uint8ArrayToBigInt: uint8ArrayToBigInt,
+    uint8ArrayToHex: uint8ArrayToHex,
+    uint8ArrayToUtf8: uint8ArrayToUtf8,
+    utf8ToUint8Array: utf8ToUint8Array
+});
+
+const nameOfType = (x) => {
+    if (typeof x === 'object') {
+        if (x === null)
+            return 'Null';
+        if (x === undefined)
+            return 'undefined';
+        if ('constructor' in x) {
+            return x.constructor.name;
+        }
+    }
+    return typeof x;
+};
+
+const MAX_UINT8 = 2 ** 8 - 1;
+const MAX_BYTES_SIZE = 4096;
+function toExternalValue(val) {
+    const instance = val;
+    if (instance instanceof BytesCls)
+        return instance.asUint8Array();
+    if (instance instanceof Uint64Cls)
+        return instance.asBigInt();
+    if (instance instanceof BigUintCls)
+        return instance.asBigInt();
+    if (typeof val === 'string')
+        return val;
+}
+const toBytes = (val) => {
+    if (val instanceof AlgoTsPrimitiveCls)
+        return val.toBytes().asAlgoTs();
+    switch (typeof val) {
+        case 'string':
+            return BytesCls.fromCompat(val).asAlgoTs();
+        case 'bigint':
+            return BigUintCls.fromCompat(val).toBytes().asAlgoTs();
+        case 'number':
+            return Uint64Cls.fromCompat(val).toBytes().asAlgoTs();
+        default:
+            internalError(`Unsupported arg type ${nameOfType(val)}`);
+    }
+};
+const isBytes = (v) => {
+    if (typeof v === 'string')
+        return true;
+    if (v instanceof BytesCls)
+        return true;
+    return v instanceof Uint8Array;
+};
+const isUint64 = (v) => {
+    if (typeof v == 'boolean')
+        return true;
+    if (typeof v == 'number')
+        return true;
+    if (typeof v == 'bigint')
+        return true;
+    return v instanceof Uint64Cls;
+};
+const isBigUint = (v) => {
+    return v instanceof BigUintCls;
+};
+const checkUint64 = (v) => {
+    const u64 = BigInt.asUintN(64, v);
+    if (u64 !== v)
+        throw new AvmError(`Uint64 over or underflow`);
+    return u64;
+};
+const checkBigUint = (v) => {
+    const uBig = BigInt.asUintN(64 * 8, v);
+    if (uBig !== v)
+        throw new AvmError(`BigUint over or underflow`);
+    return uBig;
+};
+const checkBytes = (v) => {
+    if (v.length > MAX_BYTES_SIZE)
+        throw new AvmError(`Bytes length ${v.length} exceeds maximum length ${MAX_BYTES_SIZE}`);
+    return v;
+};
+class AlgoTsPrimitiveCls {
+    _type = AlgoTsPrimitiveCls.name;
+    constructor(t) {
+        this._type = `${AlgoTsPrimitiveCls.name}.${t}`;
+    }
+    static [Symbol.hasInstance](x) {
+        return x instanceof Object && '_type' in x && x['_type'].startsWith(AlgoTsPrimitiveCls.name);
+    }
+}
+class Uint64Cls extends AlgoTsPrimitiveCls {
+    value;
+    constructor(value) {
+        super(Uint64Cls.name);
+        this.value = BigInt(value);
+        checkUint64(this.value);
+    }
+    static [Symbol.hasInstance](x) {
+        return x instanceof Object && '_type' in x && x['_type'].endsWith(Uint64Cls.name);
+    }
+    static fromCompat(v) {
+        if (typeof v == 'boolean')
+            return new Uint64Cls(v ? 1n : 0n);
+        if (typeof v == 'number')
+            return new Uint64Cls(BigInt(v));
+        if (typeof v == 'bigint')
+            return new Uint64Cls(v);
+        if (v instanceof Uint64Cls)
+            return v;
+        internalError(`Cannot convert ${v} to uint64`);
+    }
+    static getNumber(v) {
+        return Uint64Cls.fromCompat(v).asNumber();
+    }
+    valueOf() {
+        return this.value;
+    }
+    toBytes(isDynamic = false) {
+        return new BytesCls(bigIntToUint8Array(this.value, isDynamic ? 'dynamic' : 8));
+    }
+    asAlgoTs() {
+        return this;
+    }
+    asBigInt() {
+        return this.value;
+    }
+    asNumber() {
+        if (this.value > Number.MAX_SAFE_INTEGER) {
+            throw new AvmError('value cannot be safely converted to a number');
+        }
+        return Number(this.value);
+    }
+}
+class BigUintCls extends AlgoTsPrimitiveCls {
+    value;
+    constructor(value) {
+        super(BigUintCls.name);
+        this.value = value;
+    }
+    valueOf() {
+        return this.value;
+    }
+    toBytes() {
+        return new BytesCls(bigIntToUint8Array(this.value));
+    }
+    asAlgoTs() {
+        return this;
+    }
+    asBigInt() {
+        return this.value;
+    }
+    asNumber() {
+        if (this.value > Number.MAX_SAFE_INTEGER) {
+            throw new AvmError('value cannot be safely converted to a number');
+        }
+        return Number(this.value);
+    }
+    static [Symbol.hasInstance](x) {
+        return x instanceof Object && '_type' in x && x['_type'].endsWith(BigUintCls.name);
+    }
+    static fromCompat(v) {
+        if (typeof v == 'boolean')
+            return new BigUintCls(v ? 1n : 0n);
+        if (typeof v == 'number')
+            return new BigUintCls(BigInt(v));
+        if (typeof v == 'bigint')
+            return new BigUintCls(v);
+        if (v instanceof Uint64Cls)
+            return new BigUintCls(v.value);
+        if (v instanceof BytesCls)
+            return v.toBigUint();
+        if (v instanceof BigUintCls)
+            return v;
+        internalError(`Cannot convert ${nameOfType(v)} to BigUint`);
+    }
+}
+class BytesCls extends AlgoTsPrimitiveCls {
+    #v;
+    constructor(v) {
+        super(BytesCls.name);
+        this.#v = v;
+        checkBytes(this.#v);
+    }
+    get length() {
+        return new Uint64Cls(this.#v.length);
+    }
+    toBytes() {
+        return this;
+    }
+    at(i) {
+        const start = Uint64Cls.fromCompat(i).asNumber();
+        return new BytesCls(this.#v.slice(start, start + 1));
+    }
+    slice(start, end) {
+        const startNumber = start instanceof Uint64Cls ? start.asNumber() : start;
+        const endNumber = end instanceof Uint64Cls ? end.asNumber() : end;
+        const sliced = arrayUtil.arraySlice(this.#v, startNumber, endNumber);
+        return new BytesCls(sliced);
+    }
+    concat(other) {
+        const otherArray = BytesCls.fromCompat(other).asUint8Array();
+        const mergedArray = new Uint8Array(this.#v.length + otherArray.length);
+        mergedArray.set(this.#v);
+        mergedArray.set(otherArray, this.#v.length);
+        return new BytesCls(mergedArray);
+    }
+    bitwiseAnd(other) {
+        return this.bitwiseOp(other, (a, b) => a & b);
+    }
+    bitwiseOr(other) {
+        return this.bitwiseOp(other, (a, b) => a | b);
+    }
+    bitwiseXor(other) {
+        return this.bitwiseOp(other, (a, b) => a ^ b);
+    }
+    bitwiseInvert() {
+        const result = new Uint8Array(this.#v.length);
+        this.#v.forEach((v, i) => {
+            result[i] = ~v & MAX_UINT8;
+        });
+        return new BytesCls(result);
+    }
+    equals(other) {
+        const otherArray = BytesCls.fromCompat(other).asUint8Array();
+        if (this.#v.length !== otherArray.length)
+            return false;
+        for (let i = 0; i < this.#v.length; i++) {
+            if (this.#v[i] !== otherArray[i])
+                return false;
+        }
+        return true;
+    }
+    bitwiseOp(other, op) {
+        const otherArray = BytesCls.fromCompat(other).asUint8Array();
+        const result = new Uint8Array(Math.max(this.#v.length, otherArray.length));
+        for (let i = result.length - 1; i >= 0; i--) {
+            const thisIndex = i - (result.length - this.#v.length);
+            const otherIndex = i - (result.length - otherArray.length);
+            result[i] = op(this.#v[thisIndex] ?? 0, otherArray[otherIndex] ?? 0);
+        }
+        return new BytesCls(result);
+    }
+    valueOf() {
+        return uint8ArrayToUtf8(this.#v);
+    }
+    static [Symbol.hasInstance](x) {
+        return x instanceof Object && '_type' in x && x['_type'].endsWith(BytesCls.name);
+    }
+    static fromCompat(v) {
+        if (v === undefined)
+            return new BytesCls(new Uint8Array());
+        if (typeof v === 'string')
+            return new BytesCls(utf8ToUint8Array(v));
+        if (v instanceof BytesCls)
+            return v;
+        if (v instanceof Uint8Array)
+            return new BytesCls(v);
+        internalError(`Cannot convert ${nameOfType(v)} to bytes`);
+    }
+    static fromInterpolation(template, replacements) {
+        return template
+            .flatMap((templateText, index) => {
+            const replacement = replacements[index];
+            if (replacement) {
+                return [BytesCls.fromCompat(templateText), BytesCls.fromCompat(replacement)];
+            }
+            return [BytesCls.fromCompat(templateText)];
+        })
+            .reduce((a, b) => a.concat(b));
+    }
+    static fromHex(hex) {
+        return new BytesCls(Uint8Array.from(Buffer.from(hex, 'hex')));
+    }
+    static fromBase64(b64) {
+        return new BytesCls(Uint8Array.from(Buffer.from(b64, 'base64')));
+    }
+    static fromBase32(b32) {
+        return new BytesCls(base32ToUint8Array(b32));
+    }
+    toUint64() {
+        return new Uint64Cls(uint8ArrayToBigInt(this.#v));
+    }
+    toBigUint() {
+        return new BigUintCls(uint8ArrayToBigInt(this.#v));
+    }
+    toString() {
+        return this.valueOf();
+    }
+    asAlgoTs() {
+        return this;
+    }
+    asUint8Array() {
+        return this.#v;
+    }
+}
+const arrayUtil = new (class {
+    arrayAt(arrayLike, index) {
+        return arrayLike.at(Uint64Cls.fromCompat(index).asNumber()) ?? avmError('Index out of bounds');
+    }
+    arraySlice(arrayLike, start, end) {
+        return arrayLike.slice(Uint64Cls.getNumber(start), Uint64Cls.getNumber(end));
+    }
+})();
+
+var primitives = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AlgoTsPrimitiveCls: AlgoTsPrimitiveCls,
+    BigUintCls: BigUintCls,
+    BytesCls: BytesCls,
+    Uint64Cls: Uint64Cls,
+    arrayUtil: arrayUtil,
+    checkBigUint: checkBigUint,
+    checkBytes: checkBytes,
+    checkUint64: checkUint64,
+    isBigUint: isBigUint,
+    isBytes: isBytes,
+    isUint64: isUint64,
+    toBytes: toBytes,
+    toExternalValue: toExternalValue
+});
+
+function Uint64(v) {
+    return Uint64Cls.fromCompat(v).asAlgoTs();
+}
+function BigUint(v) {
+    return BigUintCls.fromCompat(v).asAlgoTs();
+}
+function Bytes(value, ...replacements) {
+    if (isTemplateStringsArray(value)) {
+        return BytesCls.fromInterpolation(value, replacements).asAlgoTs();
+    }
+    else {
+        return BytesCls.fromCompat(value).asAlgoTs();
+    }
+}
+/**
+ * Create a new bytes value from a hexadecimal encoded string
+ * @param hex
+ */
+Bytes.fromHex = (hex) => {
+    return BytesCls.fromHex(hex).asAlgoTs();
+};
+/**
+ * Create a new bytes value from a base 64 encoded string
+ * @param b64
+ */
+Bytes.fromBase64 = (b64) => {
+    return BytesCls.fromBase64(b64).asAlgoTs();
+};
+/**
+ * Create a new bytes value from a base 32 encoded string
+ * @param b32
+ */
+Bytes.fromBase32 = (b32) => {
+    return BytesCls.fromBase32(b32).asAlgoTs();
+};
+function isTemplateStringsArray(v) {
+    return Boolean(v) && Array.isArray(v) && typeof v[0] === 'string';
+}
+
+const ctxMgr = {
+    set instance(ctx) {
+        const instance = global.puyaTsExecutionContext;
+        if (instance != undefined)
+            throw new Error('Execution context has already been set');
+        global.puyaTsExecutionContext = ctx;
+    },
+    get instance() {
+        const instance = global.puyaTsExecutionContext;
+        if (instance == undefined)
+            throw new Error('No execution context has been set');
+        return instance;
+    },
+    reset() {
+        global.puyaTsExecutionContext = undefined;
+    },
+};
+
+function log(...args) {
+    ctxMgr.instance.log(args.map(toBytes).reduce((left, right) => left.concat(right)));
+}
+function assert(condition, message) {
+    if (!condition) {
+        throw new AssertError(message ?? 'Assertion failed');
+    }
+}
+function err(message) {
+    throw new AvmError(message ?? 'Err');
+}
+function match(subject, test) {
+    return true;
+}
+function assertMatch(subject, test, message) {
+    return true;
+}
+var OpUpFeeSource;
+(function (OpUpFeeSource) {
+    OpUpFeeSource[OpUpFeeSource["GroupCredit"] = 0] = "GroupCredit";
+    OpUpFeeSource[OpUpFeeSource["AppAccount"] = 1] = "AppAccount";
+    OpUpFeeSource[OpUpFeeSource["Any"] = 2] = "Any";
+})(OpUpFeeSource || (OpUpFeeSource = {}));
+function ensureBudget(budget, feeSource = OpUpFeeSource.GroupCredit) {
+    throw new Error('Not implemented');
+}
+function urange(a, b, c) {
+    throw new Error('Not implemented');
+}
+
+class BaseContract {
+    clearStateProgram() {
+        return true;
+    }
+}
+
+class AbiEncoded {
+    get bytes() {
+        throw new Error('todo');
+    }
+}
+class Str extends AbiEncoded {
+    constructor(s) {
+        super();
+    }
+    get native() {
+        throw new Error('TODO');
+    }
+}
+class UintN extends AbiEncoded {
+    constructor(v) {
+        super();
+    }
+    get native() {
+        throw new Error('TODO');
+    }
+}
+class UFixedNxM {
+    constructor(v, n, m) { }
+    get native() {
+        throw new Error('TODO');
+    }
+}
+class Byte extends UintN {
+    constructor(v) {
+        super(v);
+    }
+    get native() {
+        throw new Error('TODO');
+    }
+}
+class Bool {
+    #v;
+    constructor(v) {
+        this.#v = v;
+    }
+    get native() {
+        return this.#v;
+    }
+}
+class Arc4Array extends AbiEncoded {
+    items;
+    constructor(items) {
+        super();
+        this.items = items;
+    }
+    get length() {
+        throw new Error('TODO');
+    }
+    at(index) {
+        return arrayUtil.arrayAt(this.items, index);
+    }
+    slice(start, end) {
+        return new DynamicArray(...arrayUtil.arraySlice(this.items, start, end));
+    }
+    [Symbol.iterator]() {
+        return this.items[Symbol.iterator]();
+    }
+    entries() {
+        throw new Error('TODO');
+    }
+    keys() {
+        throw new Error('TODO');
+    }
+}
+class StaticArray extends Arc4Array {
+    constructor(...items) {
+        super(items);
+    }
+    copy() {
+        return new StaticArray(...this.items);
+    }
+}
+class DynamicArray extends Arc4Array {
+    constructor(...items) {
+        super(items);
+    }
+    push(...items) { }
+    pop() {
+        throw new Error('Not implemented');
+    }
+    copy() {
+        return new DynamicArray(...this.items);
+    }
+}
+class Tuple {
+    #items;
+    constructor(...items) {
+        this.#items = items;
+    }
+    at(index) {
+        return (this.#items[index] ?? err('Index out of bounds'));
+    }
+    get native() {
+        return this.#items;
+    }
+}
+class Address extends StaticArray {
+    constructor(value) {
+        super();
+    }
+    get native() {
+        throw new Error('TODO');
+    }
+}
+
+class Contract extends BaseContract {
+    approvalProgram() {
+        return true;
+    }
+}
+var OnCompleteAction;
+(function (OnCompleteAction) {
+    OnCompleteAction[OnCompleteAction["NoOp"] = Uint64(0)] = "NoOp";
+    OnCompleteAction[OnCompleteAction["OptIn"] = Uint64(1)] = "OptIn";
+    OnCompleteAction[OnCompleteAction["CloseOut"] = Uint64(2)] = "CloseOut";
+    OnCompleteAction[OnCompleteAction["ClearState"] = Uint64(3)] = "ClearState";
+    OnCompleteAction[OnCompleteAction["UpdateApplication"] = Uint64(4)] = "UpdateApplication";
+    OnCompleteAction[OnCompleteAction["DeleteApplication"] = Uint64(5)] = "DeleteApplication";
+})(OnCompleteAction || (OnCompleteAction = {}));
+function abimethod(config) {
+    return function (target, ctx) {
+        ctx.addInitializer(function () {
+            ctxMgr.instance.abiMetadata.captureMethodConfig(this, target.name, config);
+        });
+        return target;
+    };
+}
+function baremethod(config) {
+    return function (target, ctx) {
+        ctx.addInitializer(function () {
+            ctxMgr.instance.abiMetadata.captureMethodConfig(this, target.name, config);
+        });
+        return target;
+    };
+}
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    Address: Address,
+    Bool: Bool,
+    Byte: Byte,
+    Contract: Contract,
+    DynamicArray: DynamicArray,
+    get OnCompleteAction () { return OnCompleteAction; },
+    StaticArray: StaticArray,
+    Str: Str,
+    Tuple: Tuple,
+    UFixedNxM: UFixedNxM,
+    UintN: UintN,
+    abimethod: abimethod,
+    baremethod: baremethod
+});
+
+export { AssertError as A, BytesCls as B, Contract as C, DynamicArray as D, OpUpFeeSource as O, Str as S, Tuple as T, Uint64 as U, errors as a, err as b, ctxMgr as c, assert as d, encodingUtil as e, assertMatch as f, ensureBudget as g, abimethod as h, index as i, BaseContract as j, BigUint as k, log as l, match as m, Bytes as n, OnCompleteAction as o, primitives as p, baremethod as q, UintN as r, UFixedNxM as s, Byte as t, urange as u, Bool as v, StaticArray as w, Address as x };
+//# sourceMappingURL=index-7MfWJL4Q.js.map