@taquito/michel-codec 17.3.2 → 17.4.0

package/dist/lib/base58.js

@@ -253,4 +253,3 @@ function encodeBase58Check(src) {
     return encodeBase58([...src, ...sum.slice(0, 4)]);
 }
 exports.encodeBase58Check = encodeBase58Check;
-//# sourceMappingURL=base58.js.map

package/dist/lib/binary.js

@@ -477,7 +477,7 @@ function writeExpr(expr, wr, tf) {
         return;
     }
     if ('bytes' in e) {
-        const bytes = utils_1.parseHex(e.bytes);
+        const bytes = (0, utils_1.parseHex)(e.bytes);
         wr.writeUint8(Tag.Bytes);
         wr.writeUint32(bytes.length);
         wr.writeBytes(bytes);
@@ -568,7 +568,7 @@ function readExpr(rd, tf) {
         case Tag.Bytes: {
             const length = rd.readUint32();
             const bytes = rd.readBytes(length);
-            const hex = utils_1.hexBytes(Array.from(bytes));
+            const hex = (0, utils_1.hexBytes)(Array.from(bytes));
             return tr({ bytes: hex });
         }
         case Tag.Sequence: {
@@ -651,15 +651,15 @@ function readExpr(rd, tf) {
 const isOrData = (e) => 'prim' in e && (e.prim === 'Left' || e.prim === 'Right');
 const isOptionData = (e) => 'prim' in e && (e.prim === 'Some' || e.prim === 'None');
 const getWriteTransformFunc = (t) => {
-    if (utils_1.isPairType(t)) {
+    if ((0, utils_1.isPairType)(t)) {
         return (d) => {
-            if (!utils_1.isPairData(d)) {
+            if (!(0, utils_1.isPairData)(d)) {
                 throw new utils_1.MichelsonTypeError(t, `pair expected: ${JSON.stringify(d)}`, d);
             }
-            michelson_validator_1.assertDataListIfAny(d);
+            (0, michelson_validator_1.assertDataListIfAny)(d);
             // combs aren't used in pack format
-            const tc = utils_1.unpackComb('pair', t);
-            const dc = utils_1.unpackComb('Pair', d);
+            const tc = (0, utils_1.unpackComb)('pair', t);
+            const dc = (0, utils_1.unpackComb)('Pair', d);
             return [
                 dc,
                 (function* () {
@@ -749,11 +749,11 @@ const getWriteTransformFunc = (t) => {
                 }
                 let bytes;
                 if ('string' in d) {
-                    const id = utils_1.checkDecodeTezosID(d.string, 'ChainID');
+                    const id = (0, utils_1.checkDecodeTezosID)(d.string, 'ChainID');
                     if (id === null) {
                         throw new utils_1.MichelsonTypeError(t, `chain id base58 expected: ${d.string}`, d);
                     }
-                    bytes = { bytes: utils_1.hexBytes(id[1]) };
+                    bytes = { bytes: (0, utils_1.hexBytes)(id[1]) };
                 }
                 else {
                     bytes = d;
@@ -767,11 +767,11 @@ const getWriteTransformFunc = (t) => {
                 }
                 let bytes;
                 if ('string' in d) {
-                    const sig = utils_1.checkDecodeTezosID(d.string, 'ED25519Signature', 'SECP256K1Signature', 'P256Signature', 'GenericSignature');
+                    const sig = (0, utils_1.checkDecodeTezosID)(d.string, 'ED25519Signature', 'SECP256K1Signature', 'P256Signature', 'GenericSignature');
                     if (sig === null) {
                         throw new utils_1.MichelsonTypeError(t, `signature base58 expected: ${d.string}`, d);
                     }
-                    bytes = { bytes: utils_1.hexBytes(sig[1]) };
+                    bytes = { bytes: (0, utils_1.hexBytes)(sig[1]) };
                 }
                 else {
                     bytes = d;
@@ -785,13 +785,13 @@ const getWriteTransformFunc = (t) => {
                 }
                 let bytes;
                 if ('string' in d) {
-                    const pkh = utils_1.checkDecodeTezosID(d.string, 'ED25519PublicKeyHash', 'SECP256K1PublicKeyHash', 'P256PublicKeyHash');
+                    const pkh = (0, utils_1.checkDecodeTezosID)(d.string, 'ED25519PublicKeyHash', 'SECP256K1PublicKeyHash', 'P256PublicKeyHash');
                     if (pkh === null) {
                         throw new utils_1.MichelsonTypeError(t, `key hash base58 expected: ${d.string}`, d);
                     }
                     const w = new Writer();
                     writePublicKeyHash({ type: pkh[0], hash: pkh[1] }, w);
-                    bytes = { bytes: utils_1.hexBytes(w.buffer) };
+                    bytes = { bytes: (0, utils_1.hexBytes)(w.buffer) };
                 }
                 else {
                     bytes = d;
@@ -805,13 +805,13 @@ const getWriteTransformFunc = (t) => {
                 }
                 let bytes;
                 if ('string' in d) {
-                    const key = utils_1.checkDecodeTezosID(d.string, 'ED25519PublicKey', 'SECP256K1PublicKey', 'P256PublicKey');
+                    const key = (0, utils_1.checkDecodeTezosID)(d.string, 'ED25519PublicKey', 'SECP256K1PublicKey', 'P256PublicKey');
                     if (key === null) {
                         throw new utils_1.MichelsonTypeError(t, `public key base58 expected: ${d.string}`, d);
                     }
                     const w = new Writer();
                     writePublicKey({ type: key[0], publicKey: key[1] }, w);
-                    bytes = { bytes: utils_1.hexBytes(w.buffer) };
+                    bytes = { bytes: (0, utils_1.hexBytes)(w.buffer) };
                 }
                 else {
                     bytes = d;
@@ -826,13 +826,13 @@ const getWriteTransformFunc = (t) => {
                 let bytes;
                 if ('string' in d) {
                     const s = d.string.split('%');
-                    const address = utils_1.checkDecodeTezosID(s[0], 'ED25519PublicKeyHash', 'SECP256K1PublicKeyHash', 'P256PublicKeyHash', 'ContractHash');
+                    const address = (0, utils_1.checkDecodeTezosID)(s[0], 'ED25519PublicKeyHash', 'SECP256K1PublicKeyHash', 'P256PublicKeyHash', 'ContractHash');
                     if (address === null) {
                         throw new utils_1.MichelsonTypeError(t, `address base58 expected: ${d.string}`, d);
                     }
                     const w = new Writer();
                     writeAddress({ type: address[0], hash: address[1], entryPoint: s.length > 1 ? s[1] : undefined }, w);
-                    bytes = { bytes: utils_1.hexBytes(w.buffer) };
+                    bytes = { bytes: (0, utils_1.hexBytes)(w.buffer) };
                 }
                 else {
                     bytes = d;
@@ -846,7 +846,7 @@ const getWriteTransformFunc = (t) => {
                 }
                 let int;
                 if ('string' in d) {
-                    const p = utils_1.parseDate(d);
+                    const p = (0, utils_1.parseDate)(d);
                     if (p === null) {
                         throw new utils_1.MichelsonTypeError(t, `can't parse date: ${d.string}`, d);
                     }
@@ -864,7 +864,7 @@ const getWriteTransformFunc = (t) => {
 const isPushInstruction = (e) => 'prim' in e && e.prim === 'PUSH';
 const writePassThrough = (e) => {
     if (isPushInstruction(e)) {
-        michelson_validator_1.assertMichelsonInstruction(e);
+        (0, michelson_validator_1.assertMichelsonInstruction)(e);
         // capture inlined type definition
         return [
             e,
@@ -948,17 +948,17 @@ exports.packData = packData;
  * @returns Binary representation as a bytes literal
  */
 function packDataBytes(d, t) {
-    return { bytes: utils_1.hexBytes(packData(d, t)) };
+    return { bytes: (0, utils_1.hexBytes)(packData(d, t)) };
 }
 exports.packDataBytes = packDataBytes;
 const getReadTransformFuncs = (t) => {
-    if (utils_1.isPairType(t)) {
+    if ((0, utils_1.isPairType)(t)) {
         return [
             (d) => {
-                if (!utils_1.isPairData(d)) {
+                if (!(0, utils_1.isPairData)(d)) {
                     throw new utils_1.MichelsonTypeError(t, `pair expected: ${JSON.stringify(d)}`, d);
                 }
-                const tc = utils_1.unpackComb('pair', t);
+                const tc = (0, utils_1.unpackComb)('pair', t);
                 return (function* () {
                     for (const a of tc.args) {
                         yield getReadTransformFuncs(a);
@@ -1049,11 +1049,11 @@ const getReadTransformFuncs = (t) => {
                     if ('string' in d) {
                         return d;
                     }
-                    const bytes = utils_1.parseBytes(d.bytes);
+                    const bytes = (0, utils_1.parseBytes)(d.bytes);
                     if (bytes === null) {
                         throw new utils_1.MichelsonTypeError(t, `can't parse bytes: ${d.bytes}`, d);
                     }
-                    return { string: utils_1.encodeTezosID('ChainID', bytes) };
+                    return { string: (0, utils_1.encodeTezosID)('ChainID', bytes) };
                 },
             ];
         case 'signature':
@@ -1066,11 +1066,11 @@ const getReadTransformFuncs = (t) => {
                     if ('string' in d) {
                         return d;
                     }
-                    const bytes = utils_1.parseBytes(d.bytes);
+                    const bytes = (0, utils_1.parseBytes)(d.bytes);
                     if (bytes === null) {
                         throw new utils_1.MichelsonTypeError(t, `can't parse bytes: ${d.bytes}`, d);
                     }
-                    return { string: utils_1.encodeTezosID('GenericSignature', bytes) };
+                    return { string: (0, utils_1.encodeTezosID)('GenericSignature', bytes) };
                 },
             ];
         case 'key_hash':
@@ -1083,14 +1083,14 @@ const getReadTransformFuncs = (t) => {
                     if ('string' in d) {
                         return d;
                     }
-                    const bytes = utils_1.parseBytes(d.bytes);
+                    const bytes = (0, utils_1.parseBytes)(d.bytes);
                     if (bytes === null) {
                         throw new utils_1.MichelsonTypeError(t, `can't parse bytes: ${d.bytes}`, d);
                     }
                     const rd = new Reader(new Uint8Array(bytes));
                     const addr = readPublicKeyHash(rd);
                     return {
-                        string: utils_1.encodeTezosID(addr.type, addr.hash) + (addr.entryPoint ? '%' + addr.entryPoint : ''),
+                        string: (0, utils_1.encodeTezosID)(addr.type, addr.hash) + (addr.entryPoint ? '%' + addr.entryPoint : ''),
                     };
                 },
             ];
@@ -1104,13 +1104,13 @@ const getReadTransformFuncs = (t) => {
                     if ('string' in d) {
                         return d;
                     }
-                    const bytes = utils_1.parseBytes(d.bytes);
+                    const bytes = (0, utils_1.parseBytes)(d.bytes);
                     if (bytes === null) {
                         throw new utils_1.MichelsonTypeError(t, `can't parse bytes: ${d.bytes}`, d);
                     }
                     const rd = new Reader(new Uint8Array(bytes));
                     const pk = readPublicKey(rd);
-                    return { string: utils_1.encodeTezosID(pk.type, pk.publicKey) };
+                    return { string: (0, utils_1.encodeTezosID)(pk.type, pk.publicKey) };
                 },
             ];
         case 'address':
@@ -1123,14 +1123,14 @@ const getReadTransformFuncs = (t) => {
                     if ('string' in d) {
                         return d;
                     }
-                    const bytes = utils_1.parseBytes(d.bytes);
+                    const bytes = (0, utils_1.parseBytes)(d.bytes);
                     if (bytes === null) {
                         throw new utils_1.MichelsonTypeError(t, `can't parse bytes: ${d.bytes}`, d);
                     }
                     const rd = new Reader(new Uint8Array(bytes));
                     const addr = readAddress(rd);
                     return {
-                        string: utils_1.encodeTezosID(addr.type, addr.hash) + (addr.entryPoint ? '%' + addr.entryPoint : ''),
+                        string: (0, utils_1.encodeTezosID)(addr.type, addr.hash) + (addr.entryPoint ? '%' + addr.entryPoint : ''),
                     };
                 },
             ];
@@ -1155,7 +1155,7 @@ const getReadTransformFuncs = (t) => {
 const readPassThrough = [
     (e) => {
         if (isPushInstruction(e)) {
-            michelson_validator_1.assertMichelsonInstruction(e);
+            (0, michelson_validator_1.assertMichelsonInstruction)(e);
             // capture inlined type definition
             return (function* () {
                 yield readPassThrough;
@@ -1206,7 +1206,7 @@ function unpackData(src, t) {
         throw new Error('incorrect packed data magic number');
     }
     const ex = readExpr(r, t !== undefined ? getReadTransformFuncs(t) : readPassThrough);
-    if (michelson_validator_1.assertMichelsonData(ex)) {
+    if ((0, michelson_validator_1.assertMichelsonData)(ex)) {
         return ex;
     }
     throw new Error(); // never
@@ -1232,7 +1232,7 @@ exports.unpackData = unpackData;
  * @returns Deserialized data
  */
 function unpackDataBytes(src, t) {
-    const bytes = utils_1.parseBytes(src.bytes);
+    const bytes = (0, utils_1.parseBytes)(src.bytes);
     if (bytes === null) {
         throw new Error(`can't parse bytes: "${src.bytes}"`);
     }
@@ -1241,7 +1241,7 @@ function unpackDataBytes(src, t) {
 exports.unpackDataBytes = unpackDataBytes;
 // helper functions also used by validator
 function decodeAddressBytes(b) {
-    const bytes = utils_1.parseBytes(b.bytes);
+    const bytes = (0, utils_1.parseBytes)(b.bytes);
     if (bytes === null) {
         throw new Error(`can't parse bytes: "${b.bytes}"`);
     }
@@ -1250,7 +1250,7 @@ function decodeAddressBytes(b) {
 }
 exports.decodeAddressBytes = decodeAddressBytes;
 function decodePublicKeyHashBytes(b) {
-    const bytes = utils_1.parseBytes(b.bytes);
+    const bytes = (0, utils_1.parseBytes)(b.bytes);
     if (bytes === null) {
         throw new Error(`can't parse bytes: "${b.bytes}"`);
     }
@@ -1259,7 +1259,7 @@ function decodePublicKeyHashBytes(b) {
 }
 exports.decodePublicKeyHashBytes = decodePublicKeyHashBytes;
 function decodePublicKeyBytes(b) {
-    const bytes = utils_1.parseBytes(b.bytes);
+    const bytes = (0, utils_1.parseBytes)(b.bytes);
     if (bytes === null) {
         throw new Error(`can't parse bytes: "${b.bytes}"`);
     }
@@ -1267,4 +1267,3 @@ function decodePublicKeyBytes(b) {
     return readPublicKey(rd);
 }
 exports.decodePublicKeyBytes = decodePublicKeyBytes;
-//# sourceMappingURL=binary.js.map

package/dist/lib/errors.js

@@ -88,4 +88,3 @@ class HexParseError extends core_1.TaquitoError {
     }
 }
 exports.HexParseError = HexParseError;
-//# sourceMappingURL=errors.js.map

package/dist/lib/formatters.js

@@ -7,12 +7,12 @@ const micheline_emitter_1 = require("./micheline-emitter");
 const utils_1 = require("./utils");
 function formatStack(s) {
     if ('failed' in s) {
-        return `[FAILED: ${micheline_emitter_1.emitMicheline(s.failed)}]`;
+        return `[FAILED: ${(0, micheline_emitter_1.emitMicheline)(s.failed)}]`;
     }
     return s
         .map((v, i) => {
-        const ann = utils_1.unpackAnnotations(v);
-        return `[${i}${ann.v ? '/' + ann.v[0] : ''}]: ${micheline_emitter_1.emitMicheline(v)}`;
+        const ann = (0, utils_1.unpackAnnotations)(v);
+        return `[${i}${ann.v ? '/' + ann.v[0] : ''}]: ${(0, micheline_emitter_1.emitMicheline)(v)}`;
     })
         .join('\n');
 }
@@ -24,7 +24,7 @@ function traceDumpFunc(blocks, cb) {
             return;
         }
         const macro = (_a = v.op[micheline_1.sourceReference]) === null || _a === void 0 ? void 0 : _a.macro;
-        const msg = `${macro ? 'Macro' : 'Op'}: ${macro ? micheline_emitter_1.emitMicheline(macro, undefined, true) + ' / ' : ''}${micheline_emitter_1.emitMicheline(v.op)}
+        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)}
 Output:
@@ -38,25 +38,24 @@ 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;
-        return `${macro ? 'Macro' : 'Op'}: ${macro ? micheline_emitter_1.emitMicheline(macro, undefined, true) + ' / ' : ''}${micheline_emitter_1.emitMicheline(err.val)}
+        return `${macro ? 'Macro' : 'Op'}: ${macro ? (0, micheline_emitter_1.emitMicheline)(macro, undefined, true) + ' / ' : ''}${(0, micheline_emitter_1.emitMicheline)(err.val)}
 Stack:
 ${formatStack(err.stackState)}
 `;
     }
     else if (err instanceof utils_1.MichelsonTypeError) {
         const type = Array.isArray(err.val)
-            ? '[' + err.val.map((v, i) => `[${i}]: ${micheline_emitter_1.emitMicheline(v)}`).join('; ') + ']'
-            : micheline_emitter_1.emitMicheline(err.val);
+            ? '[' + err.val.map((v, i) => `[${i}]: ${(0, micheline_emitter_1.emitMicheline)(v)}`).join('; ') + ']'
+            : (0, micheline_emitter_1.emitMicheline)(err.val);
         return `Type: ${type}
 ${err.data
-            ? `Data: ${micheline_emitter_1.emitMicheline(err.data)}
+            ? `Data: ${(0, micheline_emitter_1.emitMicheline)(err.data)}
 `
             : ''}
 `;
     }
     else {
-        return `Value: ${micheline_emitter_1.emitMicheline(err.val)}`;
+        return `Value: ${(0, micheline_emitter_1.emitMicheline)(err.val)}`;
     }
 }
 exports.formatError = formatError;
-//# sourceMappingURL=formatters.js.map

package/dist/lib/global-constants.js

@@ -11,4 +11,3 @@ function expandGlobalConstants(ex, hashAndValue) {
     return ex;
 }
 exports.expandGlobalConstants = expandGlobalConstants;
-//# sourceMappingURL=global-constants.js.map

package/dist/lib/macros.js

@@ -336,7 +336,7 @@ function expandMacros(ex, opt) {
     }
     // UNPAPPAIIR macro
     if (unpairRe.test(ex.prim)) {
-        if (michelson_types_1.ProtoInferiorTo(proto, michelson_types_1.Protocol.PtEdo2Zk) && assertArgs(ex, 0)) {
+        if ((0, michelson_types_1.ProtoInferiorTo)(proto, michelson_types_1.Protocol.PtEdo2Zk) && assertArgs(ex, 0)) {
             const { r } = parsePairUnpairExpr(ex, ex.prim.slice(3), ex.annots || [], (l, r, top) => [
                 top,
                 ...(r || []),
@@ -497,7 +497,7 @@ function expandMacros(ex, opt) {
         while (ex.prim[1 + n] === 'U') {
             n++;
         }
-        if (michelson_types_1.ProtoInferiorTo(proto, michelson_types_1.Protocol.PtEdo2Zk)) {
+        if ((0, michelson_types_1.ProtoInferiorTo)(proto, michelson_types_1.Protocol.PtEdo2Zk)) {
             if (n === 1) {
                 if (ex.args === undefined) {
                     return ex; // skip
@@ -546,4 +546,3 @@ function expandMacros(ex, opt) {
     return ex;
 }
 exports.expandMacros = expandMacros;
-//# sourceMappingURL=macros.js.map

package/dist/lib/micheline-emitter.js

@@ -131,4 +131,3 @@ function emitMicheline(expr, opt, foldMacros = false) {
     return emitExpr(expr, new Formatter(opt), foldMacros);
 }
 exports.emitMicheline = emitMicheline;
-//# sourceMappingURL=micheline-emitter.js.map

package/dist/lib/micheline-parser.js

@@ -25,7 +25,7 @@ class MichelineParseError extends core_1.TaquitoError {
 exports.MichelineParseError = MichelineParseError;
 /**
  *  @category Error
- *  @description Error inidicates a failure when parsing Micheline JSON
+ *  @description Error indicates a failure when parsing Micheline JSON
  */
 class JSONParseError extends core_1.TaquitoError {
     /**
@@ -64,7 +64,7 @@ const bytesRe = new RegExp('^([0-9a-fA-F]{2})*$');
  * console.log(emitMicheline(storage, {indent:"    ", newline: "\n",}));
  * ```
  *
- * Encode a Michelson expression for inital storage of a smart contract
+ * Encode a Michelson expression for initial storage of a smart contract
  * ```
  * const src = `(Pair (Pair { Elt 1
  *                (Pair (Pair "tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" "tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx")
@@ -85,14 +85,14 @@ class Parser {
     expand(ex) {
         var _a, _b, _c;
         if (((_a = this.opt) === null || _a === void 0 ? void 0 : _a.expandGlobalConstant) !== undefined && ex.prim === 'constant') {
-            const ret = global_constants_1.expandGlobalConstants(ex, this.opt.expandGlobalConstant);
+            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 });
             }
             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) {
-            const ret = macros_1.expandMacros(ex, this.opt);
+            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 });
             }
@@ -273,7 +273,7 @@ class Parser {
         if (typeof src !== 'string') {
             throw new TypeError(`string type was expected, got ${typeof src} instead`);
         }
-        const scanner = scan_1.scan(src);
+        const scanner = (0, scan_1.scan)(src);
         const tok = scanner.next();
         if (tok.done) {
             return null;
@@ -289,7 +289,7 @@ class Parser {
         if (typeof src !== 'string') {
             throw new TypeError(`string type was expected, got ${typeof src} instead`);
         }
-        const scanner = scan_1.scan(src);
+        const scanner = (0, scan_1.scan)(src);
         const tok = scanner.next();
         if (tok.done) {
             return null;
@@ -305,7 +305,7 @@ class Parser {
         if (typeof src !== 'string') {
             throw new TypeError(`string type was expected, got ${typeof src} instead`);
         }
-        const scanner = scan_1.scan(src);
+        const scanner = (0, scan_1.scan)(src);
         const tok = scanner.next();
         if (tok.done) {
             return null;
@@ -401,4 +401,3 @@ class Parser {
     }
 }
 exports.Parser = Parser;
-//# sourceMappingURL=micheline-parser.js.map

package/dist/lib/micheline.js

@@ -3,4 +3,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sourceReference = void 0;
 exports.sourceReference = Symbol('source_reference');
-//# sourceMappingURL=micheline.js.map

package/dist/lib/michelson-contract.js

@@ -9,7 +9,7 @@ class Contract {
     constructor(contract, opt) {
         this.contract = contract;
         this.ctx = Object.assign({ contract }, opt);
-        this.output = michelson_typecheck_1.assertContractValid(contract, this.ctx);
+        this.output = (0, michelson_typecheck_1.assertContractValid)(contract, this.ctx);
     }
     static parse(src, opt) {
         const p = new micheline_parser_1.Parser(opt);
@@ -17,7 +17,7 @@ class Contract {
         if (expr === null) {
             throw new errors_1.InvalidMichelsonError('empty Michelson');
         }
-        if (michelson_validator_1.assertMichelsonContract(expr)) {
+        if ((0, michelson_validator_1.assertMichelsonContract)(expr)) {
             return new Contract(expr, opt);
         }
         throw undefined;
@@ -29,8 +29,8 @@ class Contract {
             throw new errors_1.InvalidTypeExpressionError('empty type expression');
         }
         // remove assertTypeAnnotationsValid from if block because: () => void || throw error
-        if (michelson_validator_1.assertMichelsonType(expr)) {
-            michelson_typecheck_1.assertTypeAnnotationsValid(expr);
+        if ((0, michelson_validator_1.assertMichelsonType)(expr)) {
+            (0, michelson_typecheck_1.assertTypeAnnotationsValid)(expr);
             return expr;
         }
         throw undefined;
@@ -41,25 +41,25 @@ class Contract {
         if (expr === null) {
             throw new errors_1.InvalidDataExpressionError('empty data expression');
         }
-        if (michelson_validator_1.assertMichelsonData(expr)) {
+        if ((0, michelson_validator_1.assertMichelsonData)(expr)) {
             return expr;
         }
         throw undefined;
     }
     section(section) {
-        return michelson_typecheck_1.contractSection(this.contract, section);
+        return (0, michelson_typecheck_1.contractSection)(this.contract, section);
     }
     entryPoints() {
-        return michelson_typecheck_1.contractEntryPoints(this.contract);
+        return (0, michelson_typecheck_1.contractEntryPoints)(this.contract);
     }
     entryPoint(ep) {
-        return michelson_typecheck_1.contractEntryPoint(this.contract, ep);
+        return (0, michelson_typecheck_1.contractEntryPoint)(this.contract, ep);
     }
     assertDataValid(d, t) {
-        michelson_typecheck_1.assertDataValid(d, t, this.ctx);
+        (0, michelson_typecheck_1.assertDataValid)(d, t, this.ctx);
     }
     isDataValid(d, t) {
-        return michelson_typecheck_1.isDataValid(d, t, this.ctx);
+        return (0, michelson_typecheck_1.isDataValid)(d, t, this.ctx);
     }
     assertParameterValid(ep, d) {
         const t = this.entryPoint(ep || undefined);
@@ -78,7 +78,7 @@ class Contract {
         }
     }
     functionType(inst, stack) {
-        return michelson_typecheck_1.functionType(inst, stack, this.ctx);
+        return (0, michelson_typecheck_1.functionType)(inst, stack, this.ctx);
     }
 }
 exports.Contract = Contract;
@@ -91,4 +91,3 @@ exports.dummyContract = new Contract([
         args: [[{ prim: 'CAR' }, { prim: 'NIL', args: [{ prim: 'operation' }] }, { prim: 'PAIR' }]],
     },
 ]);
-//# sourceMappingURL=michelson-contract.js.map