@taquito/michel-codec 24.2.0 → 24.3.0-beta.0

package/dist/taquito-michel-codec.es6.js

@@ -5,7 +5,7 @@ const sourceReference = Symbol('source_reference');
 
 /**
  *  @category Error
- *  @description Error that indicates a failure when performing the scan step when parsing Michelson
+ *  Error that indicates a failure when performing the scan step when parsing Michelson
  */
 class ScanError extends TaquitoError {
     constructor(src, idx, message) {
@@ -207,7 +207,7 @@ function ProtoInferiorTo(a, b) {
 
 /**
  *  @category Error
- *  @description Error that indicates macros failed to be expanded
+ *  Error that indicates macros failed to be expanded
  */
 class MacroError extends TaquitoError {
     constructor(prim, message) {
@@ -218,11 +218,10 @@ class MacroError extends TaquitoError {
     }
 }
 function assertArgs$1(ex, n) {
-    var _a, _b;
-    if ((n === 0 && ex.args === undefined) || ((_a = ex.args) === null || _a === void 0 ? void 0 : _a.length) === n) {
+    if ((n === 0 && ex.args === undefined) || ex.args?.length === n) {
         return true;
     }
-    throw new MacroError(ex, `macro ${ex.prim} expects ${n} arguments, was given ${(_b = ex.args) === null || _b === void 0 ? void 0 : _b.length}`);
+    throw new MacroError(ex, `macro ${ex.prim} expects ${n} arguments, was given ${ex.args?.length}`);
 }
 function assertNoAnnots(ex) {
     if (ex.annots === undefined) {
@@ -340,7 +339,11 @@ function filterAnnotations(a) {
     return { fields, rest };
 }
 function mkPrim({ prim, annots, args }) {
-    return Object.assign(Object.assign({ prim }, (annots && { annots })), (args && { args }));
+    return {
+        prim,
+        ...(annots && { annots }),
+        ...(args && { args }),
+    };
 }
 const pairRe = /^P[PAI]{3,}R$/;
 const unpairRe = /^UNP[PAI]{2,}R$/;
@@ -350,7 +353,7 @@ const mapCadrRe = /^MAP_C[AD]+R$/;
 const diipRe = /^DI{2,}P$/;
 const duupRe = /^DU+P$/;
 function expandMacros(ex, opt) {
-    const proto = (opt === null || opt === void 0 ? void 0 : opt.protocol) || DefaultProtocol;
+    const proto = opt?.protocol || DefaultProtocol;
     function mayRename(annots) {
         return annots !== undefined ? [{ prim: 'RENAME', annots }] : [];
     }
@@ -759,7 +762,7 @@ function expandGlobalConstants(ex, hashAndValue) {
 
 /**
  *  @category Error
- *  @description Error that indicates a failure when parsing Micheline expressions
+ *  Error that indicates a failure when parsing Micheline expressions
  */
 class MichelineParseError extends TaquitoError {
     /**
@@ -775,7 +778,7 @@ class MichelineParseError extends TaquitoError {
 }
 /**
  *  @category Error
- *  @description Error indicates a failure when parsing Micheline JSON
+ *  Error indicates a failure when parsing Micheline JSON
  */
 class JSONParseError extends TaquitoError {
     /**
@@ -832,18 +835,20 @@ class Parser {
         this.opt = opt;
     }
     expand(ex) {
-        var _a, _b, _c;
-        if (((_a = this.opt) === null || _a === void 0 ? void 0 : _a.expandGlobalConstant) !== undefined && ex.prim === 'constant') {
+        if (this.opt?.expandGlobalConstant !== undefined && ex.prim === 'constant') {
             const ret = expandGlobalConstants(ex, this.opt.expandGlobalConstant);
             if (ret !== ex) {
-                ret[sourceReference] = Object.assign(Object.assign({}, (ex[sourceReference] || { first: 0, last: 0 })), { globalConstant: ex });
+                ret[sourceReference] = {
+                    ...(ex[sourceReference] || { first: 0, last: 0 }),
+                    globalConstant: ex,
+                };
             }
             return ret;
         }
-        if (((_b = this.opt) === null || _b === void 0 ? void 0 : _b.expandMacros) !== undefined ? (_c = this.opt) === null || _c === void 0 ? void 0 : _c.expandMacros : true) {
+        if (this.opt?.expandMacros !== undefined ? this.opt?.expandMacros : true) {
             const ret = expandMacros(ex, this.opt);
             if (ret !== ex) {
-                ret[sourceReference] = Object.assign(Object.assign({}, (ex[sourceReference] || { first: 0, last: 0 })), { macro: ex });
+                ret[sourceReference] = { ...(ex[sourceReference] || { first: 0, last: 0 }), macro: ex };
             }
             return ret;
         }
@@ -852,7 +857,6 @@ class Parser {
         }
     }
     parseListExpr(scanner, start) {
-        var _a;
         const ref = {
             first: start.first,
             last: start.last,
@@ -899,14 +903,13 @@ class Parser {
             else {
                 ret.args = ret.args || [];
                 const arg = this.parseExpr(scanner, tok.value);
-                ref.last = ((_a = arg[sourceReference]) === null || _a === void 0 ? void 0 : _a.last) || ref.last;
+                ref.last = arg[sourceReference]?.last || ref.last;
                 ret.args.push(arg);
             }
         }
         return this.expand(ret);
     }
     parseArgs(scanner, start) {
-        var _a;
         // Identifier with arguments
         const ref = {
             first: start.first,
@@ -928,14 +931,13 @@ class Parser {
             }
             else {
                 const arg = this.parseExpr(scanner, t.value);
-                ref.last = ((_a = arg[sourceReference]) === null || _a === void 0 ? void 0 : _a.last) || ref.last;
+                ref.last = arg[sourceReference]?.last || ref.last;
                 p.args = p.args || [];
                 p.args.push(arg);
             }
         }
     }
     parseSequenceExpr(scanner, start) {
-        var _a, _b;
         const ref = {
             first: start.first,
             last: start.last,
@@ -970,14 +972,14 @@ class Parser {
             else if (tok.value.t === Literal.Ident) {
                 // Identifier with arguments
                 const [itm, n] = this.parseArgs(scanner, tok.value);
-                ref.last = ((_a = itm[sourceReference]) === null || _a === void 0 ? void 0 : _a.last) || ref.last;
+                ref.last = itm[sourceReference]?.last || ref.last;
                 seq.push(this.expand(itm));
                 tok = n;
             }
             else {
                 // Other
                 const ex = this.parseExpr(scanner, tok.value);
-                ref.last = ((_b = ex[sourceReference]) === null || _b === void 0 ? void 0 : _b.last) || ref.last;
+                ref.last = ex[sourceReference]?.last || ref.last;
                 seq.push(ex);
                 tok = null;
             }
@@ -1156,9 +1158,8 @@ class Formatter {
         this.lev = lev;
     }
     indent(n = 0) {
-        var _a;
         let ret = '';
-        if (((_a = this.opt) === null || _a === void 0 ? void 0 : _a.indent) !== undefined) {
+        if (this.opt?.indent !== undefined) {
             for (let i = this.lev + n; i > 0; i--) {
                 ret += this.opt.indent;
             }
@@ -1166,12 +1167,10 @@ class Formatter {
         return ret;
     }
     get lf() {
-        var _a;
-        return ((_a = this.opt) === null || _a === void 0 ? void 0 : _a.newline) || '';
+        return this.opt?.newline || '';
     }
     get lfsp() {
-        var _a;
-        return ((_a = this.opt) === null || _a === void 0 ? void 0 : _a.newline) || ' ';
+        return this.opt?.newline || ' ';
     }
     down(n) {
         return new Formatter(this.opt, this.lev + n);
@@ -1193,8 +1192,7 @@ function isMultiline(node) {
     return false;
 }
 function emitExpr(node, f, foldMacros) {
-    var _a;
-    const macro = (_a = node[sourceReference]) === null || _a === void 0 ? void 0 : _a.macro;
+    const macro = node[sourceReference]?.macro;
     if (foldMacros && macro) {
         return emitExpr(macro, f, foldMacros);
     }
@@ -1357,7 +1355,7 @@ const K = [
 ];
 /**
  *  @category Error
- *  @description Error that indicates a failure when decoding a base58 encoding
+ *  Error that indicates a failure when decoding a base58 encoding
  */
 class Base58DecodingError extends TaquitoError {
     constructor(message) {
@@ -1528,7 +1526,7 @@ function encodeBase58Check(src) {
 
 /**
  *  @category Error
- *  @description Error that indicates an invalid Michelson being passed or used
+ *  Error that indicates an invalid Michelson being passed or used
  */
 class InvalidMichelsonError extends ParameterValidationError {
     constructor(message) {
@@ -1539,7 +1537,7 @@ class InvalidMichelsonError extends ParameterValidationError {
 }
 /**
  *  @category Error
- *  @description Error that indicates an invalid type expression being passed or used
+ *  Error that indicates an invalid type expression being passed or used
  */
 class InvalidTypeExpressionError extends ParameterValidationError {
     constructor(message) {
@@ -1550,7 +1548,7 @@ class InvalidTypeExpressionError extends ParameterValidationError {
 }
 /**
  *  @category Error
- *  @description Error that indicates an invalid data expression being passed or used
+ *  Error that indicates an invalid data expression being passed or used
  */
 class InvalidDataExpressionError extends ParameterValidationError {
     constructor(message) {
@@ -1561,7 +1559,7 @@ class InvalidDataExpressionError extends ParameterValidationError {
 }
 /**
  *  @category Error
- *  @description Error that indicates an invalid contract entrypoint being referenced or passed
+ *  Error that indicates an invalid contract entrypoint being referenced or passed
  */
 class InvalidEntrypointError extends ParameterValidationError {
     constructor(entrypoint) {
@@ -1573,7 +1571,7 @@ class InvalidEntrypointError extends ParameterValidationError {
 }
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when trying to encode Tezos ID
+ *  Error that indicates a failure happening when trying to encode Tezos ID
  */
 class TezosIdEncodeError extends ParameterValidationError {
     constructor(message) {
@@ -1584,7 +1582,7 @@ class TezosIdEncodeError extends ParameterValidationError {
 }
 /**
  *  @category Error
- *  @description Error that indicates a general error happening when trying to create a LongInteger
+ *  Error that indicates a general error happening when trying to create a LongInteger
  */
 class LongIntegerError extends TaquitoError {
     constructor(message) {
@@ -1595,7 +1593,7 @@ class LongIntegerError extends TaquitoError {
 }
 /**
  *  @category Error
- *  @description Error that indicates a failure occurring when trying to parse a hex byte
+ *  Error that indicates a failure occurring when trying to parse a hex byte
  */
 class HexParseError extends TaquitoError {
     constructor(hexByte) {
@@ -1608,12 +1606,11 @@ class HexParseError extends TaquitoError {
 
 /**
  *  @category Error
- *  @description Error that indicates a Michelson failure occurring
+ *  Error that indicates a Michelson failure occurring
  */
 class MichelsonError extends TaquitoError {
     /**
      * @param val Value of a AST node caused the error
-     * @param path Path to a node caused the error
      * @param message An error message
      */
     constructor(val, message) {
@@ -1719,7 +1716,7 @@ function isDecimal(x) {
         new LongInteger(x);
         return true;
     }
-    catch (_a) {
+    catch {
         return false;
     }
 }
@@ -1727,7 +1724,7 @@ function isNatural(x) {
     try {
         return new LongInteger(x).sign >= 0;
     }
-    catch (_a) {
+    catch {
         return false;
     }
 }
@@ -1743,13 +1740,13 @@ function unpackAnnotations(p, opt) {
         for (const v of p.annots) {
             if (v.length !== 0) {
                 if (!annRe.test(v) ||
-                    (!(opt === null || opt === void 0 ? void 0 : opt.specialVar) && (v === '@%' || v === '@%%')) ||
-                    (!(opt === null || opt === void 0 ? void 0 : opt.specialFields) && v === '%@')) {
+                    (!opt?.specialVar && (v === '@%' || v === '@%%')) ||
+                    (!opt?.specialFields && v === '%@')) {
                     throw new MichelsonError(p, `${p.prim}: unexpected annotation: ${v}`);
                 }
                 switch (v[0]) {
                     case '%':
-                        if ((opt === null || opt === void 0 ? void 0 : opt.emptyFields) || v.length > 1) {
+                        if (opt?.emptyFields || v.length > 1) {
                             field = field || [];
                             field.push(v);
                         }
@@ -1761,7 +1758,7 @@ function unpackAnnotations(p, opt) {
                         }
                         break;
                     case '@':
-                        if ((opt === null || opt === void 0 ? void 0 : opt.emptyVar) || v.length > 1) {
+                        if (opt?.emptyVar || v.length > 1) {
                             vars = vars || [];
                             vars.push(v);
                         }
@@ -1842,13 +1839,16 @@ function unpackComb(id, v) {
             };
         return ret;
     }
-    return Object.assign(Object.assign({}, (Array.isArray(vv) ? { prim: id } : vv)), { args: [
+    return {
+        ...(Array.isArray(vv) ? { prim: id } : vv),
+        args: [
             args[0],
             {
                 prim: id,
                 args: args.slice(1),
             },
-        ] });
+        ],
+    };
 }
 function isPairType(t) {
     return Array.isArray(t) || t.prim === 'pair';
@@ -2104,8 +2104,7 @@ function assertStringOrBytes(ex) {
     throw new MichelsonValidationError(ex, 'string or bytes literal expected');
 }
 function assertArgs(ex, n) {
-    var _a;
-    if ((n === 0 && ex.args === undefined) || ((_a = ex.args) === null || _a === void 0 ? void 0 : _a.length) === n) {
+    if ((n === 0 && ex.args === undefined) || ex.args?.length === n) {
         return true;
     }
     throw new MichelsonValidationError(ex, `${n} arguments expected`);
@@ -2116,7 +2115,6 @@ function assertArgs(ex, n) {
  * @param ex An AST node
  */
 function assertMichelsonInstruction(ex) {
-    var _a, _b;
     if (Array.isArray(ex)) {
         for (const n of ex) {
             if (!Array.isArray(n) && !isPrim(n)) {
@@ -2210,7 +2208,7 @@ function assertMichelsonInstruction(ex) {
                 }
                 break;
             case 'DIP':
-                if (((_a = ex.args) === null || _a === void 0 ? void 0 : _a.length) === 2) {
+                if (ex.args?.length === 2) {
                     /* istanbul ignore else */
                     if (assertIntLiteral(ex.args[0])) {
                         assertNatural(ex.args[0]);
@@ -2220,7 +2218,7 @@ function assertMichelsonInstruction(ex) {
                         assertMichelsonInstruction(ex.args[1]);
                     }
                 }
-                else if (((_b = ex.args) === null || _b === void 0 ? void 0 : _b.length) === 1) {
+                else if (ex.args?.length === 1) {
                     /* istanbul ignore else */
                     if (assertSeq(ex.args[0])) {
                         assertMichelsonInstruction(ex.args[0]);
@@ -2641,7 +2639,7 @@ function isMichelsonScript(ex) {
         assertMichelsonContract(ex);
         return true;
     }
-    catch (_a) {
+    catch {
         return false;
     }
 }
@@ -2654,7 +2652,7 @@ function isMichelsonData(ex) {
         assertMichelsonData(ex);
         return true;
     }
-    catch (_a) {
+    catch {
         return false;
     }
 }
@@ -2667,7 +2665,7 @@ function isMichelsonCode(ex) {
         assertMichelsonInstruction(ex);
         return true;
     }
-    catch (_a) {
+    catch {
         return false;
     }
 }
@@ -2680,7 +2678,7 @@ function isMichelsonType(ex) {
         assertMichelsonType(ex);
         return true;
     }
-    catch (_a) {
+    catch {
         return false;
     }
 }
@@ -2704,40 +2702,6 @@ function assertDataListIfAny(d) {
     return true;
 }
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
 // The order is important!
 // The position represent the encoding value.
 const primitives = [
@@ -3168,7 +3132,6 @@ function writePublicKey(pk, w) {
     w.writeBytes(Array.from(pk.publicKey));
 }
 function writeExpr(expr, wr, tf) {
-    var _a, _b;
     const [e, args] = tf(expr);
     if (Array.isArray(e)) {
         const w = new Writer();
@@ -3226,9 +3189,9 @@ function writeExpr(expr, wr, tf) {
     if (prim === undefined) {
         throw new TypeError(`Can't encode primary: ${e.prim}`);
     }
-    const tag = (((_a = e.args) === null || _a === void 0 ? void 0 : _a.length) || 0) < 3
+    const tag = (e.args?.length || 0) < 3
         ? Tag.Prim0 +
-            (((_b = e.args) === null || _b === void 0 ? void 0 : _b.length) || 0) * 2 +
+            (e.args?.length || 0) * 2 +
             (e.annots === undefined || e.annots.length === 0 ? 0 : 1)
         : Tag.Prim;
     wr.writeUint8(tag);
@@ -4073,19 +4036,18 @@ function assertStacksEqual(a, b) {
     }
 }
 function assertTypeAnnotationsValid(t, field = false) {
-    var _a, _b, _c;
     if (!Array.isArray(t)) {
         const ann = unpackAnnotations(t);
-        if ((((_a = ann.t) === null || _a === void 0 ? void 0 : _a.length) || 0) > 1) {
+        if ((ann.t?.length || 0) > 1) {
             throw new MichelsonTypeError(t, `${t.prim}: at most one type annotation allowed: ${t.annots}`, undefined);
         }
         if (field) {
-            if ((((_b = ann.f) === null || _b === void 0 ? void 0 : _b.length) || 0) > 1) {
+            if ((ann.f?.length || 0) > 1) {
                 throw new MichelsonTypeError(t, `${t.prim}: at most one field annotation allowed: ${t.annots}`, undefined);
             }
         }
         else {
-            if ((((_c = ann.f) === null || _c === void 0 ? void 0 : _c.length) || 0) > 0) {
+            if ((ann.f?.length || 0) > 0) {
                 throw new MichelsonTypeError(t, `${t.prim}: field annotations aren't allowed: ${t.annots}`, undefined);
             }
         }
@@ -4359,7 +4321,7 @@ function instructionListType(inst, stack, ctx) {
         i !== inst.length - 1) {
         throw new MichelsonInstructionError(inst, ret, 'FAIL must appear in a tail position');
     }
-    if ((ctx === null || ctx === void 0 ? void 0 : ctx.traceCallback) !== undefined) {
+    if (ctx?.traceCallback !== undefined) {
         const trace = {
             op: inst,
             in: stack,
@@ -4370,7 +4332,7 @@ function instructionListType(inst, stack, ctx) {
     return 'failed' in ret ? { failed: ret.failed, level: ret.level + 1 } : ret;
 }
 function functionTypeInternal(inst, stack, ctx) {
-    const proto = (ctx === null || ctx === void 0 ? void 0 : ctx.protocol) || DefaultProtocol;
+    const proto = ctx?.protocol || DefaultProtocol;
     if (Array.isArray(inst)) {
         return instructionListType(inst, stack, ctx);
     }
@@ -4435,7 +4397,11 @@ function functionTypeInternal(inst, stack, ctx) {
     const ensureBigMapStorableType = rethrowTypeGuard(assertMichelsonBigMapStorableType);
     // unpack instruction annotations and assert their maximum number
     function instructionAnn(num, opt) {
-        const a = argAnn(instruction, Object.assign(Object.assign({}, opt), { emptyFields: num.f !== undefined && num.f > 1, emptyVar: num.v !== undefined && num.v > 1 }));
+        const a = argAnn(instruction, {
+            ...opt,
+            emptyFields: num.f !== undefined && num.f > 1,
+            emptyVar: num.v !== undefined && num.v > 1,
+        });
         const assertNum = (a, n, type) => {
             if (a && a.length > (n || 0)) {
                 throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: at most ${n || 0} ${type} annotations allowed`);
@@ -4458,8 +4424,8 @@ function functionTypeInternal(inst, stack, ctx) {
                 ...((a.f === null ? src.f : a.f) || []),
             ]
             : undefined;
-        const { annots: _annots } = t, rest = __rest(t, ["annots"]);
-        return Object.assign(Object.assign({}, rest), (ann && ann.length !== 0 && { annots: ann }));
+        const { annots: _annots, ...rest } = t;
+        return { ...rest, ...(ann && ann.length !== 0 && { annots: ann }) };
     }
     // shortcut to copy at most one variable annotation from the instruction to the type
     function annotateVar(t, def) {
@@ -4471,17 +4437,16 @@ function functionTypeInternal(inst, stack, ctx) {
     }
     // annotate CAR/CDR/UNPAIR/GET
     function annotateField(arg, field, insAnn, n, defField) {
-        var _a, _b, _c, _d;
-        const fieldAnn = (_a = argAnn(field).f) === null || _a === void 0 ? void 0 : _a[0]; // field's field annotation
-        const insFieldAnn = (_b = insAnn.f) === null || _b === void 0 ? void 0 : _b[n];
+        const fieldAnn = argAnn(field).f?.[0]; // field's field annotation
+        const insFieldAnn = insAnn.f?.[n];
         if (insFieldAnn !== undefined &&
             insFieldAnn !== '%' &&
             fieldAnn !== undefined &&
             insFieldAnn !== fieldAnn) {
             throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: field names doesn't match: ${insFieldAnn} !== ${fieldAnn}`);
         }
-        const insVarAnn = (_c = insAnn.v) === null || _c === void 0 ? void 0 : _c[n]; // nth instruction's variable annotation
-        const varAnn = (_d = argAnn(arg).v) === null || _d === void 0 ? void 0 : _d[0]; // instruction argument's variable annotation
+        const insVarAnn = insAnn.v?.[n]; // nth instruction's variable annotation
+        const varAnn = argAnn(arg).v?.[0]; // instruction argument's variable annotation
         return annotate(field, {
             t: null,
             v: insVarAnn
@@ -4539,14 +4504,23 @@ function functionTypeInternal(inst, stack, ctx) {
         }
         const p = unpackComb('pair', src);
         if (i === 1) {
-            return Object.assign(Object.assign({}, p), { args: [x, p.args[1]] });
+            return {
+                ...p,
+                args: [x, p.args[1]],
+            };
         }
         const right = p.args[1];
         if (isPairType(right)) {
-            return Object.assign(Object.assign({}, p), { args: [p.args[0], updateNth(right, x, n, i - 2)] });
+            return {
+                ...p,
+                args: [p.args[0], updateNth(right, x, n, i - 2)],
+            };
         }
         else if (i === 2) {
-            return Object.assign(Object.assign({}, p), { args: [p.args[0], x] });
+            return {
+                ...p,
+                args: [p.args[0], x],
+            };
         }
         throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: at least ${n + 1} fields are expected`);
     }
@@ -4563,7 +4537,6 @@ function functionTypeInternal(inst, stack, ctx) {
         }
     }
     const retStack = ((instruction) => {
-        var _a, _b, _c, _d, _e;
         switch (instruction.prim) {
             case 'DUP': {
                 const n = instruction.args ? parseInt(instruction.args[0].int, 10) : 1;
@@ -4600,12 +4573,11 @@ function functionTypeInternal(inst, stack, ctx) {
                     return s.slice(i > 0 ? i + 1 : 1);
                 };
                 const retArgs = s.map((v, i) => {
-                    var _a;
                     const va = argAnn(v);
                     const f = ia.f && ia.f.length > i && ia.f[i] !== '%'
                         ? ia.f[i] === '%@'
                             ? va.v
-                                ? ['%' + trim(((_a = va.v) === null || _a === void 0 ? void 0 : _a[0]) || '')]
+                                ? ['%' + trim(va.v?.[0] || '')]
                                 : undefined
                             : [ia.f[i]]
                         : undefined;
@@ -4718,24 +4690,24 @@ function functionTypeInternal(inst, stack, ctx) {
                 ensureComparableType(s[0]);
                 ensureTypesEqual(s[0], s[2].args[0]);
                 ensureTypesEqual(s[1].args[0], s[2].args[1]);
-                const va = (_a = ia.v) === null || _a === void 0 ? void 0 : _a.map((v) => (v !== '@' ? [v] : undefined));
+                const va = ia.v?.map((v) => (v !== '@' ? [v] : undefined));
                 if (s[2].prim === 'map') {
                     return [
-                        annotate({ prim: 'option', args: [s[2].args[1]] }, { v: va === null || va === void 0 ? void 0 : va[0] }),
+                        annotate({ prim: 'option', args: [s[2].args[1]] }, { v: va?.[0] }),
                         annotate({
                             prim: 'map',
                             args: [annotate(s[0], { t: null }), annotate(s[1].args[0], { t: null })],
-                        }, { v: va === null || va === void 0 ? void 0 : va[1] }),
+                        }, { v: va?.[1] }),
                         ...stack.slice(3),
                     ];
                 }
                 ensureBigMapStorableType(s[1].args[0]);
                 return [
-                    annotate({ prim: 'option', args: [s[2].args[1]] }, { v: va === null || va === void 0 ? void 0 : va[0] }),
+                    annotate({ prim: 'option', args: [s[2].args[1]] }, { v: va?.[0] }),
                     annotate({
                         prim: 'big_map',
                         args: [annotate(s[0], { t: null }), annotate(s[1].args[0], { t: null })],
-                    }, { v: va === null || va === void 0 ? void 0 : va[1] }),
+                    }, { v: va?.[1] }),
                     ...stack.slice(3),
                 ];
             }
@@ -4943,11 +4915,11 @@ function functionTypeInternal(inst, stack, ctx) {
                 args(0, ['int']);
                 return [annotateVar({ prim: 'bool' }), ...stack.slice(1)];
             case 'SELF': {
-                if ((ctx === null || ctx === void 0 ? void 0 : ctx.contract) === undefined) {
+                if (ctx?.contract === undefined) {
                     throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: contract required`);
                 }
                 const ia = instructionAnn({ f: 1, v: 1 });
-                const ep = contractEntryPoint(ctx.contract, (_b = ia.f) === null || _b === void 0 ? void 0 : _b[0]);
+                const ep = contractEntryPoint(ctx.contract, ia.f?.[0]);
                 if (ep === null) {
                     throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: contract has no entrypoint ${ep}`);
                 }
@@ -5004,7 +4976,7 @@ function functionTypeInternal(inst, stack, ctx) {
             }
             case 'SELF_ADDRESS': {
                 const addr = { prim: 'address' };
-                if ((ctx === null || ctx === void 0 ? void 0 : ctx.contract) !== undefined) {
+                if (ctx?.contract !== undefined) {
                     addr[refContract] = {
                         prim: 'contract',
                         args: [contractSection(ctx.contract, 'parameter').args[0]],
@@ -5085,7 +5057,7 @@ function functionTypeInternal(inst, stack, ctx) {
                 const ia = instructionAnn({ v: 1, f: 1 });
                 const contract = s[refContract];
                 if (contract !== undefined) {
-                    const ep = contractEntryPoint(contract, (_c = ia.f) === null || _c === void 0 ? void 0 : _c[0]);
+                    const ep = contractEntryPoint(contract, ia.f?.[0]);
                     if (ep === null) {
                         throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: contract has no entrypoint ${ep}`);
                     }
@@ -5235,22 +5207,25 @@ function functionTypeInternal(inst, stack, ctx) {
                     assertContractValid(instruction.args[0]);
                     assertScalarTypesEqual(contractSection(instruction.args[0], 'storage').args[0], s[2]);
                 }
-                const va = (_d = ia.v) === null || _d === void 0 ? void 0 : _d.map((v) => (v !== '@' ? [v] : undefined));
+                const va = ia.v?.map((v) => (v !== '@' ? [v] : undefined));
                 return [
-                    annotate({ prim: 'operation' }, { v: va === null || va === void 0 ? void 0 : va[0] }),
+                    annotate({ prim: 'operation' }, { v: va?.[0] }),
                     annotate({
                         prim: 'address',
                         [refContract]: {
                             prim: 'contract',
                             args: [contractSection(instruction.args[0], 'parameter').args[0]],
                         },
-                    }, { v: va === null || va === void 0 ? void 0 : va[1] }),
+                    }, { v: va?.[1] }),
                     ...stack.slice(3),
                 ];
             }
             case 'PUSH':
                 assertTypeAnnotationsValid(instruction.args[0]);
-                assertDataValidInternal(instruction.args[1], instruction.args[0], Object.assign(Object.assign({}, ctx), { contract: undefined }));
+                assertDataValidInternal(instruction.args[1], instruction.args[0], {
+                    ...ctx,
+                    contract: undefined,
+                });
                 return [annotateVar(instruction.args[0]), ...stack];
             case 'EMPTY_SET':
                 assertTypeAnnotationsValid(instruction.args[0]);
@@ -5284,7 +5259,10 @@ function functionTypeInternal(inst, stack, ctx) {
                 if (instruction.prim === 'LAMBDA_REC') {
                     s.push({ prim: 'lambda', args: [instruction.args[0], instruction.args[1]] });
                 }
-                const body = functionTypeInternal(instruction.args[2], s, Object.assign(Object.assign({}, ctx), { contract: undefined }));
+                const body = functionTypeInternal(instruction.args[2], s, {
+                    ...ctx,
+                    contract: undefined,
+                });
                 if ('failed' in body) {
                     return { failed: body.failed, level: body.level + 1 };
                 }
@@ -5360,13 +5338,13 @@ function functionTypeInternal(inst, stack, ctx) {
             case 'READ_TICKET': {
                 const ia = instructionAnn({ v: 2 });
                 const s = args(0, ['ticket'])[0];
-                const va = (_e = ia.v) === null || _e === void 0 ? void 0 : _e.map((v) => (v !== '@' ? [v] : undefined));
+                const va = ia.v?.map((v) => (v !== '@' ? [v] : undefined));
                 return [
                     annotate({
                         prim: 'pair',
                         args: [{ prim: 'address' }, annotate(s.args[0], { t: null }), { prim: 'nat' }],
-                    }, { v: va === null || va === void 0 ? void 0 : va[0] }),
-                    annotate(s, { v: va === null || va === void 0 ? void 0 : va[1], t: null }),
+                    }, { v: va?.[0] }),
+                    annotate(s, { v: va?.[1], t: null }),
                     ...stack.slice(1),
                 ];
             }
@@ -5461,7 +5439,7 @@ function functionTypeInternal(inst, stack, ctx) {
                 throw new MichelsonError(instruction, `unexpected instruction: ${instruction.prim}`);
         }
     })(instruction);
-    if ((ctx === null || ctx === void 0 ? void 0 : ctx.traceCallback) !== undefined) {
+    if (ctx?.traceCallback !== undefined) {
         const trace = {
             op: instruction,
             in: stack,
@@ -5541,11 +5519,11 @@ function assertContractValid(contract, ctx) {
         const arg = {
             prim: 'pair',
             args: [
-                Object.assign(Object.assign({}, parameter), { annots: ['@parameter'] }),
-                Object.assign(Object.assign({}, storage), { annots: ['@storage'] }),
+                { ...parameter, ...{ annots: ['@parameter'] } },
+                { ...storage, ...{ annots: ['@storage'] } },
             ],
         };
-        const out = functionTypeInternal(code, [arg], Object.assign(Object.assign({}, ctx), { contract }));
+        const out = functionTypeInternal(code, [arg], { ...ctx, ...{ contract } });
         if ('failed' in out) {
             return out;
         }
@@ -5584,7 +5562,7 @@ function functionType(inst, stack, ctx) {
     for (const t of stack) {
         assertTypeAnnotationsValid(t);
     }
-    if ((ctx === null || ctx === void 0 ? void 0 : ctx.contract) !== undefined) {
+    if (ctx?.contract !== undefined) {
         for (const typesec of ['parameter', 'storage']) {
             const sec = contractSection(ctx.contract, typesec).args[0];
             assertTypeAnnotationsValid(sec);
@@ -5613,7 +5591,7 @@ function isTypeAnnotationsValid(t, field = false) {
         assertTypeAnnotationsValid(t, field);
         return true;
     }
-    catch (_a) {
+    catch {
         return false;
     }
 }
@@ -5621,7 +5599,7 @@ function isContractValid(contract, ctx) {
     try {
         return assertContractValid(contract, ctx);
     }
-    catch (_a) {
+    catch {
         return null;
     }
 }
@@ -5630,7 +5608,7 @@ function isDataValid(d, t, ctx) {
         assertDataValid(d, t, ctx);
         return true;
     }
-    catch (_a) {
+    catch {
         return false;
     }
 }
@@ -5639,7 +5617,7 @@ function isTypeEqual(a, b, field = false) {
         assertTypesEqual(a, b, field);
         return true;
     }
-    catch (_a) {
+    catch {
         return false;
     }
 }
@@ -5647,7 +5625,7 @@ function isTypeEqual(a, b, field = false) {
 class Contract {
     constructor(contract, opt) {
         this.contract = contract;
-        this.ctx = Object.assign({ contract }, opt);
+        this.ctx = { contract, ...opt };
         this.output = assertContractValid(contract, this.ctx);
     }
     static parse(src, opt) {
@@ -5701,7 +5679,7 @@ class Contract {
     assertParameterValid(ep, d) {
         const t = this.entryPoint(ep || undefined);
         if (t === null) {
-            throw new InvalidEntrypointError(ep === null || ep === void 0 ? void 0 : ep.toString());
+            throw new InvalidEntrypointError(ep?.toString());
         }
         this.assertDataValid(d, t);
     }
@@ -5710,7 +5688,7 @@ class Contract {
             this.assertParameterValid(ep, d);
             return true;
         }
-        catch (_a) {
+        catch {
             return false;
         }
     }
@@ -5741,11 +5719,10 @@ function formatStack(s) {
 }
 function traceDumpFunc(blocks, cb) {
     return (v) => {
-        var _a;
         if (Array.isArray(v) && !blocks) {
             return;
         }
-        const macro = (_a = v.op[sourceReference]) === null || _a === void 0 ? void 0 : _a.macro;
+        const macro = v.op[sourceReference]?.macro;
         const msg = `${macro ? 'Macro' : 'Op'}: ${macro ? emitMicheline(macro, undefined, true) + ' / ' : ''}${emitMicheline(v.op)}
 Input:
 ${formatStack(v.in)}
@@ -5756,9 +5733,8 @@ ${formatStack(v.out)}
     };
 }
 function formatError(err) {
-    var _a;
     if (err instanceof MichelsonInstructionError) {
-        const macro = (_a = err.val[sourceReference]) === null || _a === void 0 ? void 0 : _a.macro;
+        const macro = err.val[sourceReference]?.macro;
         return `${macro ? 'Macro' : 'Op'}: ${macro ? emitMicheline(macro, undefined, true) + ' / ' : ''}${emitMicheline(err.val)}
 Stack:
 ${formatStack(err.stackState)}
@@ -5782,8 +5758,8 @@ ${err.data
 
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
 const VERSION = {
-    "commitHash": "105a7b15cfb862a0732c204e0e9741098d697775",
-    "version": "24.2.0"
+    "commitHash": "27675679db6515e8b092195ef5c58c2c0ea5f5c8",
+    "version": "24.3.0-beta.0"
 };
 
 export { Contract, DefaultProtocol, JSONParseError, MacroError, MichelineParseError, MichelsonError, MichelsonInstructionError, MichelsonTypeError, MichelsonValidationError, Parser, ProtoGreaterOrEqual, ProtoInferiorTo, Protocol, VERSION, assertContractValid, assertDataListIfAny, assertDataValid, assertMichelsonBigMapStorableType, assertMichelsonComparableType, assertMichelsonContract, assertMichelsonData, assertMichelsonInstruction, assertMichelsonPackableType, assertMichelsonPassableType, assertMichelsonPushableType, assertMichelsonStorableType, assertMichelsonType, assertTypeAnnotationsValid, assertTypesEqual, assertViewNameValid, contractEntryPoint, contractEntryPoints, contractSection, contractViews, decodeAddressBytes, decodePublicKeyBytes, decodePublicKeyHashBytes, dummyContract, emitMicheline, formatError, formatStack, functionType, instructionIDs, isContractValid, isDataValid, isInstruction, isMichelsonCode, isMichelsonData, isMichelsonError, isMichelsonScript, isMichelsonType, isTypeAnnotationsValid, isTypeEqual, packData, packDataBytes, refContract, sourceReference, traceDumpFunc, unpackData, unpackDataBytes };