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

package/dist/lib/base58.js

@@ -84,7 +84,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 core_1.TaquitoError {
     constructor(message) {

package/dist/lib/binary.js

@@ -439,7 +439,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();
@@ -497,9 +496,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);

package/dist/lib/errors.js

@@ -4,7 +4,7 @@ exports.HexParseError = exports.LongIntegerError = exports.TezosIdEncodeError =
 const core_1 = require("@taquito/core");
 /**
  *  @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_1.ParameterValidationError {
     constructor(message) {
@@ -16,7 +16,7 @@ class InvalidMichelsonError extends core_1.ParameterValidationError {
 exports.InvalidMichelsonError = InvalidMichelsonError;
 /**
  *  @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_1.ParameterValidationError {
     constructor(message) {
@@ -28,7 +28,7 @@ class InvalidTypeExpressionError extends core_1.ParameterValidationError {
 exports.InvalidTypeExpressionError = InvalidTypeExpressionError;
 /**
  *  @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_1.ParameterValidationError {
     constructor(message) {
@@ -40,7 +40,7 @@ class InvalidDataExpressionError extends core_1.ParameterValidationError {
 exports.InvalidDataExpressionError = InvalidDataExpressionError;
 /**
  *  @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_1.ParameterValidationError {
     constructor(entrypoint) {
@@ -53,7 +53,7 @@ class InvalidEntrypointError extends core_1.ParameterValidationError {
 exports.InvalidEntrypointError = InvalidEntrypointError;
 /**
  *  @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_1.ParameterValidationError {
     constructor(message) {
@@ -65,7 +65,7 @@ class TezosIdEncodeError extends core_1.ParameterValidationError {
 exports.TezosIdEncodeError = TezosIdEncodeError;
 /**
  *  @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_1.TaquitoError {
     constructor(message) {
@@ -77,7 +77,7 @@ class LongIntegerError extends core_1.TaquitoError {
 exports.LongIntegerError = LongIntegerError;
 /**
  *  @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_1.TaquitoError {
     constructor(hexByte) {

package/dist/lib/formatters.js

@@ -20,11 +20,10 @@ function formatStack(s) {
 }
 function traceDumpFunc(blocks, cb) {
     return (v) => {
-        var _a;
         if (Array.isArray(v) && !blocks) {
             return;
         }
-        const macro = (_a = v.op[micheline_1.sourceReference]) === null || _a === void 0 ? void 0 : _a.macro;
+        const macro = v.op[micheline_1.sourceReference]?.macro;
         const msg = `${macro ? 'Macro' : 'Op'}: ${macro ? (0, micheline_emitter_1.emitMicheline)(macro, undefined, true) + ' / ' : ''}${(0, micheline_emitter_1.emitMicheline)(v.op)}
 Input:
 ${formatStack(v.in)}
@@ -35,9 +34,8 @@ ${formatStack(v.out)}
     };
 }
 function formatError(err) {
-    var _a;
     if (err instanceof michelson_typecheck_1.MichelsonInstructionError) {
-        const macro = (_a = err.val[micheline_1.sourceReference]) === null || _a === void 0 ? void 0 : _a.macro;
+        const macro = err.val[micheline_1.sourceReference]?.macro;
         return `${macro ? 'Macro' : 'Op'}: ${macro ? (0, micheline_emitter_1.emitMicheline)(macro, undefined, true) + ' / ' : ''}${(0, micheline_emitter_1.emitMicheline)(err.val)}
 Stack:
 ${formatStack(err.stackState)}

package/dist/lib/macros.js

@@ -6,7 +6,7 @@ const core_1 = require("@taquito/core");
 const michelson_types_1 = require("./michelson-types");
 /**
  *  @category Error
- *  @description Error that indicates macros failed to be expanded
+ *  Error that indicates macros failed to be expanded
  */
 class MacroError extends core_1.TaquitoError {
     constructor(prim, message) {
@@ -18,11 +18,10 @@ class MacroError extends core_1.TaquitoError {
 }
 exports.MacroError = MacroError;
 function assertArgs(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) {
@@ -140,7 +139,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$/;
@@ -150,7 +153,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) || michelson_types_1.DefaultProtocol;
+    const proto = opt?.protocol || michelson_types_1.DefaultProtocol;
     function mayRename(annots) {
         return annots !== undefined ? [{ prim: 'RENAME', annots }] : [];
     }

package/dist/lib/micheline-emitter.js

@@ -8,9 +8,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;
             }
@@ -18,12 +17,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);
@@ -45,8 +42,7 @@ function isMultiline(node) {
     return false;
 }
 function emitExpr(node, f, foldMacros) {
-    var _a;
-    const macro = (_a = node[micheline_1.sourceReference]) === null || _a === void 0 ? void 0 : _a.macro;
+    const macro = node[micheline_1.sourceReference]?.macro;
     if (foldMacros && macro) {
         return emitExpr(macro, f, foldMacros);
     }

package/dist/lib/micheline-parser.js

@@ -8,7 +8,7 @@ const global_constants_1 = require("./global-constants");
 const core_1 = require("@taquito/core");
 /**
  *  @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_1.TaquitoError {
     /**
@@ -25,7 +25,7 @@ class MichelineParseError extends core_1.TaquitoError {
 exports.MichelineParseError = MichelineParseError;
 /**
  *  @category Error
- *  @description Error indicates a failure when parsing Micheline JSON
+ *  Error indicates a failure when parsing Micheline JSON
  */
 class JSONParseError extends core_1.TaquitoError {
     /**
@@ -83,18 +83,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 = (0, global_constants_1.expandGlobalConstants)(ex, this.opt.expandGlobalConstant);
             if (ret !== ex) {
-                ret[micheline_1.sourceReference] = Object.assign(Object.assign({}, (ex[micheline_1.sourceReference] || { first: 0, last: 0 })), { globalConstant: ex });
+                ret[micheline_1.sourceReference] = {
+                    ...(ex[micheline_1.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 = (0, macros_1.expandMacros)(ex, this.opt);
             if (ret !== ex) {
-                ret[micheline_1.sourceReference] = Object.assign(Object.assign({}, (ex[micheline_1.sourceReference] || { first: 0, last: 0 })), { macro: ex });
+                ret[micheline_1.sourceReference] = { ...(ex[micheline_1.sourceReference] || { first: 0, last: 0 }), macro: ex };
             }
             return ret;
         }
@@ -103,7 +105,6 @@ class Parser {
         }
     }
     parseListExpr(scanner, start) {
-        var _a;
         const ref = {
             first: start.first,
             last: start.last,
@@ -150,14 +151,13 @@ class Parser {
             else {
                 ret.args = ret.args || [];
                 const arg = this.parseExpr(scanner, tok.value);
-                ref.last = ((_a = arg[micheline_1.sourceReference]) === null || _a === void 0 ? void 0 : _a.last) || ref.last;
+                ref.last = arg[micheline_1.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,
@@ -179,14 +179,13 @@ class Parser {
             }
             else {
                 const arg = this.parseExpr(scanner, t.value);
-                ref.last = ((_a = arg[micheline_1.sourceReference]) === null || _a === void 0 ? void 0 : _a.last) || ref.last;
+                ref.last = arg[micheline_1.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,
@@ -221,14 +220,14 @@ class Parser {
             else if (tok.value.t === scan_1.Literal.Ident) {
                 // Identifier with arguments
                 const [itm, n] = this.parseArgs(scanner, tok.value);
-                ref.last = ((_a = itm[micheline_1.sourceReference]) === null || _a === void 0 ? void 0 : _a.last) || ref.last;
+                ref.last = itm[micheline_1.sourceReference]?.last || ref.last;
                 seq.push(this.expand(itm));
                 tok = n;
             }
             else {
                 // Other
                 const ex = this.parseExpr(scanner, tok.value);
-                ref.last = ((_b = ex[micheline_1.sourceReference]) === null || _b === void 0 ? void 0 : _b.last) || ref.last;
+                ref.last = ex[micheline_1.sourceReference]?.last || ref.last;
                 seq.push(ex);
                 tok = null;
             }

package/dist/lib/michelson-contract.js

@@ -8,7 +8,7 @@ const errors_1 = require("./errors");
 class Contract {
     constructor(contract, opt) {
         this.contract = contract;
-        this.ctx = Object.assign({ contract }, opt);
+        this.ctx = { contract, ...opt };
         this.output = (0, michelson_typecheck_1.assertContractValid)(contract, this.ctx);
     }
     static parse(src, opt) {
@@ -64,7 +64,7 @@ class Contract {
     assertParameterValid(ep, d) {
         const t = this.entryPoint(ep || undefined);
         if (t === null) {
-            throw new errors_1.InvalidEntrypointError(ep === null || ep === void 0 ? void 0 : ep.toString());
+            throw new errors_1.InvalidEntrypointError(ep?.toString());
         }
         this.assertDataValid(d, t);
     }
@@ -73,7 +73,7 @@ class Contract {
             this.assertParameterValid(ep, d);
             return true;
         }
-        catch (_a) {
+        catch {
             return false;
         }
     }

package/dist/lib/michelson-typecheck.js

@@ -1,15 +1,4 @@
 "use strict";
-var __rest = (this && this.__rest) || function (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;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MichelsonInstructionError = void 0;
 exports.assertTypeAnnotationsValid = assertTypeAnnotationsValid;
@@ -104,19 +93,18 @@ function assertStacksEqual(a, b) {
     }
 }
 function assertTypeAnnotationsValid(t, field = false) {
-    var _a, _b, _c;
     if (!Array.isArray(t)) {
         const ann = (0, utils_1.unpackAnnotations)(t);
-        if ((((_a = ann.t) === null || _a === void 0 ? void 0 : _a.length) || 0) > 1) {
+        if ((ann.t?.length || 0) > 1) {
             throw new utils_1.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 utils_1.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 utils_1.MichelsonTypeError(t, `${t.prim}: field annotations aren't allowed: ${t.annots}`, undefined);
             }
         }
@@ -466,7 +454,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,
@@ -477,7 +465,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) || michelson_types_1.DefaultProtocol;
+    const proto = ctx?.protocol || michelson_types_1.DefaultProtocol;
     if (Array.isArray(inst)) {
         return instructionListType(inst, stack, ctx);
     }
@@ -542,7 +530,11 @@ function functionTypeInternal(inst, stack, ctx) {
     const ensureBigMapStorableType = rethrowTypeGuard(michelson_validator_1.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`);
@@ -565,8 +557,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) {
@@ -578,17 +570,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
@@ -646,14 +637,23 @@ function functionTypeInternal(inst, stack, ctx) {
         }
         const p = (0, utils_1.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 ((0, utils_1.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`);
     }
@@ -670,7 +670,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;
@@ -707,12 +706,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;
@@ -825,24 +823,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),
                 ];
             }
@@ -1050,11 +1048,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}`);
                 }
@@ -1111,7 +1109,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[michelson_types_1.refContract] = {
                         prim: 'contract',
                         args: [contractSection(ctx.contract, 'parameter').args[0]],
@@ -1192,7 +1190,7 @@ function functionTypeInternal(inst, stack, ctx) {
                 const ia = instructionAnn({ v: 1, f: 1 });
                 const contract = s[michelson_types_1.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}`);
                     }
@@ -1342,22 +1340,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',
                         [michelson_types_1.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]);
@@ -1391,7 +1392,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 };
                 }
@@ -1467,13 +1471,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),
                 ];
             }
@@ -1568,7 +1572,7 @@ function functionTypeInternal(inst, stack, ctx) {
                 throw new utils_1.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,
@@ -1648,11 +1652,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;
         }
@@ -1691,7 +1695,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);
@@ -1720,7 +1724,7 @@ function isTypeAnnotationsValid(t, field = false) {
         assertTypeAnnotationsValid(t, field);
         return true;
     }
-    catch (_a) {
+    catch {
         return false;
     }
 }
@@ -1728,7 +1732,7 @@ function isContractValid(contract, ctx) {
     try {
         return assertContractValid(contract, ctx);
     }
-    catch (_a) {
+    catch {
         return null;
     }
 }
@@ -1737,7 +1741,7 @@ function isDataValid(d, t, ctx) {
         assertDataValid(d, t, ctx);
         return true;
     }
-    catch (_a) {
+    catch {
         return false;
     }
 }
@@ -1746,7 +1750,7 @@ function isTypeEqual(a, b, field = false) {
         assertTypesEqual(a, b, field);
         return true;
     }
-    catch (_a) {
+    catch {
         return false;
     }
 }