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

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

@@ -9,7 +9,7 @@
 
   /**
    *  @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 core.TaquitoError {
       constructor(src, idx, message) {
@@ -211,7 +211,7 @@
 
   /**
    *  @category Error
-   *  @description Error that indicates macros failed to be expanded
+   *  Error that indicates macros failed to be expanded
    */
   class MacroError extends core.TaquitoError {
       constructor(prim, message) {
@@ -222,11 +222,10 @@
       }
   }
   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) {
@@ -344,7 +343,11 @@
       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$/;
@@ -354,7 +357,7 @@
   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 }] : [];
       }
@@ -763,7 +766,7 @@
 
   /**
    *  @category Error
-   *  @description Error that indicates a failure when parsing Micheline expressions
+   *  Error that indicates a failure when parsing Micheline expressions
    */
   class MichelineParseError extends core.TaquitoError {
       /**
@@ -779,7 +782,7 @@
   }
   /**
    *  @category Error
-   *  @description Error indicates a failure when parsing Micheline JSON
+   *  Error indicates a failure when parsing Micheline JSON
    */
   class JSONParseError extends core.TaquitoError {
       /**
@@ -836,18 +839,20 @@
           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;
           }
@@ -856,7 +861,6 @@
           }
       }
       parseListExpr(scanner, start) {
-          var _a;
           const ref = {
               first: start.first,
               last: start.last,
@@ -903,14 +907,13 @@
               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,
@@ -932,14 +935,13 @@
               }
               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,
@@ -974,14 +976,14 @@
               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;
               }
@@ -1160,9 +1162,8 @@
           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;
               }
@@ -1170,12 +1171,10 @@
           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);
@@ -1197,8 +1196,7 @@
       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);
       }
@@ -1361,7 +1359,7 @@
   ];
   /**
    *  @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 core.TaquitoError {
       constructor(message) {
@@ -1532,7 +1530,7 @@
 
   /**
    *  @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 core.ParameterValidationError {
       constructor(message) {
@@ -1543,7 +1541,7 @@
   }
   /**
    *  @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 core.ParameterValidationError {
       constructor(message) {
@@ -1554,7 +1552,7 @@
   }
   /**
    *  @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 core.ParameterValidationError {
       constructor(message) {
@@ -1565,7 +1563,7 @@
   }
   /**
    *  @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 core.ParameterValidationError {
       constructor(entrypoint) {
@@ -1577,7 +1575,7 @@
   }
   /**
    *  @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 core.ParameterValidationError {
       constructor(message) {
@@ -1588,7 +1586,7 @@
   }
   /**
    *  @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 core.TaquitoError {
       constructor(message) {
@@ -1599,7 +1597,7 @@
   }
   /**
    *  @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 core.TaquitoError {
       constructor(hexByte) {
@@ -1612,12 +1610,11 @@
 
   /**
    *  @category Error
-   *  @description Error that indicates a Michelson failure occurring
+   *  Error that indicates a Michelson failure occurring
    */
   class MichelsonError extends core.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) {
@@ -1723,7 +1720,7 @@
           new LongInteger(x);
           return true;
       }
-      catch (_a) {
+      catch {
           return false;
       }
   }
@@ -1731,7 +1728,7 @@
       try {
           return new LongInteger(x).sign >= 0;
       }
-      catch (_a) {
+      catch {
           return false;
       }
   }
@@ -1747,13 +1744,13 @@
           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);
                           }
@@ -1765,7 +1762,7 @@
                           }
                           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);
                           }
@@ -1846,13 +1843,16 @@
               };
           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';
@@ -2108,8 +2108,7 @@
       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`);
@@ -2120,7 +2119,6 @@
    * @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)) {
@@ -2214,7 +2212,7 @@
                   }
                   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]);
@@ -2224,7 +2222,7 @@
                           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]);
@@ -2645,7 +2643,7 @@
           assertMichelsonContract(ex);
           return true;
       }
-      catch (_a) {
+      catch {
           return false;
       }
   }
@@ -2658,7 +2656,7 @@
           assertMichelsonData(ex);
           return true;
       }
-      catch (_a) {
+      catch {
           return false;
       }
   }
@@ -2671,7 +2669,7 @@
           assertMichelsonInstruction(ex);
           return true;
       }
-      catch (_a) {
+      catch {
           return false;
       }
   }
@@ -2684,7 +2682,7 @@
           assertMichelsonType(ex);
           return true;
       }
-      catch (_a) {
+      catch {
           return false;
       }
   }
@@ -2708,40 +2706,6 @@
       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 = [
@@ -3172,7 +3136,6 @@
       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();
@@ -3230,9 +3193,9 @@
       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);
@@ -4077,19 +4040,18 @@
       }
   }
   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);
               }
           }
@@ -4363,7 +4325,7 @@
           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,
@@ -4374,7 +4336,7 @@
       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);
       }
@@ -4439,7 +4401,11 @@
       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`);
@@ -4462,8 +4428,8 @@
                   ...((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) {
@@ -4475,17 +4441,16 @@
       }
       // 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
@@ -4543,14 +4508,23 @@
           }
           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`);
       }
@@ -4567,7 +4541,6 @@
           }
       }
       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;
@@ -4604,12 +4577,11 @@
                       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;
@@ -4722,24 +4694,24 @@
                   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),
                   ];
               }
@@ -4947,11 +4919,11 @@
                   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}`);
                   }
@@ -5008,7 +4980,7 @@
               }
               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]],
@@ -5089,7 +5061,7 @@
                   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}`);
                       }
@@ -5239,22 +5211,25 @@
                       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]);
@@ -5288,7 +5263,10 @@
                   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 };
                   }
@@ -5364,13 +5342,13 @@
               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),
                   ];
               }
@@ -5465,7 +5443,7 @@
                   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,
@@ -5545,11 +5523,11 @@
           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;
           }
@@ -5588,7 +5566,7 @@
       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);
@@ -5617,7 +5595,7 @@
           assertTypeAnnotationsValid(t, field);
           return true;
       }
-      catch (_a) {
+      catch {
           return false;
       }
   }
@@ -5625,7 +5603,7 @@
       try {
           return assertContractValid(contract, ctx);
       }
-      catch (_a) {
+      catch {
           return null;
       }
   }
@@ -5634,7 +5612,7 @@
           assertDataValid(d, t, ctx);
           return true;
       }
-      catch (_a) {
+      catch {
           return false;
       }
   }
@@ -5643,7 +5621,7 @@
           assertTypesEqual(a, b, field);
           return true;
       }
-      catch (_a) {
+      catch {
           return false;
       }
   }
@@ -5651,7 +5629,7 @@
   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) {
@@ -5705,7 +5683,7 @@
       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);
       }
@@ -5714,7 +5692,7 @@
               this.assertParameterValid(ep, d);
               return true;
           }
-          catch (_a) {
+          catch {
               return false;
           }
       }
@@ -5745,11 +5723,10 @@
   }
   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)}
@@ -5760,9 +5737,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)}
@@ -5786,8 +5762,8 @@ ${err.data
 
   // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
   const VERSION = {
-      "commitHash": "105a7b15cfb862a0732c204e0e9741098d697775",
-      "version": "24.2.0"
+      "commitHash": "05df48fee92f846cba793920d6fa829afd6a1847",
+      "version": "24.3.0-beta.1"
   };
 
   exports.Contract = Contract;