@airgap/icp 0.13.15-beta.1 → 0.13.15-beta.3

package/v1/utils/idl.js

@@ -1,62 +1,11 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Vec = exports.Tuple = exports.Principal = exports.Nat64 = exports.Nat32 = exports.Nat16 = exports.Nat8 = exports.Int64 = exports.Int32 = exports.Int16 = exports.Int8 = exports.Float64 = exports.Float32 = exports.Nat = exports.Int = exports.Text = exports.Null = exports.Bool = exports.Unknown = exports.Reserved = exports.Empty = exports.decode = exports.encode = exports.ServiceClass = exports.FuncClass = exports.PrincipalClass = exports.RecClass = exports.VariantClass = exports.TupleClass = exports.RecordClass = exports.OptClass = exports.VecClass = exports.FixedNatClass = exports.FixedIntClass = exports.FloatClass = exports.NatClass = exports.IntClass = exports.TextClass = exports.ReservedClass = exports.NullClass = exports.BoolClass = exports.UnknownClass = exports.EmptyClass = exports.ConstructType = exports.PrimitiveType = exports.Type = exports.Visitor = exports.idlLabelToId = exports.iexp2 = exports.ilog2 = void 0;
 exports.Service = exports.Func = exports.Rec = exports.Variant = exports.Record = exports.Opt = void 0;
-var buffer_1 = require("./buffer");
-var leb128_1 = require("./leb128");
-var buffer_2 = require("./buffer");
-var principal_1 = require("./principal");
+const buffer_1 = require("./buffer");
+const leb128_1 = require("./leb128");
+const buffer_2 = require("./buffer");
+const principal_1 = require("./principal");
 /**
  * Equivalent to `Math.log2(n)` with support for `BigInt` values
  *
@@ -64,7 +13,7 @@ var principal_1 = require("./principal");
  * @returns integer
  */
 function ilog2(n) {
-    var nBig = BigInt(n);
+    const nBig = BigInt(n);
     if (n <= 0) {
         throw new RangeError('Input must be positive');
     }
@@ -79,7 +28,7 @@ exports.ilog2 = ilog2;
  * @returns bigint
  */
 function iexp2(n) {
-    var nBig = BigInt(n);
+    const nBig = BigInt(n);
     if (n < 0) {
         throw new RangeError('Input must be non-negative');
     }
@@ -87,22 +36,11 @@ function iexp2(n) {
 }
 exports.iexp2 = iexp2;
 function idlHash(s) {
-    var e_1, _a;
-    var utf8encoder = new TextEncoder();
-    var array = utf8encoder.encode(s);
-    var h = 0;
-    try {
-        for (var array_1 = __values(array), array_1_1 = array_1.next(); !array_1_1.done; array_1_1 = array_1.next()) {
-            var c = array_1_1.value;
-            h = (h * 223 + c) % Math.pow(2, 32);
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (array_1_1 && !array_1_1.done && (_a = array_1.return)) _a.call(array_1);
-        }
-        finally { if (e_1) throw e_1.error; }
+    const utf8encoder = new TextEncoder();
+    const array = utf8encoder.encode(s);
+    let h = 0;
+    for (const c of array) {
+        h = (h * 223 + c) % 2 ** 32;
     }
     return h;
 }
@@ -113,39 +51,39 @@ function idlHash(s) {
  */
 function idlLabelToId(label) {
     if (/^_\d+_$/.test(label) || /^_0x[0-9a-fA-F]+_$/.test(label)) {
-        var num = +label.slice(1, -1);
-        if (Number.isSafeInteger(num) && num >= 0 && num < Math.pow(2, 32)) {
+        const num = +label.slice(1, -1);
+        if (Number.isSafeInteger(num) && num >= 0 && num < 2 ** 32) {
             return num;
         }
     }
     return idlHash(label);
 }
 exports.idlLabelToId = idlLabelToId;
-var magicNumber = 'DIDL';
-var toReadableString_max = 400; // will not display arguments after 400chars. Makes sure 2mb blobs don't get inside the error
+const magicNumber = 'DIDL';
+const toReadableString_max = 400; // will not display arguments after 400chars. Makes sure 2mb blobs don't get inside the error
 function zipWith(xs, ys, f) {
-    return xs.map(function (x, i) { return f(x, ys[i]); });
+    return xs.map((x, i) => f(x, ys[i]));
 }
 /**
  * An IDL Type Table, which precedes the data in the stream.
  */
-var TypeTable = /** @class */ (function () {
-    function TypeTable() {
+class TypeTable {
+    constructor() {
         // List of types. Needs to be an array as the index needs to be stable.
         this._typs = [];
         this._idx = new Map();
     }
-    TypeTable.prototype.has = function (obj) {
+    has(obj) {
         return this._idx.has(obj.name);
-    };
-    TypeTable.prototype.add = function (type, buf) {
-        var idx = this._typs.length;
+    }
+    add(type, buf) {
+        const idx = this._typs.length;
         this._idx.set(type.name, idx);
         this._typs.push(buf);
-    };
-    TypeTable.prototype.merge = function (obj, knot) {
-        var idx = this._idx.get(obj.name);
-        var knotIdx = this._idx.get(knot);
+    }
+    merge(obj, knot) {
+        const idx = this._idx.get(obj.name);
+        const knotIdx = this._idx.get(knot);
         if (idx === undefined) {
             throw new Error('Missing type index for ' + obj);
         }
@@ -156,194 +94,168 @@ var TypeTable = /** @class */ (function () {
         // Delete the type.
         this._typs.splice(knotIdx, 1);
         this._idx.delete(knot);
-    };
-    TypeTable.prototype.encode = function () {
-        var len = (0, leb128_1.lebEncode)(this._typs.length);
-        var buf = buffer_1.concat.apply(void 0, __spreadArray([], __read(this._typs), false));
+    }
+    encode() {
+        const len = (0, leb128_1.lebEncode)(this._typs.length);
+        const buf = (0, buffer_1.concat)(...this._typs);
         return (0, buffer_1.concat)(len, buf);
-    };
-    TypeTable.prototype.indexOf = function (typeName) {
+    }
+    indexOf(typeName) {
         if (!this._idx.has(typeName)) {
             throw new Error('Missing type index for ' + typeName);
         }
         return (0, leb128_1.slebEncode)(this._idx.get(typeName) || 0);
-    };
-    return TypeTable;
-}());
-var Visitor = /** @class */ (function () {
-    function Visitor() {
     }
-    Visitor.prototype.visitType = function (t, data) {
+}
+class Visitor {
+    visitType(t, data) {
         throw new Error('Not implemented');
-    };
-    Visitor.prototype.visitPrimitive = function (t, data) {
+    }
+    visitPrimitive(t, data) {
         return this.visitType(t, data);
-    };
-    Visitor.prototype.visitEmpty = function (t, data) {
+    }
+    visitEmpty(t, data) {
         return this.visitPrimitive(t, data);
-    };
-    Visitor.prototype.visitBool = function (t, data) {
+    }
+    visitBool(t, data) {
         return this.visitPrimitive(t, data);
-    };
-    Visitor.prototype.visitNull = function (t, data) {
+    }
+    visitNull(t, data) {
         return this.visitPrimitive(t, data);
-    };
-    Visitor.prototype.visitReserved = function (t, data) {
+    }
+    visitReserved(t, data) {
         return this.visitPrimitive(t, data);
-    };
-    Visitor.prototype.visitText = function (t, data) {
+    }
+    visitText(t, data) {
         return this.visitPrimitive(t, data);
-    };
-    Visitor.prototype.visitNumber = function (t, data) {
+    }
+    visitNumber(t, data) {
         return this.visitPrimitive(t, data);
-    };
-    Visitor.prototype.visitInt = function (t, data) {
+    }
+    visitInt(t, data) {
         return this.visitNumber(t, data);
-    };
-    Visitor.prototype.visitNat = function (t, data) {
+    }
+    visitNat(t, data) {
         return this.visitNumber(t, data);
-    };
-    Visitor.prototype.visitFloat = function (t, data) {
+    }
+    visitFloat(t, data) {
         return this.visitPrimitive(t, data);
-    };
-    Visitor.prototype.visitFixedInt = function (t, data) {
+    }
+    visitFixedInt(t, data) {
         return this.visitNumber(t, data);
-    };
-    Visitor.prototype.visitFixedNat = function (t, data) {
+    }
+    visitFixedNat(t, data) {
         return this.visitNumber(t, data);
-    };
-    Visitor.prototype.visitPrincipal = function (t, data) {
+    }
+    visitPrincipal(t, data) {
         return this.visitPrimitive(t, data);
-    };
-    Visitor.prototype.visitConstruct = function (t, data) {
+    }
+    visitConstruct(t, data) {
         return this.visitType(t, data);
-    };
-    Visitor.prototype.visitVec = function (t, ty, data) {
+    }
+    visitVec(t, ty, data) {
         return this.visitConstruct(t, data);
-    };
-    Visitor.prototype.visitOpt = function (t, ty, data) {
+    }
+    visitOpt(t, ty, data) {
         return this.visitConstruct(t, data);
-    };
-    Visitor.prototype.visitRecord = function (t, fields, data) {
+    }
+    visitRecord(t, fields, data) {
         return this.visitConstruct(t, data);
-    };
-    Visitor.prototype.visitTuple = function (t, components, data) {
-        var fields = components.map(function (ty, i) { return ["_".concat(i, "_"), ty]; });
+    }
+    visitTuple(t, components, data) {
+        const fields = components.map((ty, i) => [`_${i}_`, ty]);
         return this.visitRecord(t, fields, data);
-    };
-    Visitor.prototype.visitVariant = function (t, fields, data) {
+    }
+    visitVariant(t, fields, data) {
         return this.visitConstruct(t, data);
-    };
-    Visitor.prototype.visitRec = function (t, ty, data) {
+    }
+    visitRec(t, ty, data) {
         return this.visitConstruct(ty, data);
-    };
-    Visitor.prototype.visitFunc = function (t, data) {
+    }
+    visitFunc(t, data) {
         return this.visitConstruct(t, data);
-    };
-    Visitor.prototype.visitService = function (t, data) {
+    }
+    visitService(t, data) {
         return this.visitConstruct(t, data);
-    };
-    return Visitor;
-}());
+    }
+}
 exports.Visitor = Visitor;
 /**
  * Represents an IDL type.
  */
-var Type = /** @class */ (function () {
-    function Type() {
-    }
+class Type {
     /* Display type name */
-    Type.prototype.display = function () {
+    display() {
         return this.name;
-    };
-    Type.prototype.valueToString = function (x) {
+    }
+    valueToString(x) {
         return toReadableString(x);
-    };
+    }
     /* Implement `T` in the IDL spec, only needed for non-primitive types */
-    Type.prototype.buildTypeTable = function (typeTable) {
+    buildTypeTable(typeTable) {
         if (!typeTable.has(this)) {
             this._buildTypeTableImpl(typeTable);
         }
-    };
-    return Type;
-}());
-exports.Type = Type;
-var PrimitiveType = /** @class */ (function (_super) {
-    __extends(PrimitiveType, _super);
-    function PrimitiveType() {
-        return _super !== null && _super.apply(this, arguments) || this;
     }
-    PrimitiveType.prototype.checkType = function (t) {
+}
+exports.Type = Type;
+class PrimitiveType extends Type {
+    checkType(t) {
         if (this.name !== t.name) {
-            throw new Error("type mismatch: type on the wire ".concat(t.name, ", expect type ").concat(this.name));
+            throw new Error(`type mismatch: type on the wire ${t.name}, expect type ${this.name}`);
         }
         return t;
-    };
-    PrimitiveType.prototype._buildTypeTableImpl = function (typeTable) {
+    }
+    _buildTypeTableImpl(typeTable) {
         // No type table encoding for Primitive types.
         return;
-    };
-    return PrimitiveType;
-}(Type));
-exports.PrimitiveType = PrimitiveType;
-var ConstructType = /** @class */ (function (_super) {
-    __extends(ConstructType, _super);
-    function ConstructType() {
-        return _super !== null && _super.apply(this, arguments) || this;
     }
-    ConstructType.prototype.checkType = function (t) {
+}
+exports.PrimitiveType = PrimitiveType;
+class ConstructType extends Type {
+    checkType(t) {
         if (t instanceof RecClass) {
-            var ty = t.getType();
+            const ty = t.getType();
             if (typeof ty === 'undefined') {
                 throw new Error('type mismatch with uninitialized type');
             }
             return ty;
         }
-        throw new Error("type mismatch: type on the wire ".concat(t.name, ", expect type ").concat(this.name));
-    };
-    ConstructType.prototype.encodeType = function (typeTable) {
+        throw new Error(`type mismatch: type on the wire ${t.name}, expect type ${this.name}`);
+    }
+    encodeType(typeTable) {
         return typeTable.indexOf(this.name);
-    };
-    return ConstructType;
-}(Type));
+    }
+}
 exports.ConstructType = ConstructType;
 /**
  * Represents an IDL Empty, a type which has no inhabitants.
  * Since no values exist for this type, it cannot be serialised or deserialised.
  * Result types like `Result<Text, Empty>` should always succeed.
  */
-var EmptyClass = /** @class */ (function (_super) {
-    __extends(EmptyClass, _super);
-    function EmptyClass() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    EmptyClass.prototype.accept = function (v, d) {
+class EmptyClass extends PrimitiveType {
+    accept(v, d) {
         return v.visitEmpty(this, d);
-    };
-    EmptyClass.prototype.covariant = function (x) {
-        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
-    };
-    EmptyClass.prototype.encodeValue = function () {
+    }
+    covariant(x) {
+        throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);
+    }
+    encodeValue() {
         throw new Error('Empty cannot appear as a function argument');
-    };
-    EmptyClass.prototype.valueToString = function () {
+    }
+    valueToString() {
         throw new Error('Empty cannot appear as a value');
-    };
-    EmptyClass.prototype.encodeType = function () {
+    }
+    encodeType() {
         return (0, leb128_1.slebEncode)(-17 /* IDLTypeIds.Empty */);
-    };
-    EmptyClass.prototype.decodeValue = function () {
+    }
+    decodeValue() {
         throw new Error('Empty cannot appear as an output');
-    };
-    Object.defineProperty(EmptyClass.prototype, "name", {
-        get: function () {
-            return 'empty';
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return EmptyClass;
-}(PrimitiveType));
+    }
+    get name() {
+        return 'empty';
+    }
+}
 exports.EmptyClass = EmptyClass;
 /**
  * Represents an IDL Unknown, a placeholder type for deserialization only.
@@ -352,43 +264,39 @@ exports.EmptyClass = EmptyClass;
  * A deserialized unknown will offer it's actual type by calling the `type()` function.
  * Unknown cannot be serialized and attempting to do so will throw an error.
  */
-var UnknownClass = /** @class */ (function (_super) {
-    __extends(UnknownClass, _super);
-    function UnknownClass() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    UnknownClass.prototype.checkType = function (t) {
+class UnknownClass extends Type {
+    checkType(t) {
         throw new Error('Method not implemented for unknown.');
-    };
-    UnknownClass.prototype.accept = function (v, d) {
+    }
+    accept(v, d) {
         throw v.visitType(this, d);
-    };
-    UnknownClass.prototype.covariant = function (x) {
-        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
-    };
-    UnknownClass.prototype.encodeValue = function () {
+    }
+    covariant(x) {
+        throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);
+    }
+    encodeValue() {
         throw new Error('Unknown cannot appear as a function argument');
-    };
-    UnknownClass.prototype.valueToString = function () {
+    }
+    valueToString() {
         throw new Error('Unknown cannot appear as a value');
-    };
-    UnknownClass.prototype.encodeType = function () {
+    }
+    encodeType() {
         throw new Error('Unknown cannot be serialized');
-    };
-    UnknownClass.prototype.decodeValue = function (b, t) {
-        var decodedValue = t.decodeValue(b, t);
+    }
+    decodeValue(b, t) {
+        let decodedValue = t.decodeValue(b, t);
         if (Object(decodedValue) !== decodedValue) {
             // decodedValue is primitive. Box it, otherwise we cannot add the type() function.
             // The type() function is important for primitives because otherwise we cannot tell apart the
             // different number types.
             decodedValue = Object(decodedValue);
         }
-        var typeFunc;
+        let typeFunc;
         if (t instanceof RecClass) {
-            typeFunc = function () { return t.getType(); };
+            typeFunc = () => t.getType();
         }
         else {
-            typeFunc = function () { return t; };
+            typeFunc = () => t;
         }
         // Do not use 'decodedValue.type = typeFunc' because this would lead to an enumerable property
         // 'type' which means it would be serialized if the value would be candid encoded again.
@@ -401,43 +309,34 @@ var UnknownClass = /** @class */ (function (_super) {
             configurable: true
         });
         return decodedValue;
-    };
-    UnknownClass.prototype._buildTypeTableImpl = function () {
+    }
+    _buildTypeTableImpl() {
         throw new Error('Unknown cannot be serialized');
-    };
-    Object.defineProperty(UnknownClass.prototype, "name", {
-        get: function () {
-            return 'Unknown';
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return UnknownClass;
-}(Type));
+    }
+    get name() {
+        return 'Unknown';
+    }
+}
 exports.UnknownClass = UnknownClass;
 /**
  * Represents an IDL Bool
  */
-var BoolClass = /** @class */ (function (_super) {
-    __extends(BoolClass, _super);
-    function BoolClass() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    BoolClass.prototype.accept = function (v, d) {
+class BoolClass extends PrimitiveType {
+    accept(v, d) {
         return v.visitBool(this, d);
-    };
-    BoolClass.prototype.covariant = function (x) {
+    }
+    covariant(x) {
         if (typeof x === 'boolean')
             return true;
-        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
-    };
-    BoolClass.prototype.encodeValue = function (x) {
+        throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);
+    }
+    encodeValue(x) {
         return new Uint8Array([x ? 1 : 0]);
-    };
-    BoolClass.prototype.encodeType = function () {
+    }
+    encodeType() {
         return (0, leb128_1.slebEncode)(-2 /* IDLTypeIds.Bool */);
-    };
-    BoolClass.prototype.decodeValue = function (b, t) {
+    }
+    decodeValue(b, t) {
         this.checkType(t);
         switch ((0, leb128_1.safeReadUint8)(b)) {
             case 0:
@@ -447,239 +346,187 @@ var BoolClass = /** @class */ (function (_super) {
             default:
                 throw new Error('Boolean value out of range');
         }
-    };
-    Object.defineProperty(BoolClass.prototype, "name", {
-        get: function () {
-            return 'bool';
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return BoolClass;
-}(PrimitiveType));
+    }
+    get name() {
+        return 'bool';
+    }
+}
 exports.BoolClass = BoolClass;
 /**
  * Represents an IDL Null
  */
-var NullClass = /** @class */ (function (_super) {
-    __extends(NullClass, _super);
-    function NullClass() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    NullClass.prototype.accept = function (v, d) {
+class NullClass extends PrimitiveType {
+    accept(v, d) {
         return v.visitNull(this, d);
-    };
-    NullClass.prototype.covariant = function (x) {
+    }
+    covariant(x) {
         if (x === null)
             return true;
-        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
-    };
-    NullClass.prototype.encodeValue = function () {
+        throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);
+    }
+    encodeValue() {
         return new ArrayBuffer(0);
-    };
-    NullClass.prototype.encodeType = function () {
+    }
+    encodeType() {
         return (0, leb128_1.slebEncode)(-1 /* IDLTypeIds.Null */);
-    };
-    NullClass.prototype.decodeValue = function (b, t) {
+    }
+    decodeValue(b, t) {
         this.checkType(t);
         return null;
-    };
-    Object.defineProperty(NullClass.prototype, "name", {
-        get: function () {
-            return 'null';
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return NullClass;
-}(PrimitiveType));
+    }
+    get name() {
+        return 'null';
+    }
+}
 exports.NullClass = NullClass;
 /**
  * Represents an IDL Reserved
  */
-var ReservedClass = /** @class */ (function (_super) {
-    __extends(ReservedClass, _super);
-    function ReservedClass() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ReservedClass.prototype.accept = function (v, d) {
+class ReservedClass extends PrimitiveType {
+    accept(v, d) {
         return v.visitReserved(this, d);
-    };
-    ReservedClass.prototype.covariant = function (x) {
+    }
+    covariant(x) {
         return true;
-    };
-    ReservedClass.prototype.encodeValue = function () {
+    }
+    encodeValue() {
         return new ArrayBuffer(0);
-    };
-    ReservedClass.prototype.encodeType = function () {
+    }
+    encodeType() {
         return (0, leb128_1.slebEncode)(-16 /* IDLTypeIds.Reserved */);
-    };
-    ReservedClass.prototype.decodeValue = function (b, t) {
+    }
+    decodeValue(b, t) {
         if (t.name !== this.name) {
             t.decodeValue(b, t);
         }
         return null;
-    };
-    Object.defineProperty(ReservedClass.prototype, "name", {
-        get: function () {
-            return 'reserved';
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return ReservedClass;
-}(PrimitiveType));
+    }
+    get name() {
+        return 'reserved';
+    }
+}
 exports.ReservedClass = ReservedClass;
 /**
  * Represents an IDL Text
  */
-var TextClass = /** @class */ (function (_super) {
-    __extends(TextClass, _super);
-    function TextClass() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    TextClass.prototype.accept = function (v, d) {
+class TextClass extends PrimitiveType {
+    accept(v, d) {
         return v.visitText(this, d);
-    };
-    TextClass.prototype.covariant = function (x) {
+    }
+    covariant(x) {
         if (typeof x === 'string')
             return true;
-        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
-    };
-    TextClass.prototype.encodeValue = function (x) {
-        var buf = new TextEncoder().encode(x);
-        var len = (0, leb128_1.lebEncode)(buf.byteLength);
+        throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);
+    }
+    encodeValue(x) {
+        const buf = new TextEncoder().encode(x);
+        const len = (0, leb128_1.lebEncode)(buf.byteLength);
         return (0, buffer_1.concat)(len, buf);
-    };
-    TextClass.prototype.encodeType = function () {
+    }
+    encodeType() {
         return (0, leb128_1.slebEncode)(-15 /* IDLTypeIds.Text */);
-    };
-    TextClass.prototype.decodeValue = function (b, t) {
+    }
+    decodeValue(b, t) {
         this.checkType(t);
-        var len = (0, leb128_1.lebDecode)(b);
-        var buf = (0, leb128_1.safeRead)(b, Number(len));
-        var decoder = new TextDecoder('utf8', { fatal: true });
+        const len = (0, leb128_1.lebDecode)(b);
+        const buf = (0, leb128_1.safeRead)(b, Number(len));
+        const decoder = new TextDecoder('utf8', { fatal: true });
         return decoder.decode(buf);
-    };
-    Object.defineProperty(TextClass.prototype, "name", {
-        get: function () {
-            return 'text';
-        },
-        enumerable: false,
-        configurable: true
-    });
-    TextClass.prototype.valueToString = function (x) {
+    }
+    get name() {
+        return 'text';
+    }
+    valueToString(x) {
         return '"' + x + '"';
-    };
-    return TextClass;
-}(PrimitiveType));
+    }
+}
 exports.TextClass = TextClass;
 /**
  * Represents an IDL Int
  */
-var IntClass = /** @class */ (function (_super) {
-    __extends(IntClass, _super);
-    function IntClass() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    IntClass.prototype.accept = function (v, d) {
+class IntClass extends PrimitiveType {
+    accept(v, d) {
         return v.visitInt(this, d);
-    };
-    IntClass.prototype.covariant = function (x) {
+    }
+    covariant(x) {
         // We allow encoding of JavaScript plain numbers.
         // But we will always decode to bigint.
         if (typeof x === 'bigint' || Number.isInteger(x))
             return true;
-        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
-    };
-    IntClass.prototype.encodeValue = function (x) {
+        throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);
+    }
+    encodeValue(x) {
         return (0, leb128_1.slebEncode)(x);
-    };
-    IntClass.prototype.encodeType = function () {
+    }
+    encodeType() {
         return (0, leb128_1.slebEncode)(-4 /* IDLTypeIds.Int */);
-    };
-    IntClass.prototype.decodeValue = function (b, t) {
+    }
+    decodeValue(b, t) {
         this.checkType(t);
         return (0, leb128_1.slebDecode)(b);
-    };
-    Object.defineProperty(IntClass.prototype, "name", {
-        get: function () {
-            return 'int';
-        },
-        enumerable: false,
-        configurable: true
-    });
-    IntClass.prototype.valueToString = function (x) {
+    }
+    get name() {
+        return 'int';
+    }
+    valueToString(x) {
         return x.toString();
-    };
-    return IntClass;
-}(PrimitiveType));
+    }
+}
 exports.IntClass = IntClass;
 /**
  * Represents an IDL Nat
  */
-var NatClass = /** @class */ (function (_super) {
-    __extends(NatClass, _super);
-    function NatClass() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    NatClass.prototype.accept = function (v, d) {
+class NatClass extends PrimitiveType {
+    accept(v, d) {
         return v.visitNat(this, d);
-    };
-    NatClass.prototype.covariant = function (x) {
+    }
+    covariant(x) {
         // We allow encoding of JavaScript plain numbers.
         // But we will always decode to bigint.
         if ((typeof x === 'bigint' && x >= BigInt(0)) || (Number.isInteger(x) && x >= 0))
             return true;
-        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
-    };
-    NatClass.prototype.encodeValue = function (x) {
+        throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);
+    }
+    encodeValue(x) {
         return (0, leb128_1.lebEncode)(x);
-    };
-    NatClass.prototype.encodeType = function () {
+    }
+    encodeType() {
         return (0, leb128_1.slebEncode)(-3 /* IDLTypeIds.Nat */);
-    };
-    NatClass.prototype.decodeValue = function (b, t) {
+    }
+    decodeValue(b, t) {
         this.checkType(t);
         return (0, leb128_1.lebDecode)(b);
-    };
-    Object.defineProperty(NatClass.prototype, "name", {
-        get: function () {
-            return 'nat';
-        },
-        enumerable: false,
-        configurable: true
-    });
-    NatClass.prototype.valueToString = function (x) {
+    }
+    get name() {
+        return 'nat';
+    }
+    valueToString(x) {
         return x.toString();
-    };
-    return NatClass;
-}(PrimitiveType));
+    }
+}
 exports.NatClass = NatClass;
 /**
  * Represents an IDL Float
  */
-var FloatClass = /** @class */ (function (_super) {
-    __extends(FloatClass, _super);
-    function FloatClass(_bits) {
-        var _this = _super.call(this) || this;
-        _this._bits = _bits;
+class FloatClass extends PrimitiveType {
+    constructor(_bits) {
+        super();
+        this._bits = _bits;
         if (_bits !== 32 && _bits !== 64) {
             throw new Error('not a valid float type');
         }
-        return _this;
     }
-    FloatClass.prototype.accept = function (v, d) {
+    accept(v, d) {
         return v.visitFloat(this, d);
-    };
-    FloatClass.prototype.covariant = function (x) {
+    }
+    covariant(x) {
         if (typeof x === 'number' || x instanceof Number)
             return true;
-        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
-    };
-    FloatClass.prototype.encodeValue = function (x) {
-        var buf = new ArrayBuffer(this._bits / 8);
-        var view = new DataView(buf);
+        throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);
+    }
+    encodeValue(x) {
+        const buf = new ArrayBuffer(this._bits / 8);
+        const view = new DataView(buf);
         if (this._bits === 32) {
             view.setFloat32(0, x, true);
         }
@@ -687,57 +534,50 @@ var FloatClass = /** @class */ (function (_super) {
             view.setFloat64(0, x, true);
         }
         return buf;
-    };
-    FloatClass.prototype.encodeType = function () {
-        var opcode = this._bits === 32 ? -13 /* IDLTypeIds.Float32 */ : -14 /* IDLTypeIds.Float64 */;
+    }
+    encodeType() {
+        const opcode = this._bits === 32 ? -13 /* IDLTypeIds.Float32 */ : -14 /* IDLTypeIds.Float64 */;
         return (0, leb128_1.slebEncode)(opcode);
-    };
-    FloatClass.prototype.decodeValue = function (b, t) {
+    }
+    decodeValue(b, t) {
         this.checkType(t);
-        var bytes = (0, leb128_1.safeRead)(b, this._bits / 8);
-        var view = new DataView(bytes);
+        const bytes = (0, leb128_1.safeRead)(b, this._bits / 8);
+        const view = new DataView(bytes);
         if (this._bits === 32) {
             return view.getFloat32(0, true);
         }
         else {
             return view.getFloat64(0, true);
         }
-    };
-    Object.defineProperty(FloatClass.prototype, "name", {
-        get: function () {
-            return 'float' + this._bits;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    FloatClass.prototype.valueToString = function (x) {
+    }
+    get name() {
+        return 'float' + this._bits;
+    }
+    valueToString(x) {
         return x.toString();
-    };
-    return FloatClass;
-}(PrimitiveType));
+    }
+}
 exports.FloatClass = FloatClass;
 /**
  * Represents an IDL fixed-width Int(n)
  */
-var FixedIntClass = /** @class */ (function (_super) {
-    __extends(FixedIntClass, _super);
-    function FixedIntClass(_bits) {
-        var _this = _super.call(this) || this;
-        _this._bits = _bits;
-        return _this;
-    }
-    FixedIntClass.prototype.accept = function (v, d) {
+class FixedIntClass extends PrimitiveType {
+    constructor(_bits) {
+        super();
+        this._bits = _bits;
+    }
+    accept(v, d) {
         return v.visitFixedInt(this, d);
-    };
-    FixedIntClass.prototype.covariant = function (x) {
-        var min = iexp2(this._bits - 1) * BigInt(-1);
-        var max = iexp2(this._bits - 1) - BigInt(1);
-        var ok = false;
+    }
+    covariant(x) {
+        const min = iexp2(this._bits - 1) * BigInt(-1);
+        const max = iexp2(this._bits - 1) - BigInt(1);
+        let ok = false;
         if (typeof x === 'bigint') {
             ok = x >= min && x <= max;
         }
         else if (Number.isInteger(x)) {
-            var v = BigInt(x);
+            const v = BigInt(x);
             ok = v >= min && v <= max;
         }
         else {
@@ -745,59 +585,52 @@ var FixedIntClass = /** @class */ (function (_super) {
         }
         if (ok)
             return true;
-        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
-    };
-    FixedIntClass.prototype.encodeValue = function (x) {
+        throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);
+    }
+    encodeValue(x) {
         return (0, leb128_1.writeIntLE)(x, this._bits / 8);
-    };
-    FixedIntClass.prototype.encodeType = function () {
-        var offset = Math.log2(this._bits) - 3;
+    }
+    encodeType() {
+        const offset = Math.log2(this._bits) - 3;
         return (0, leb128_1.slebEncode)(-9 - offset);
-    };
-    FixedIntClass.prototype.decodeValue = function (b, t) {
+    }
+    decodeValue(b, t) {
         this.checkType(t);
-        var num = (0, leb128_1.readIntLE)(b, this._bits / 8);
+        const num = (0, leb128_1.readIntLE)(b, this._bits / 8);
         if (this._bits <= 32) {
             return Number(num);
         }
         else {
             return num;
         }
-    };
-    Object.defineProperty(FixedIntClass.prototype, "name", {
-        get: function () {
-            return "int".concat(this._bits);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    FixedIntClass.prototype.valueToString = function (x) {
+    }
+    get name() {
+        return `int${this._bits}`;
+    }
+    valueToString(x) {
         return x.toString();
-    };
-    return FixedIntClass;
-}(PrimitiveType));
+    }
+}
 exports.FixedIntClass = FixedIntClass;
 /**
  * Represents an IDL fixed-width Nat(n)
  */
-var FixedNatClass = /** @class */ (function (_super) {
-    __extends(FixedNatClass, _super);
-    function FixedNatClass(_bits) {
-        var _this = _super.call(this) || this;
-        _this._bits = _bits;
-        return _this;
-    }
-    FixedNatClass.prototype.accept = function (v, d) {
+class FixedNatClass extends PrimitiveType {
+    constructor(_bits) {
+        super();
+        this._bits = _bits;
+    }
+    accept(v, d) {
         return v.visitFixedNat(this, d);
-    };
-    FixedNatClass.prototype.covariant = function (x) {
-        var max = iexp2(this._bits);
-        var ok = false;
+    }
+    covariant(x) {
+        const max = iexp2(this._bits);
+        let ok = false;
         if (typeof x === 'bigint' && x >= BigInt(0)) {
             ok = x < max;
         }
         else if (Number.isInteger(x) && x >= 0) {
-            var v = BigInt(x);
+            const v = BigInt(x);
             ok = v < max;
         }
         else {
@@ -805,37 +638,32 @@ var FixedNatClass = /** @class */ (function (_super) {
         }
         if (ok)
             return true;
-        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
-    };
-    FixedNatClass.prototype.encodeValue = function (x) {
+        throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);
+    }
+    encodeValue(x) {
         return (0, leb128_1.writeUIntLE)(x, this._bits / 8);
-    };
-    FixedNatClass.prototype.encodeType = function () {
-        var offset = Math.log2(this._bits) - 3;
+    }
+    encodeType() {
+        const offset = Math.log2(this._bits) - 3;
         return (0, leb128_1.slebEncode)(-5 - offset);
-    };
-    FixedNatClass.prototype.decodeValue = function (b, t) {
+    }
+    decodeValue(b, t) {
         this.checkType(t);
-        var num = (0, leb128_1.readUIntLE)(b, this._bits / 8);
+        const num = (0, leb128_1.readUIntLE)(b, this._bits / 8);
         if (this._bits <= 32) {
             return Number(num);
         }
         else {
             return num;
         }
-    };
-    Object.defineProperty(FixedNatClass.prototype, "name", {
-        get: function () {
-            return "nat".concat(this._bits);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    FixedNatClass.prototype.valueToString = function (x) {
+    }
+    get name() {
+        return `nat${this._bits}`;
+    }
+    valueToString(x) {
         return x.toString();
-    };
-    return FixedNatClass;
-}(PrimitiveType));
+    }
+}
 exports.FixedNatClass = FixedNatClass;
 /**
  * Represents an IDL Array
@@ -845,82 +673,68 @@ exports.FixedNatClass = FixedNatClass;
  *
  * @param {Type} t
  */
-var VecClass = /** @class */ (function (_super) {
-    __extends(VecClass, _super);
-    function VecClass(_type) {
-        var _this = _super.call(this) || this;
-        _this._type = _type;
+class VecClass extends ConstructType {
+    constructor(_type) {
+        super();
+        this._type = _type;
         // If true, this vector is really a blob and we can just use memcpy.
         //
         // NOTE:
         // With support of encoding/dencoding of TypedArrays, this optimization is
         // only used when plain array of bytes are passed as encoding input in order
         // to be backward compatible.
-        _this._blobOptimization = false;
+        this._blobOptimization = false;
         if (_type instanceof FixedNatClass && _type._bits === 8) {
-            _this._blobOptimization = true;
+            this._blobOptimization = true;
         }
-        return _this;
     }
-    VecClass.prototype.accept = function (v, d) {
+    accept(v, d) {
         return v.visitVec(this, this._type, d);
-    };
-    VecClass.prototype.covariant = function (x) {
-        var _this = this;
+    }
+    covariant(x) {
         // Special case for ArrayBuffer
-        var bits = this._type instanceof FixedNatClass ? this._type._bits : this._type instanceof FixedIntClass ? this._type._bits : 0;
+        const bits = this._type instanceof FixedNatClass ? this._type._bits : this._type instanceof FixedIntClass ? this._type._bits : 0;
         if ((ArrayBuffer.isView(x) && bits == x.BYTES_PER_ELEMENT * 8) ||
             (Array.isArray(x) &&
-                x.every(function (v, idx) {
+                x.every((v, idx) => {
                     try {
-                        return _this._type.covariant(v);
+                        return this._type.covariant(v);
                     }
                     catch (e) {
-                        throw new Error("Invalid ".concat(_this.display(), " argument: \n\nindex ").concat(idx, " -> ").concat(e.message));
+                        throw new Error(`Invalid ${this.display()} argument: \n\nindex ${idx} -> ${e.message}`);
                     }
                 })))
             return true;
-        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
-    };
-    VecClass.prototype.encodeValue = function (x) {
-        var e_2, _a;
-        var len = (0, leb128_1.lebEncode)(x.length);
+        throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);
+    }
+    encodeValue(x) {
+        const len = (0, leb128_1.lebEncode)(x.length);
         if (this._blobOptimization) {
             return (0, buffer_1.concat)(len, new Uint8Array(x));
         }
         if (ArrayBuffer.isView(x)) {
             return (0, buffer_1.concat)(len, new Uint8Array(x.buffer));
         }
-        var buf = new buffer_2.PipeArrayBuffer(new ArrayBuffer(len.byteLength + x.length), 0);
+        const buf = new buffer_2.PipeArrayBuffer(new ArrayBuffer(len.byteLength + x.length), 0);
         buf.write(len);
-        try {
-            for (var x_1 = __values(x), x_1_1 = x_1.next(); !x_1_1.done; x_1_1 = x_1.next()) {
-                var d = x_1_1.value;
-                var encoded = this._type.encodeValue(d);
-                buf.write(new Uint8Array(encoded));
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (x_1_1 && !x_1_1.done && (_a = x_1.return)) _a.call(x_1);
-            }
-            finally { if (e_2) throw e_2.error; }
+        for (const d of x) {
+            const encoded = this._type.encodeValue(d);
+            buf.write(new Uint8Array(encoded));
         }
         return buf.buffer;
-    };
-    VecClass.prototype._buildTypeTableImpl = function (typeTable) {
+    }
+    _buildTypeTableImpl(typeTable) {
         this._type.buildTypeTable(typeTable);
-        var opCode = (0, leb128_1.slebEncode)(-19 /* IDLTypeIds.Vector */);
-        var buffer = this._type.encodeType(typeTable);
+        const opCode = (0, leb128_1.slebEncode)(-19 /* IDLTypeIds.Vector */);
+        const buffer = this._type.encodeType(typeTable);
         typeTable.add(this, (0, buffer_1.concat)(opCode, buffer));
-    };
-    VecClass.prototype.decodeValue = function (b, t) {
-        var vec = this.checkType(t);
+    }
+    decodeValue(b, t) {
+        const vec = this.checkType(t);
         if (!(vec instanceof VecClass)) {
             throw new Error('Not a vector type');
         }
-        var len = Number((0, leb128_1.lebDecode)(b));
+        const len = Number((0, leb128_1.lebDecode)(b));
         if (this._type instanceof FixedNatClass) {
             if (this._type._bits == 8) {
                 return new Uint8Array(b.read(len));
@@ -949,70 +763,62 @@ var VecClass = /** @class */ (function (_super) {
                 return new BigInt64Array(b.read(len * 8));
             }
         }
-        var rets = [];
-        for (var i = 0; i < len; i++) {
+        const rets = [];
+        for (let i = 0; i < len; i++) {
             rets.push(this._type.decodeValue(b, vec._type));
         }
         return rets;
-    };
-    Object.defineProperty(VecClass.prototype, "name", {
-        get: function () {
-            return "vec ".concat(this._type.name);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    VecClass.prototype.display = function () {
-        return "vec ".concat(this._type.display());
-    };
-    VecClass.prototype.valueToString = function (x) {
-        var _this = this;
-        var elements = x.map(function (e) { return _this._type.valueToString(e); });
+    }
+    get name() {
+        return `vec ${this._type.name}`;
+    }
+    display() {
+        return `vec ${this._type.display()}`;
+    }
+    valueToString(x) {
+        const elements = x.map((e) => this._type.valueToString(e));
         return 'vec {' + elements.join('; ') + '}';
-    };
-    return VecClass;
-}(ConstructType));
+    }
+}
 exports.VecClass = VecClass;
 /**
  * Represents an IDL Option
  * @param {Type} t
  */
-var OptClass = /** @class */ (function (_super) {
-    __extends(OptClass, _super);
-    function OptClass(_type) {
-        var _this = _super.call(this) || this;
-        _this._type = _type;
-        return _this;
-    }
-    OptClass.prototype.accept = function (v, d) {
+class OptClass extends ConstructType {
+    constructor(_type) {
+        super();
+        this._type = _type;
+    }
+    accept(v, d) {
         return v.visitOpt(this, this._type, d);
-    };
-    OptClass.prototype.covariant = function (x) {
+    }
+    covariant(x) {
         try {
             if (Array.isArray(x) && (x.length === 0 || (x.length === 1 && this._type.covariant(x[0]))))
                 return true;
         }
         catch (e) {
-            throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x), " \n\n-> ").concat(e.message));
+            throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)} \n\n-> ${e.message}`);
         }
-        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
-    };
-    OptClass.prototype.encodeValue = function (x) {
+        throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);
+    }
+    encodeValue(x) {
         if (x.length === 0) {
             return new Uint8Array([0]);
         }
         else {
             return (0, buffer_1.concat)(new Uint8Array([1]), this._type.encodeValue(x[0]));
         }
-    };
-    OptClass.prototype._buildTypeTableImpl = function (typeTable) {
+    }
+    _buildTypeTableImpl(typeTable) {
         this._type.buildTypeTable(typeTable);
-        var opCode = (0, leb128_1.slebEncode)(-18 /* IDLTypeIds.Opt */);
-        var buffer = this._type.encodeType(typeTable);
+        const opCode = (0, leb128_1.slebEncode)(-18 /* IDLTypeIds.Opt */);
+        const buffer = this._type.encodeType(typeTable);
         typeTable.add(this, (0, buffer_1.concat)(opCode, buffer));
-    };
-    OptClass.prototype.decodeValue = function (b, t) {
-        var opt = this.checkType(t);
+    }
+    decodeValue(b, t) {
+        const opt = this.checkType(t);
         if (!(opt instanceof OptClass)) {
             throw new Error('Not an option type');
         }
@@ -1024,117 +830,94 @@ var OptClass = /** @class */ (function (_super) {
             default:
                 throw new Error('Not an option value');
         }
-    };
-    Object.defineProperty(OptClass.prototype, "name", {
-        get: function () {
-            return "opt ".concat(this._type.name);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    OptClass.prototype.display = function () {
-        return "opt ".concat(this._type.display());
-    };
-    OptClass.prototype.valueToString = function (x) {
+    }
+    get name() {
+        return `opt ${this._type.name}`;
+    }
+    display() {
+        return `opt ${this._type.display()}`;
+    }
+    valueToString(x) {
         if (x.length === 0) {
             return 'null';
         }
         else {
-            return "opt ".concat(this._type.valueToString(x[0]));
+            return `opt ${this._type.valueToString(x[0])}`;
         }
-    };
-    return OptClass;
-}(ConstructType));
+    }
+}
 exports.OptClass = OptClass;
 /**
  * Represents an IDL Record
  * @param {Object} [fields] - mapping of function name to Type
  */
-var RecordClass = /** @class */ (function (_super) {
-    __extends(RecordClass, _super);
-    function RecordClass(fields) {
-        if (fields === void 0) { fields = {}; }
-        var _this = _super.call(this) || this;
-        _this._fields = Object.entries(fields).sort(function (a, b) { return idlLabelToId(a[0]) - idlLabelToId(b[0]); });
-        return _this;
-    }
-    RecordClass.prototype.accept = function (v, d) {
+class RecordClass extends ConstructType {
+    constructor(fields = {}) {
+        super();
+        this._fields = Object.entries(fields).sort((a, b) => idlLabelToId(a[0]) - idlLabelToId(b[0]));
+    }
+    accept(v, d) {
         return v.visitRecord(this, this._fields, d);
-    };
-    RecordClass.prototype.tryAsTuple = function () {
-        var res = [];
-        for (var i = 0; i < this._fields.length; i++) {
-            var _a = __read(this._fields[i], 2), key = _a[0], type = _a[1];
-            if (key !== "_".concat(i, "_")) {
+    }
+    tryAsTuple() {
+        const res = [];
+        for (let i = 0; i < this._fields.length; i++) {
+            const [key, type] = this._fields[i];
+            if (key !== `_${i}_`) {
                 return null;
             }
             res.push(type);
         }
         return res;
-    };
-    RecordClass.prototype.covariant = function (x) {
-        var _this = this;
+    }
+    covariant(x) {
         if (typeof x === 'object' &&
-            this._fields.every(function (_a) {
-                var _b = __read(_a, 2), k = _b[0], t = _b[1];
+            this._fields.every(([k, t]) => {
                 // eslint-disable-next-line
                 if (!x.hasOwnProperty(k)) {
-                    throw new Error("Record is missing key \"".concat(k, "\"."));
+                    throw new Error(`Record is missing key "${k}".`);
                 }
                 try {
                     return t.covariant(x[k]);
                 }
                 catch (e) {
-                    throw new Error("Invalid ".concat(_this.display(), " argument: \n\nfield ").concat(k, " -> ").concat(e.message));
+                    throw new Error(`Invalid ${this.display()} argument: \n\nfield ${k} -> ${e.message}`);
                 }
             }))
             return true;
-        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
-    };
-    RecordClass.prototype.encodeValue = function (x) {
-        var values = this._fields.map(function (_a) {
-            var _b = __read(_a, 1), key = _b[0];
-            return x[key];
-        });
-        var bufs = zipWith(this._fields, values, function (_a, d) {
-            var _b = __read(_a, 2), c = _b[1];
-            return c.encodeValue(d);
-        });
-        return buffer_1.concat.apply(void 0, __spreadArray([], __read(bufs), false));
-    };
-    RecordClass.prototype._buildTypeTableImpl = function (T) {
-        this._fields.forEach(function (_a) {
-            var _b = __read(_a, 2), _ = _b[0], value = _b[1];
-            return value.buildTypeTable(T);
-        });
-        var opCode = (0, leb128_1.slebEncode)(-20 /* IDLTypeIds.Record */);
-        var len = (0, leb128_1.lebEncode)(this._fields.length);
-        var fields = this._fields.map(function (_a) {
-            var _b = __read(_a, 2), key = _b[0], value = _b[1];
-            return (0, buffer_1.concat)((0, leb128_1.lebEncode)(idlLabelToId(key)), value.encodeType(T));
-        });
-        T.add(this, (0, buffer_1.concat)(opCode, len, buffer_1.concat.apply(void 0, __spreadArray([], __read(fields), false))));
-    };
-    RecordClass.prototype.decodeValue = function (b, t) {
-        var e_3, _a;
-        var record = this.checkType(t);
+        throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);
+    }
+    encodeValue(x) {
+        const values = this._fields.map(([key]) => x[key]);
+        const bufs = zipWith(this._fields, values, ([, c], d) => c.encodeValue(d));
+        return (0, buffer_1.concat)(...bufs);
+    }
+    _buildTypeTableImpl(T) {
+        this._fields.forEach(([_, value]) => value.buildTypeTable(T));
+        const opCode = (0, leb128_1.slebEncode)(-20 /* IDLTypeIds.Record */);
+        const len = (0, leb128_1.lebEncode)(this._fields.length);
+        const fields = this._fields.map(([key, value]) => (0, buffer_1.concat)((0, leb128_1.lebEncode)(idlLabelToId(key)), value.encodeType(T)));
+        T.add(this, (0, buffer_1.concat)(opCode, len, (0, buffer_1.concat)(...fields)));
+    }
+    decodeValue(b, t) {
+        const record = this.checkType(t);
         if (!(record instanceof RecordClass)) {
             throw new Error('Not a record type');
         }
-        var x = {};
-        var expectedRecordIdx = 0;
-        var actualRecordIdx = 0;
+        const x = {};
+        let expectedRecordIdx = 0;
+        let actualRecordIdx = 0;
         while (actualRecordIdx < record._fields.length) {
-            var _b = __read(record._fields[actualRecordIdx], 2), hash = _b[0], type = _b[1];
+            const [hash, type] = record._fields[actualRecordIdx];
             if (expectedRecordIdx >= this._fields.length) {
                 // skip unexpected left over fields present on the wire
                 type.decodeValue(b, type);
                 actualRecordIdx++;
                 continue;
             }
-            var _c = __read(this._fields[expectedRecordIdx], 2), expectKey = _c[0], expectType = _c[1];
-            var expectedId = idlLabelToId(this._fields[expectedRecordIdx][0]);
-            var actualId = idlLabelToId(hash);
+            const [expectKey, expectType] = this._fields[expectedRecordIdx];
+            const expectedId = idlLabelToId(this._fields[expectedRecordIdx][0]);
+            const actualId = idlLabelToId(hash);
             if (expectedId === actualId) {
                 // the current field on the wire matches the expected field
                 x[expectKey] = expectType.decodeValue(b, type);
@@ -1157,392 +940,291 @@ var RecordClass = /** @class */ (function (_super) {
                 actualRecordIdx++;
             }
         }
-        try {
-            // initialize left over expected optional fields
-            for (var _d = __values(this._fields.slice(expectedRecordIdx)), _e = _d.next(); !_e.done; _e = _d.next()) {
-                var _f = __read(_e.value, 2), expectKey = _f[0], expectType = _f[1];
-                if (expectType instanceof OptClass || expectType instanceof ReservedClass) {
-                    // TODO this assumes null value in opt is represented as []
-                    x[expectKey] = [];
-                }
-                else {
-                    throw new Error('Cannot find required field ' + expectKey);
-                }
+        // initialize left over expected optional fields
+        for (const [expectKey, expectType] of this._fields.slice(expectedRecordIdx)) {
+            if (expectType instanceof OptClass || expectType instanceof ReservedClass) {
+                // TODO this assumes null value in opt is represented as []
+                x[expectKey] = [];
             }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            else {
+                throw new Error('Cannot find required field ' + expectKey);
             }
-            finally { if (e_3) throw e_3.error; }
         }
         return x;
-    };
-    Object.defineProperty(RecordClass.prototype, "name", {
-        get: function () {
-            var fields = this._fields.map(function (_a) {
-                var _b = __read(_a, 2), key = _b[0], value = _b[1];
-                return key + ':' + value.name;
-            });
-            return "record {".concat(fields.join('; '), "}");
-        },
-        enumerable: false,
-        configurable: true
-    });
-    RecordClass.prototype.display = function () {
-        var fields = this._fields.map(function (_a) {
-            var _b = __read(_a, 2), key = _b[0], value = _b[1];
-            return key + ':' + value.display();
-        });
-        return "record {".concat(fields.join('; '), "}");
-    };
-    RecordClass.prototype.valueToString = function (x) {
-        var values = this._fields.map(function (_a) {
-            var _b = __read(_a, 1), key = _b[0];
-            return x[key];
-        });
-        var fields = zipWith(this._fields, values, function (_a, d) {
-            var _b = __read(_a, 2), k = _b[0], c = _b[1];
-            return k + '=' + c.valueToString(d);
-        });
-        return "record {".concat(fields.join('; '), "}");
-    };
-    return RecordClass;
-}(ConstructType));
+    }
+    get name() {
+        const fields = this._fields.map(([key, value]) => key + ':' + value.name);
+        return `record {${fields.join('; ')}}`;
+    }
+    display() {
+        const fields = this._fields.map(([key, value]) => key + ':' + value.display());
+        return `record {${fields.join('; ')}}`;
+    }
+    valueToString(x) {
+        const values = this._fields.map(([key]) => x[key]);
+        const fields = zipWith(this._fields, values, ([k, c], d) => k + '=' + c.valueToString(d));
+        return `record {${fields.join('; ')}}`;
+    }
+}
 exports.RecordClass = RecordClass;
 /**
  * Represents Tuple, a syntactic sugar for Record.
  * @param {Type} components
  */
-var TupleClass = /** @class */ (function (_super) {
-    __extends(TupleClass, _super);
-    function TupleClass(_components) {
-        var _this = this;
-        var x = {};
-        _components.forEach(function (e, i) { return (x['_' + i + '_'] = e); });
-        _this = _super.call(this, x) || this;
-        _this._components = _components;
-        return _this;
-    }
-    TupleClass.prototype.accept = function (v, d) {
+class TupleClass extends RecordClass {
+    constructor(_components) {
+        const x = {};
+        _components.forEach((e, i) => (x['_' + i + '_'] = e));
+        super(x);
+        this._components = _components;
+    }
+    accept(v, d) {
         return v.visitTuple(this, this._components, d);
-    };
-    TupleClass.prototype.covariant = function (x) {
+    }
+    covariant(x) {
         // `>=` because tuples can be covariant when encoded.
-        var _this = this;
         if (Array.isArray(x) &&
             x.length >= this._fields.length &&
-            this._components.every(function (t, i) {
+            this._components.every((t, i) => {
                 try {
                     return t.covariant(x[i]);
                 }
                 catch (e) {
-                    throw new Error("Invalid ".concat(_this.display(), " argument: \n\nindex ").concat(i, " -> ").concat(e.message));
+                    throw new Error(`Invalid ${this.display()} argument: \n\nindex ${i} -> ${e.message}`);
                 }
             }))
             return true;
-        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
-    };
-    TupleClass.prototype.encodeValue = function (x) {
-        var bufs = zipWith(this._components, x, function (c, d) { return c.encodeValue(d); });
-        return buffer_1.concat.apply(void 0, __spreadArray([], __read(bufs), false));
-    };
-    TupleClass.prototype.decodeValue = function (b, t) {
-        var e_4, _a;
-        var tuple = this.checkType(t);
+        throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);
+    }
+    encodeValue(x) {
+        const bufs = zipWith(this._components, x, (c, d) => c.encodeValue(d));
+        return (0, buffer_1.concat)(...bufs);
+    }
+    decodeValue(b, t) {
+        const tuple = this.checkType(t);
         if (!(tuple instanceof TupleClass)) {
             throw new Error('not a tuple type');
         }
         if (tuple._components.length < this._components.length) {
             throw new Error('tuple mismatch');
         }
-        var res = [];
-        try {
-            for (var _b = __values(tuple._components.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var _d = __read(_c.value, 2), i = _d[0], wireType = _d[1];
-                if (i >= this._components.length) {
-                    // skip value
-                    wireType.decodeValue(b, wireType);
-                }
-                else {
-                    res.push(this._components[i].decodeValue(b, wireType));
-                }
+        const res = [];
+        for (const [i, wireType] of tuple._components.entries()) {
+            if (i >= this._components.length) {
+                // skip value
+                wireType.decodeValue(b, wireType);
             }
-        }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            else {
+                res.push(this._components[i].decodeValue(b, wireType));
             }
-            finally { if (e_4) throw e_4.error; }
         }
         return res;
-    };
-    TupleClass.prototype.display = function () {
-        var fields = this._components.map(function (value) { return value.display(); });
-        return "record {".concat(fields.join('; '), "}");
-    };
-    TupleClass.prototype.valueToString = function (values) {
-        var fields = zipWith(this._components, values, function (c, d) { return c.valueToString(d); });
-        return "record {".concat(fields.join('; '), "}");
-    };
-    return TupleClass;
-}(RecordClass));
+    }
+    display() {
+        const fields = this._components.map((value) => value.display());
+        return `record {${fields.join('; ')}}`;
+    }
+    valueToString(values) {
+        const fields = zipWith(this._components, values, (c, d) => c.valueToString(d));
+        return `record {${fields.join('; ')}}`;
+    }
+}
 exports.TupleClass = TupleClass;
 /**
  * Represents an IDL Variant
  * @param {Object} [fields] - mapping of function name to Type
  */
-var VariantClass = /** @class */ (function (_super) {
-    __extends(VariantClass, _super);
-    function VariantClass(fields) {
-        if (fields === void 0) { fields = {}; }
-        var _this = _super.call(this) || this;
-        _this._fields = Object.entries(fields).sort(function (a, b) { return idlLabelToId(a[0]) - idlLabelToId(b[0]); });
-        return _this;
-    }
-    VariantClass.prototype.accept = function (v, d) {
+class VariantClass extends ConstructType {
+    constructor(fields = {}) {
+        super();
+        this._fields = Object.entries(fields).sort((a, b) => idlLabelToId(a[0]) - idlLabelToId(b[0]));
+    }
+    accept(v, d) {
         return v.visitVariant(this, this._fields, d);
-    };
-    VariantClass.prototype.covariant = function (x) {
-        var _this = this;
+    }
+    covariant(x) {
         if (typeof x === 'object' &&
             Object.entries(x).length === 1 &&
-            this._fields.every(function (_a) {
-                var _b = __read(_a, 2), k = _b[0], v = _b[1];
+            this._fields.every(([k, v]) => {
                 try {
                     // eslint-disable-next-line
                     return !x.hasOwnProperty(k) || v.covariant(x[k]);
                 }
                 catch (e) {
-                    throw new Error("Invalid ".concat(_this.display(), " argument: \n\nvariant ").concat(k, " -> ").concat(e.message));
+                    throw new Error(`Invalid ${this.display()} argument: \n\nvariant ${k} -> ${e.message}`);
                 }
             }))
             return true;
-        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
-    };
-    VariantClass.prototype.encodeValue = function (x) {
-        for (var i = 0; i < this._fields.length; i++) {
-            var _a = __read(this._fields[i], 2), name_1 = _a[0], type = _a[1];
+        throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);
+    }
+    encodeValue(x) {
+        for (let i = 0; i < this._fields.length; i++) {
+            const [name, type] = this._fields[i];
             // eslint-disable-next-line
-            if (x.hasOwnProperty(name_1)) {
-                var idx = (0, leb128_1.lebEncode)(i);
-                var buf = type.encodeValue(x[name_1]);
+            if (x.hasOwnProperty(name)) {
+                const idx = (0, leb128_1.lebEncode)(i);
+                const buf = type.encodeValue(x[name]);
                 return (0, buffer_1.concat)(idx, buf);
             }
         }
         throw Error('Variant has no data: ' + x);
-    };
-    VariantClass.prototype._buildTypeTableImpl = function (typeTable) {
-        this._fields.forEach(function (_a) {
-            var _b = __read(_a, 2), type = _b[1];
+    }
+    _buildTypeTableImpl(typeTable) {
+        this._fields.forEach(([, type]) => {
             type.buildTypeTable(typeTable);
         });
-        var opCode = (0, leb128_1.slebEncode)(-21 /* IDLTypeIds.Variant */);
-        var len = (0, leb128_1.lebEncode)(this._fields.length);
-        var fields = this._fields.map(function (_a) {
-            var _b = __read(_a, 2), key = _b[0], value = _b[1];
-            return (0, buffer_1.concat)((0, leb128_1.lebEncode)(idlLabelToId(key)), value.encodeType(typeTable));
-        });
-        typeTable.add(this, buffer_1.concat.apply(void 0, __spreadArray([opCode, len], __read(fields), false)));
-    };
-    VariantClass.prototype.decodeValue = function (b, t) {
-        var e_5, _a, _b;
-        var variant = this.checkType(t);
+        const opCode = (0, leb128_1.slebEncode)(-21 /* IDLTypeIds.Variant */);
+        const len = (0, leb128_1.lebEncode)(this._fields.length);
+        const fields = this._fields.map(([key, value]) => (0, buffer_1.concat)((0, leb128_1.lebEncode)(idlLabelToId(key)), value.encodeType(typeTable)));
+        typeTable.add(this, (0, buffer_1.concat)(opCode, len, ...fields));
+    }
+    decodeValue(b, t) {
+        const variant = this.checkType(t);
         if (!(variant instanceof VariantClass)) {
             throw new Error('Not a variant type');
         }
-        var idx = Number((0, leb128_1.lebDecode)(b));
+        const idx = Number((0, leb128_1.lebDecode)(b));
         if (idx >= variant._fields.length) {
             throw Error('Invalid variant index: ' + idx);
         }
-        var _c = __read(variant._fields[idx], 2), wireHash = _c[0], wireType = _c[1];
-        try {
-            for (var _d = __values(this._fields), _e = _d.next(); !_e.done; _e = _d.next()) {
-                var _f = __read(_e.value, 2), key = _f[0], expectType = _f[1];
-                if (idlLabelToId(wireHash) === idlLabelToId(key)) {
-                    var value = expectType.decodeValue(b, wireType);
-                    return _b = {}, _b[key] = value, _b;
-                }
-            }
-        }
-        catch (e_5_1) { e_5 = { error: e_5_1 }; }
-        finally {
-            try {
-                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+        const [wireHash, wireType] = variant._fields[idx];
+        for (const [key, expectType] of this._fields) {
+            if (idlLabelToId(wireHash) === idlLabelToId(key)) {
+                const value = expectType.decodeValue(b, wireType);
+                return { [key]: value };
             }
-            finally { if (e_5) throw e_5.error; }
         }
         throw new Error('Cannot find field hash ' + wireHash);
-    };
-    Object.defineProperty(VariantClass.prototype, "name", {
-        get: function () {
-            var fields = this._fields.map(function (_a) {
-                var _b = __read(_a, 2), key = _b[0], type = _b[1];
-                return key + ':' + type.name;
-            });
-            return "variant {".concat(fields.join('; '), "}");
-        },
-        enumerable: false,
-        configurable: true
-    });
-    VariantClass.prototype.display = function () {
-        var fields = this._fields.map(function (_a) {
-            var _b = __read(_a, 2), key = _b[0], type = _b[1];
-            return key + (type.name === 'null' ? '' : ":".concat(type.display()));
-        });
-        return "variant {".concat(fields.join('; '), "}");
-    };
-    VariantClass.prototype.valueToString = function (x) {
-        var e_6, _a;
-        try {
-            for (var _b = __values(this._fields), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var _d = __read(_c.value, 2), name_2 = _d[0], type = _d[1];
-                // eslint-disable-next-line
-                if (x.hasOwnProperty(name_2)) {
-                    var value = type.valueToString(x[name_2]);
-                    if (value === 'null') {
-                        return "variant {".concat(name_2, "}");
-                    }
-                    else {
-                        return "variant {".concat(name_2, "=").concat(value, "}");
-                    }
+    }
+    get name() {
+        const fields = this._fields.map(([key, type]) => key + ':' + type.name);
+        return `variant {${fields.join('; ')}}`;
+    }
+    display() {
+        const fields = this._fields.map(([key, type]) => key + (type.name === 'null' ? '' : `:${type.display()}`));
+        return `variant {${fields.join('; ')}}`;
+    }
+    valueToString(x) {
+        for (const [name, type] of this._fields) {
+            // eslint-disable-next-line
+            if (x.hasOwnProperty(name)) {
+                const value = type.valueToString(x[name]);
+                if (value === 'null') {
+                    return `variant {${name}}`;
+                }
+                else {
+                    return `variant {${name}=${value}}`;
                 }
             }
         }
-        catch (e_6_1) { e_6 = { error: e_6_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_6) throw e_6.error; }
-        }
         throw new Error('Variant has no data: ' + x);
-    };
-    return VariantClass;
-}(ConstructType));
+    }
+}
 exports.VariantClass = VariantClass;
 /**
  * Represents a reference to an IDL type, used for defining recursive data
  * types.
  */
-var RecClass = /** @class */ (function (_super) {
-    __extends(RecClass, _super);
-    function RecClass() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this._id = RecClass._counter++;
-        _this._type = undefined;
-        return _this;
-    }
-    RecClass.prototype.accept = function (v, d) {
+class RecClass extends ConstructType {
+    constructor() {
+        super(...arguments);
+        this._id = RecClass._counter++;
+        this._type = undefined;
+    }
+    accept(v, d) {
         if (!this._type) {
             throw Error('Recursive type uninitialized.');
         }
         return v.visitRec(this, this._type, d);
-    };
-    RecClass.prototype.fill = function (t) {
+    }
+    fill(t) {
         this._type = t;
-    };
-    RecClass.prototype.getType = function () {
+    }
+    getType() {
         return this._type;
-    };
-    RecClass.prototype.covariant = function (x) {
+    }
+    covariant(x) {
         if (this._type ? this._type.covariant(x) : false)
             return true;
-        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
-    };
-    RecClass.prototype.encodeValue = function (x) {
+        throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);
+    }
+    encodeValue(x) {
         if (!this._type) {
             throw Error('Recursive type uninitialized.');
         }
         return this._type.encodeValue(x);
-    };
-    RecClass.prototype._buildTypeTableImpl = function (typeTable) {
+    }
+    _buildTypeTableImpl(typeTable) {
         if (!this._type) {
             throw Error('Recursive type uninitialized.');
         }
         typeTable.add(this, new Uint8Array([]));
         this._type.buildTypeTable(typeTable);
         typeTable.merge(this, this._type.name);
-    };
-    RecClass.prototype.decodeValue = function (b, t) {
+    }
+    decodeValue(b, t) {
         if (!this._type) {
             throw Error('Recursive type uninitialized.');
         }
         return this._type.decodeValue(b, t);
-    };
-    Object.defineProperty(RecClass.prototype, "name", {
-        get: function () {
-            return "rec_".concat(this._id);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    RecClass.prototype.display = function () {
+    }
+    get name() {
+        return `rec_${this._id}`;
+    }
+    display() {
         if (!this._type) {
             throw Error('Recursive type uninitialized.');
         }
-        return "\u03BC".concat(this.name, ".").concat(this._type.name);
-    };
-    RecClass.prototype.valueToString = function (x) {
+        return `μ${this.name}.${this._type.name}`;
+    }
+    valueToString(x) {
         if (!this._type) {
             throw Error('Recursive type uninitialized.');
         }
         return this._type.valueToString(x);
-    };
-    RecClass._counter = 0;
-    return RecClass;
-}(ConstructType));
+    }
+}
 exports.RecClass = RecClass;
+RecClass._counter = 0;
 function decodePrincipalId(b) {
-    var x = (0, leb128_1.safeReadUint8)(b);
+    const x = (0, leb128_1.safeReadUint8)(b);
     if (x !== 1) {
         throw new Error('Cannot decode principal');
     }
-    var len = Number((0, leb128_1.lebDecode)(b));
+    const len = Number((0, leb128_1.lebDecode)(b));
     return principal_1.Principal.fromUint8Array(new Uint8Array((0, leb128_1.safeRead)(b, len)));
 }
 /**
  * Represents an IDL principal reference
  */
-var PrincipalClass = /** @class */ (function (_super) {
-    __extends(PrincipalClass, _super);
-    function PrincipalClass() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    PrincipalClass.prototype.accept = function (v, d) {
+class PrincipalClass extends PrimitiveType {
+    accept(v, d) {
         return v.visitPrincipal(this, d);
-    };
-    PrincipalClass.prototype.covariant = function (x) {
+    }
+    covariant(x) {
         if (x && x._isPrincipal)
             return true;
-        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
-    };
-    PrincipalClass.prototype.encodeValue = function (x) {
-        var buf = x.toUint8Array();
-        var len = (0, leb128_1.lebEncode)(buf.byteLength);
+        throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);
+    }
+    encodeValue(x) {
+        const buf = x.toUint8Array();
+        const len = (0, leb128_1.lebEncode)(buf.byteLength);
         return (0, buffer_1.concat)(new Uint8Array([1]), len, buf);
-    };
-    PrincipalClass.prototype.encodeType = function () {
+    }
+    encodeType() {
         return (0, leb128_1.slebEncode)(-24 /* IDLTypeIds.Principal */);
-    };
-    PrincipalClass.prototype.decodeValue = function (b, t) {
+    }
+    decodeValue(b, t) {
         this.checkType(t);
         return decodePrincipalId(b);
-    };
-    Object.defineProperty(PrincipalClass.prototype, "name", {
-        get: function () {
-            return 'principal';
-        },
-        enumerable: false,
-        configurable: true
-    });
-    PrincipalClass.prototype.valueToString = function (x) {
-        return "".concat(this.name, " \"").concat(x.toText(), "\"");
-    };
-    return PrincipalClass;
-}(PrimitiveType));
+    }
+    get name() {
+        return 'principal';
+    }
+    valueToString(x) {
+        return `${this.name} "${x.toText()}"`;
+    }
+}
 exports.PrincipalClass = PrincipalClass;
 /**
  * Represents an IDL function reference.
@@ -1550,85 +1232,75 @@ exports.PrincipalClass = PrincipalClass;
  * @param retTypes Return types.
  * @param annotations Function annotations.
  */
-var FuncClass = /** @class */ (function (_super) {
-    __extends(FuncClass, _super);
-    function FuncClass(argTypes, retTypes, annotations) {
-        if (annotations === void 0) { annotations = []; }
-        var _this = _super.call(this) || this;
-        _this.argTypes = argTypes;
-        _this.retTypes = retTypes;
-        _this.annotations = annotations;
-        return _this;
-    }
-    FuncClass.argsToString = function (types, v) {
+class FuncClass extends ConstructType {
+    constructor(argTypes, retTypes, annotations = []) {
+        super();
+        this.argTypes = argTypes;
+        this.retTypes = retTypes;
+        this.annotations = annotations;
+    }
+    static argsToString(types, v) {
         if (types.length !== v.length) {
             throw new Error('arity mismatch');
         }
-        return '(' + types.map(function (t, i) { return t.valueToString(v[i]); }).join(', ') + ')';
-    };
-    FuncClass.prototype.accept = function (v, d) {
+        return '(' + types.map((t, i) => t.valueToString(v[i])).join(', ') + ')';
+    }
+    accept(v, d) {
         return v.visitFunc(this, d);
-    };
-    FuncClass.prototype.covariant = function (x) {
+    }
+    covariant(x) {
         if (Array.isArray(x) && x.length === 2 && x[0] && x[0]._isPrincipal && typeof x[1] === 'string')
             return true;
-        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
-    };
-    FuncClass.prototype.encodeValue = function (_a) {
-        var _b = __read(_a, 2), principal = _b[0], methodName = _b[1];
-        var buf = principal.toUint8Array();
-        var len = (0, leb128_1.lebEncode)(buf.byteLength);
-        var canister = (0, buffer_1.concat)(new Uint8Array([1]), len, buf);
-        var method = new TextEncoder().encode(methodName);
-        var methodLen = (0, leb128_1.lebEncode)(method.byteLength);
+        throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);
+    }
+    encodeValue([principal, methodName]) {
+        const buf = principal.toUint8Array();
+        const len = (0, leb128_1.lebEncode)(buf.byteLength);
+        const canister = (0, buffer_1.concat)(new Uint8Array([1]), len, buf);
+        const method = new TextEncoder().encode(methodName);
+        const methodLen = (0, leb128_1.lebEncode)(method.byteLength);
         return (0, buffer_1.concat)(new Uint8Array([1]), canister, methodLen, method);
-    };
-    FuncClass.prototype._buildTypeTableImpl = function (T) {
-        var _this = this;
-        this.argTypes.forEach(function (arg) { return arg.buildTypeTable(T); });
-        this.retTypes.forEach(function (arg) { return arg.buildTypeTable(T); });
-        var opCode = (0, leb128_1.slebEncode)(-22 /* IDLTypeIds.Func */);
-        var argLen = (0, leb128_1.lebEncode)(this.argTypes.length);
-        var args = buffer_1.concat.apply(void 0, __spreadArray([], __read(this.argTypes.map(function (arg) { return arg.encodeType(T); })), false));
-        var retLen = (0, leb128_1.lebEncode)(this.retTypes.length);
-        var rets = buffer_1.concat.apply(void 0, __spreadArray([], __read(this.retTypes.map(function (arg) { return arg.encodeType(T); })), false));
-        var annLen = (0, leb128_1.lebEncode)(this.annotations.length);
-        var anns = buffer_1.concat.apply(void 0, __spreadArray([], __read(this.annotations.map(function (a) { return _this.encodeAnnotation(a); })), false));
+    }
+    _buildTypeTableImpl(T) {
+        this.argTypes.forEach((arg) => arg.buildTypeTable(T));
+        this.retTypes.forEach((arg) => arg.buildTypeTable(T));
+        const opCode = (0, leb128_1.slebEncode)(-22 /* IDLTypeIds.Func */);
+        const argLen = (0, leb128_1.lebEncode)(this.argTypes.length);
+        const args = (0, buffer_1.concat)(...this.argTypes.map((arg) => arg.encodeType(T)));
+        const retLen = (0, leb128_1.lebEncode)(this.retTypes.length);
+        const rets = (0, buffer_1.concat)(...this.retTypes.map((arg) => arg.encodeType(T)));
+        const annLen = (0, leb128_1.lebEncode)(this.annotations.length);
+        const anns = (0, buffer_1.concat)(...this.annotations.map((a) => this.encodeAnnotation(a)));
         T.add(this, (0, buffer_1.concat)(opCode, argLen, args, retLen, rets, annLen, anns));
-    };
-    FuncClass.prototype.decodeValue = function (b) {
-        var x = (0, leb128_1.safeReadUint8)(b);
+    }
+    decodeValue(b) {
+        const x = (0, leb128_1.safeReadUint8)(b);
         if (x !== 1) {
             throw new Error('Cannot decode function reference');
         }
-        var canister = decodePrincipalId(b);
-        var mLen = Number((0, leb128_1.lebDecode)(b));
-        var buf = (0, leb128_1.safeRead)(b, mLen);
-        var decoder = new TextDecoder('utf8', { fatal: true });
-        var method = decoder.decode(buf);
+        const canister = decodePrincipalId(b);
+        const mLen = Number((0, leb128_1.lebDecode)(b));
+        const buf = (0, leb128_1.safeRead)(b, mLen);
+        const decoder = new TextDecoder('utf8', { fatal: true });
+        const method = decoder.decode(buf);
         return [canister, method];
-    };
-    Object.defineProperty(FuncClass.prototype, "name", {
-        get: function () {
-            var args = this.argTypes.map(function (arg) { return arg.name; }).join(', ');
-            var rets = this.retTypes.map(function (arg) { return arg.name; }).join(', ');
-            var annon = ' ' + this.annotations.join(' ');
-            return "(".concat(args, ") -> (").concat(rets, ")").concat(annon);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    FuncClass.prototype.valueToString = function (_a) {
-        var _b = __read(_a, 2), principal = _b[0], str = _b[1];
-        return "func \"".concat(principal.toText(), "\".").concat(str);
-    };
-    FuncClass.prototype.display = function () {
-        var args = this.argTypes.map(function (arg) { return arg.display(); }).join(', ');
-        var rets = this.retTypes.map(function (arg) { return arg.display(); }).join(', ');
-        var annon = ' ' + this.annotations.join(' ');
-        return "(".concat(args, ") \u2192 (").concat(rets, ")").concat(annon);
-    };
-    FuncClass.prototype.encodeAnnotation = function (ann) {
+    }
+    get name() {
+        const args = this.argTypes.map((arg) => arg.name).join(', ');
+        const rets = this.retTypes.map((arg) => arg.name).join(', ');
+        const annon = ' ' + this.annotations.join(' ');
+        return `(${args}) -> (${rets})${annon}`;
+    }
+    valueToString([principal, str]) {
+        return `func "${principal.toText()}".${str}`;
+    }
+    display() {
+        const args = this.argTypes.map((arg) => arg.display()).join(', ');
+        const rets = this.retTypes.map((arg) => arg.display()).join(', ');
+        const annon = ' ' + this.annotations.join(' ');
+        return `(${args}) → (${rets})${annon}`;
+    }
+    encodeAnnotation(ann) {
         if (ann === 'query') {
             return new Uint8Array([1]);
         }
@@ -1638,64 +1310,49 @@ var FuncClass = /** @class */ (function (_super) {
         else {
             throw new Error('Illegal function annotation');
         }
-    };
-    return FuncClass;
-}(ConstructType));
+    }
+}
 exports.FuncClass = FuncClass;
-var ServiceClass = /** @class */ (function (_super) {
-    __extends(ServiceClass, _super);
-    function ServiceClass(fields) {
-        var _this = _super.call(this) || this;
-        _this._fields = Object.entries(fields).sort(function (a, b) { return idlLabelToId(a[0]) - idlLabelToId(b[0]); });
-        return _this;
-    }
-    ServiceClass.prototype.accept = function (v, d) {
+class ServiceClass extends ConstructType {
+    constructor(fields) {
+        super();
+        this._fields = Object.entries(fields).sort((a, b) => idlLabelToId(a[0]) - idlLabelToId(b[0]));
+    }
+    accept(v, d) {
         return v.visitService(this, d);
-    };
-    ServiceClass.prototype.covariant = function (x) {
+    }
+    covariant(x) {
         if (x && x._isPrincipal)
             return true;
-        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
-    };
-    ServiceClass.prototype.encodeValue = function (x) {
-        var buf = x.toUint8Array();
-        var len = (0, leb128_1.lebEncode)(buf.length);
+        throw new Error(`Invalid ${this.display()} argument: ${toReadableString(x)}`);
+    }
+    encodeValue(x) {
+        const buf = x.toUint8Array();
+        const len = (0, leb128_1.lebEncode)(buf.length);
         return (0, buffer_1.concat)(new Uint8Array([1]), len, buf);
-    };
-    ServiceClass.prototype._buildTypeTableImpl = function (T) {
-        this._fields.forEach(function (_a) {
-            var _b = __read(_a, 2), _ = _b[0], func = _b[1];
-            return func.buildTypeTable(T);
-        });
-        var opCode = (0, leb128_1.slebEncode)(-23 /* IDLTypeIds.Service */);
-        var len = (0, leb128_1.lebEncode)(this._fields.length);
-        var meths = this._fields.map(function (_a) {
-            var _b = __read(_a, 2), label = _b[0], func = _b[1];
-            var labelBuf = new TextEncoder().encode(label);
-            var labelLen = (0, leb128_1.lebEncode)(labelBuf.length);
+    }
+    _buildTypeTableImpl(T) {
+        this._fields.forEach(([_, func]) => func.buildTypeTable(T));
+        const opCode = (0, leb128_1.slebEncode)(-23 /* IDLTypeIds.Service */);
+        const len = (0, leb128_1.lebEncode)(this._fields.length);
+        const meths = this._fields.map(([label, func]) => {
+            const labelBuf = new TextEncoder().encode(label);
+            const labelLen = (0, leb128_1.lebEncode)(labelBuf.length);
             return (0, buffer_1.concat)(labelLen, labelBuf, func.encodeType(T));
         });
-        T.add(this, buffer_1.concat.apply(void 0, __spreadArray([opCode, len], __read(meths), false)));
-    };
-    ServiceClass.prototype.decodeValue = function (b) {
+        T.add(this, (0, buffer_1.concat)(opCode, len, ...meths));
+    }
+    decodeValue(b) {
         return decodePrincipalId(b);
-    };
-    Object.defineProperty(ServiceClass.prototype, "name", {
-        get: function () {
-            var fields = this._fields.map(function (_a) {
-                var _b = __read(_a, 2), key = _b[0], value = _b[1];
-                return key + ':' + value.name;
-            });
-            return "service {".concat(fields.join('; '), "}");
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ServiceClass.prototype.valueToString = function (x) {
-        return "service \"".concat(x.toText(), "\"");
-    };
-    return ServiceClass;
-}(ConstructType));
+    }
+    get name() {
+        const fields = this._fields.map(([key, value]) => key + ':' + value.name);
+        return `service {${fields.join('; ')}}`;
+    }
+    valueToString(x) {
+        return `service "${x.toText()}"`;
+    }
+}
 exports.ServiceClass = ServiceClass;
 /**
  *
@@ -1703,7 +1360,7 @@ exports.ServiceClass = ServiceClass;
  * @returns {string}
  */
 function toReadableString(x) {
-    var str = JSON.stringify(x, function (_key, value) { return (typeof value === 'bigint' ? "BigInt(".concat(value, ")") : value); });
+    const str = JSON.stringify(x, (_key, value) => (typeof value === 'bigint' ? `BigInt(${value})` : value));
     return str && str.length > toReadableString_max ? str.substring(0, toReadableString_max - 3) + '...' : str;
 }
 /**
@@ -1716,22 +1373,22 @@ function encode(argTypes, args) {
     if (args.length < argTypes.length) {
         throw Error('Wrong number of message arguments');
     }
-    var typeTable = new TypeTable();
-    argTypes.forEach(function (t) { return t.buildTypeTable(typeTable); });
-    var magic = new TextEncoder().encode(magicNumber);
-    var table = typeTable.encode();
-    var len = (0, leb128_1.lebEncode)(args.length);
-    var typs = buffer_1.concat.apply(void 0, __spreadArray([], __read(argTypes.map(function (t) { return t.encodeType(typeTable); })), false));
-    var vals = buffer_1.concat.apply(void 0, __spreadArray([], __read(zipWith(argTypes, args, function (t, x) {
+    const typeTable = new TypeTable();
+    argTypes.forEach((t) => t.buildTypeTable(typeTable));
+    const magic = new TextEncoder().encode(magicNumber);
+    const table = typeTable.encode();
+    const len = (0, leb128_1.lebEncode)(args.length);
+    const typs = (0, buffer_1.concat)(...argTypes.map((t) => t.encodeType(typeTable)));
+    const vals = (0, buffer_1.concat)(...zipWith(argTypes, args, (t, x) => {
         try {
             t.covariant(x);
         }
         catch (e) {
-            var err = new Error(e.message + '\n\n');
+            const err = new Error(e.message + '\n\n');
             throw err;
         }
         return t.encodeValue(x);
-    })), false));
+    }));
     return (0, buffer_1.concat)(magic, table, len, typs, vals);
 }
 exports.encode = encode;
@@ -1742,34 +1399,34 @@ exports.encode = encode;
  * @returns Value deserialised to JS type
  */
 function decode(retTypes, bytes) {
-    var b = new buffer_2.PipeArrayBuffer(bytes);
+    const b = new buffer_2.PipeArrayBuffer(bytes);
     if (bytes.byteLength < magicNumber.length) {
         throw new Error('Message length smaller than magic number');
     }
-    var magicBuffer = (0, leb128_1.safeRead)(b, magicNumber.length);
-    var magic = new TextDecoder().decode(magicBuffer);
+    const magicBuffer = (0, leb128_1.safeRead)(b, magicNumber.length);
+    const magic = new TextDecoder().decode(magicBuffer);
     if (magic !== magicNumber) {
         throw new Error('Wrong magic number: ' + JSON.stringify(magic));
     }
     function readTypeTable(pipe) {
-        var typeTable = [];
-        var len = Number((0, leb128_1.lebDecode)(pipe));
-        for (var i = 0; i < len; i++) {
-            var ty = Number((0, leb128_1.slebDecode)(pipe));
+        const typeTable = [];
+        const len = Number((0, leb128_1.lebDecode)(pipe));
+        for (let i = 0; i < len; i++) {
+            const ty = Number((0, leb128_1.slebDecode)(pipe));
             switch (ty) {
                 case -18 /* IDLTypeIds.Opt */:
                 case -19 /* IDLTypeIds.Vector */: {
-                    var t = Number((0, leb128_1.slebDecode)(pipe));
+                    const t = Number((0, leb128_1.slebDecode)(pipe));
                     typeTable.push([ty, t]);
                     break;
                 }
                 case -20 /* IDLTypeIds.Record */:
                 case -21 /* IDLTypeIds.Variant */: {
-                    var fields = [];
-                    var objectLength = Number((0, leb128_1.lebDecode)(pipe));
-                    var prevHash = void 0;
+                    const fields = [];
+                    let objectLength = Number((0, leb128_1.lebDecode)(pipe));
+                    let prevHash;
                     while (objectLength--) {
-                        var hash = Number((0, leb128_1.lebDecode)(pipe));
+                        const hash = Number((0, leb128_1.lebDecode)(pipe));
                         if (hash >= Math.pow(2, 32)) {
                             throw new Error('field id out of 32-bit range');
                         }
@@ -1777,27 +1434,27 @@ function decode(retTypes, bytes) {
                             throw new Error('field id collision or not sorted');
                         }
                         prevHash = hash;
-                        var t = Number((0, leb128_1.slebDecode)(pipe));
+                        const t = Number((0, leb128_1.slebDecode)(pipe));
                         fields.push([hash, t]);
                     }
                     typeTable.push([ty, fields]);
                     break;
                 }
                 case -22 /* IDLTypeIds.Func */: {
-                    var args = [];
-                    var argLength = Number((0, leb128_1.lebDecode)(pipe));
+                    const args = [];
+                    let argLength = Number((0, leb128_1.lebDecode)(pipe));
                     while (argLength--) {
                         args.push(Number((0, leb128_1.slebDecode)(pipe)));
                     }
-                    var returnValues = [];
-                    var returnValuesLength = Number((0, leb128_1.lebDecode)(pipe));
+                    const returnValues = [];
+                    let returnValuesLength = Number((0, leb128_1.lebDecode)(pipe));
                     while (returnValuesLength--) {
                         returnValues.push(Number((0, leb128_1.slebDecode)(pipe)));
                     }
-                    var annotations = [];
-                    var annotationLength = Number((0, leb128_1.lebDecode)(pipe));
+                    const annotations = [];
+                    let annotationLength = Number((0, leb128_1.lebDecode)(pipe));
                     while (annotationLength--) {
-                        var annotation = Number((0, leb128_1.lebDecode)(pipe));
+                        const annotation = Number((0, leb128_1.lebDecode)(pipe));
                         switch (annotation) {
                             case 1: {
                                 annotations.push('query');
@@ -1815,12 +1472,12 @@ function decode(retTypes, bytes) {
                     break;
                 }
                 case -23 /* IDLTypeIds.Service */: {
-                    var servLength = Number((0, leb128_1.lebDecode)(pipe));
-                    var methods = [];
+                    let servLength = Number((0, leb128_1.lebDecode)(pipe));
+                    const methods = [];
                     while (servLength--) {
-                        var nameLength = Number((0, leb128_1.lebDecode)(pipe));
-                        var funcName = new TextDecoder().decode((0, leb128_1.safeRead)(pipe, nameLength));
-                        var funcType = (0, leb128_1.slebDecode)(pipe);
+                        const nameLength = Number((0, leb128_1.lebDecode)(pipe));
+                        const funcName = new TextDecoder().decode((0, leb128_1.safeRead)(pipe, nameLength));
+                        const funcType = (0, leb128_1.slebDecode)(pipe);
                         methods.push([funcName, funcType]);
                     }
                     typeTable.push([ty, methods]);
@@ -1830,18 +1487,18 @@ function decode(retTypes, bytes) {
                     throw new Error('Illegal op_code: ' + ty);
             }
         }
-        var rawList = [];
-        var length = Number((0, leb128_1.lebDecode)(pipe));
-        for (var i = 0; i < length; i++) {
+        const rawList = [];
+        const length = Number((0, leb128_1.lebDecode)(pipe));
+        for (let i = 0; i < length; i++) {
             rawList.push(Number((0, leb128_1.slebDecode)(pipe)));
         }
         return [typeTable, rawList];
     }
-    var _a = __read(readTypeTable(b), 2), rawTable = _a[0], rawTypes = _a[1];
+    const [rawTable, rawTypes] = readTypeTable(b);
     if (rawTypes.length < retTypes.length) {
         throw new Error('Wrong number of return values');
     }
-    var table = rawTable.map(function (_) { return Rec(); });
+    const table = rawTable.map((_) => Rec());
     function getType(t) {
         if (t < -24) {
             throw new Error('future value not supported');
@@ -1894,86 +1551,55 @@ function decode(retTypes, bytes) {
         return table[t];
     }
     function buildType(entry) {
-        var e_7, _a, e_8, _b, e_9, _c;
         switch (entry[0]) {
             case -19 /* IDLTypeIds.Vector */: {
-                var ty = getType(entry[1]);
+                const ty = getType(entry[1]);
                 return Vec(ty);
             }
             case -18 /* IDLTypeIds.Opt */: {
-                var ty = getType(entry[1]);
+                const ty = getType(entry[1]);
                 return Opt(ty);
             }
             case -20 /* IDLTypeIds.Record */: {
-                var fields = {};
-                try {
-                    for (var _d = __values(entry[1]), _e = _d.next(); !_e.done; _e = _d.next()) {
-                        var _f = __read(_e.value, 2), hash = _f[0], ty = _f[1];
-                        var name_3 = "_".concat(hash, "_");
-                        fields[name_3] = getType(ty);
-                    }
+                const fields = {};
+                for (const [hash, ty] of entry[1]) {
+                    const name = `_${hash}_`;
+                    fields[name] = getType(ty);
                 }
-                catch (e_7_1) { e_7 = { error: e_7_1 }; }
-                finally {
-                    try {
-                        if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
-                    }
-                    finally { if (e_7) throw e_7.error; }
-                }
-                var record = Record(fields);
-                var tuple = record.tryAsTuple();
+                const record = Record(fields);
+                const tuple = record.tryAsTuple();
                 if (Array.isArray(tuple)) {
-                    return Tuple.apply(void 0, __spreadArray([], __read(tuple), false));
+                    return Tuple(...tuple);
                 }
                 else {
                     return record;
                 }
             }
             case -21 /* IDLTypeIds.Variant */: {
-                var fields = {};
-                try {
-                    for (var _g = __values(entry[1]), _h = _g.next(); !_h.done; _h = _g.next()) {
-                        var _j = __read(_h.value, 2), hash = _j[0], ty = _j[1];
-                        var name_4 = "_".concat(hash, "_");
-                        fields[name_4] = getType(ty);
-                    }
-                }
-                catch (e_8_1) { e_8 = { error: e_8_1 }; }
-                finally {
-                    try {
-                        if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
-                    }
-                    finally { if (e_8) throw e_8.error; }
+                const fields = {};
+                for (const [hash, ty] of entry[1]) {
+                    const name = `_${hash}_`;
+                    fields[name] = getType(ty);
                 }
                 return Variant(fields);
             }
             case -22 /* IDLTypeIds.Func */: {
-                var _k = __read(entry[1], 3), args = _k[0], returnValues = _k[1], annotations = _k[2];
-                return Func(args.map(function (t) { return getType(t); }), returnValues.map(function (t) { return getType(t); }), annotations);
+                const [args, returnValues, annotations] = entry[1];
+                return Func(args.map((t) => getType(t)), returnValues.map((t) => getType(t)), annotations);
             }
             case -23 /* IDLTypeIds.Service */: {
-                var rec = {};
-                var methods = entry[1];
-                try {
-                    for (var methods_1 = __values(methods), methods_1_1 = methods_1.next(); !methods_1_1.done; methods_1_1 = methods_1.next()) {
-                        var _l = __read(methods_1_1.value, 2), name_5 = _l[0], typeRef = _l[1];
-                        var type = getType(typeRef);
-                        if (type instanceof RecClass) {
-                            // unpack reference type
-                            type = type.getType();
-                        }
-                        if (!(type instanceof FuncClass)) {
-                            throw new Error('Illegal service definition: services can only contain functions');
-                        }
-                        rec[name_5] = type;
+                const rec = {};
+                const methods = entry[1];
+                for (const [name, typeRef] of methods) {
+                    let type = getType(typeRef);
+                    if (type instanceof RecClass) {
+                        // unpack reference type
+                        type = type.getType();
                     }
-                }
-                catch (e_9_1) { e_9 = { error: e_9_1 }; }
-                finally {
-                    try {
-                        if (methods_1_1 && !methods_1_1.done && (_c = methods_1.return)) _c.call(methods_1);
+                    if (!(type instanceof FuncClass)) {
+                        throw new Error('Illegal service definition: services can only contain functions');
                     }
-                    finally { if (e_9) throw e_9.error; }
+                    rec[name] = type;
                 }
                 return Service(rec);
             }
@@ -1981,16 +1607,16 @@ function decode(retTypes, bytes) {
                 throw new Error('Illegal op_code: ' + entry[0]);
         }
     }
-    rawTable.forEach(function (entry, i) {
-        var t = buildType(entry);
+    rawTable.forEach((entry, i) => {
+        const t = buildType(entry);
         table[i].fill(t);
     });
-    var types = rawTypes.map(function (t) { return getType(t); });
-    var output = retTypes.map(function (t, i) {
+    const types = rawTypes.map((t) => getType(t));
+    const output = retTypes.map((t, i) => {
         return t.decodeValue(b, types[i]);
     });
     // skip unused values
-    for (var ind = retTypes.length; ind < types.length; ind++) {
+    for (let ind = retTypes.length; ind < types.length; ind++) {
         types[ind].decodeValue(b, types[ind]);
     }
     if (b.byteLength > 0) {
@@ -2027,11 +1653,7 @@ exports.Principal = new PrincipalClass();
  * @param types array of any types
  * @returns TupleClass from those types
  */
-function Tuple() {
-    var types = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        types[_i] = arguments[_i];
-    }
+function Tuple(...types) {
     return new TupleClass(types);
 }
 exports.Tuple = Tuple;
@@ -2086,8 +1708,7 @@ exports.Rec = Rec;
  * @param annotations array of strings, [] by default
  * @returns new FuncClass
  */
-function Func(args, ret, annotations) {
-    if (annotations === void 0) { annotations = []; }
+function Func(args, ret, annotations = []) {
     return new FuncClass(args, ret, annotations);
 }
 exports.Func = Func;