@airgap/icp 0.13.11-beta.1 → 0.13.11-beta.10

package/v1/utils/idl.js

@@ -0,0 +1,2103 @@
+"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");
+/**
+ * Equivalent to `Math.log2(n)` with support for `BigInt` values
+ *
+ * @param n bigint or integer
+ * @returns integer
+ */
+function ilog2(n) {
+    var nBig = BigInt(n);
+    if (n <= 0) {
+        throw new RangeError('Input must be positive');
+    }
+    return nBig.toString(2).length - 1;
+}
+exports.ilog2 = ilog2;
+/**
+ * Equivalent to `2 ** n` with support for `BigInt` values
+ * (necessary for browser preprocessors which replace the `**` operator with `Math.pow`)
+ *
+ * @param n bigint or integer
+ * @returns bigint
+ */
+function iexp2(n) {
+    var nBig = BigInt(n);
+    if (n < 0) {
+        throw new RangeError('Input must be non-negative');
+    }
+    return BigInt(1) << nBig;
+}
+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; }
+    }
+    return h;
+}
+/**
+ *
+ * @param label string
+ * @returns number representing hashed label
+ */
+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)) {
+            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
+function zipWith(xs, ys, f) {
+    return xs.map(function (x, i) { return f(x, ys[i]); });
+}
+/**
+ * An IDL Type Table, which precedes the data in the stream.
+ */
+var TypeTable = /** @class */ (function () {
+    function TypeTable() {
+        // 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) {
+        return this._idx.has(obj.name);
+    };
+    TypeTable.prototype.add = function (type, buf) {
+        var 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);
+        if (idx === undefined) {
+            throw new Error('Missing type index for ' + obj);
+        }
+        if (knotIdx === undefined) {
+            throw new Error('Missing type index for ' + knot);
+        }
+        this._typs[idx] = this._typs[knotIdx];
+        // 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));
+        return (0, buffer_1.concat)(len, buf);
+    };
+    TypeTable.prototype.indexOf = function (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) {
+        throw new Error('Not implemented');
+    };
+    Visitor.prototype.visitPrimitive = function (t, data) {
+        return this.visitType(t, data);
+    };
+    Visitor.prototype.visitEmpty = function (t, data) {
+        return this.visitPrimitive(t, data);
+    };
+    Visitor.prototype.visitBool = function (t, data) {
+        return this.visitPrimitive(t, data);
+    };
+    Visitor.prototype.visitNull = function (t, data) {
+        return this.visitPrimitive(t, data);
+    };
+    Visitor.prototype.visitReserved = function (t, data) {
+        return this.visitPrimitive(t, data);
+    };
+    Visitor.prototype.visitText = function (t, data) {
+        return this.visitPrimitive(t, data);
+    };
+    Visitor.prototype.visitNumber = function (t, data) {
+        return this.visitPrimitive(t, data);
+    };
+    Visitor.prototype.visitInt = function (t, data) {
+        return this.visitNumber(t, data);
+    };
+    Visitor.prototype.visitNat = function (t, data) {
+        return this.visitNumber(t, data);
+    };
+    Visitor.prototype.visitFloat = function (t, data) {
+        return this.visitPrimitive(t, data);
+    };
+    Visitor.prototype.visitFixedInt = function (t, data) {
+        return this.visitNumber(t, data);
+    };
+    Visitor.prototype.visitFixedNat = function (t, data) {
+        return this.visitNumber(t, data);
+    };
+    Visitor.prototype.visitPrincipal = function (t, data) {
+        return this.visitPrimitive(t, data);
+    };
+    Visitor.prototype.visitConstruct = function (t, data) {
+        return this.visitType(t, data);
+    };
+    Visitor.prototype.visitVec = function (t, ty, data) {
+        return this.visitConstruct(t, data);
+    };
+    Visitor.prototype.visitOpt = function (t, ty, data) {
+        return this.visitConstruct(t, data);
+    };
+    Visitor.prototype.visitRecord = function (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]; });
+        return this.visitRecord(t, fields, data);
+    };
+    Visitor.prototype.visitVariant = function (t, fields, data) {
+        return this.visitConstruct(t, data);
+    };
+    Visitor.prototype.visitRec = function (t, ty, data) {
+        return this.visitConstruct(ty, data);
+    };
+    Visitor.prototype.visitFunc = function (t, data) {
+        return this.visitConstruct(t, data);
+    };
+    Visitor.prototype.visitService = function (t, data) {
+        return this.visitConstruct(t, data);
+    };
+    return Visitor;
+}());
+exports.Visitor = Visitor;
+/**
+ * Represents an IDL type.
+ */
+var Type = /** @class */ (function () {
+    function Type() {
+    }
+    /* Display type name */
+    Type.prototype.display = function () {
+        return this.name;
+    };
+    Type.prototype.valueToString = function (x) {
+        return toReadableString(x);
+    };
+    /* Implement `T` in the IDL spec, only needed for non-primitive types */
+    Type.prototype.buildTypeTable = function (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) {
+        if (this.name !== t.name) {
+            throw new Error("type mismatch: type on the wire ".concat(t.name, ", expect type ").concat(this.name));
+        }
+        return t;
+    };
+    PrimitiveType.prototype._buildTypeTableImpl = function (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) {
+        if (t instanceof RecClass) {
+            var 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) {
+        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) {
+        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 () {
+        throw new Error('Empty cannot appear as a function argument');
+    };
+    EmptyClass.prototype.valueToString = function () {
+        throw new Error('Empty cannot appear as a value');
+    };
+    EmptyClass.prototype.encodeType = function () {
+        return (0, leb128_1.slebEncode)(-17 /* IDLTypeIds.Empty */);
+    };
+    EmptyClass.prototype.decodeValue = function () {
+        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));
+exports.EmptyClass = EmptyClass;
+/**
+ * Represents an IDL Unknown, a placeholder type for deserialization only.
+ * When decoding a value as Unknown, all fields will be retained but the names are only available in
+ * hashed form.
+ * 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) {
+        throw new Error('Method not implemented for unknown.');
+    };
+    UnknownClass.prototype.accept = function (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 () {
+        throw new Error('Unknown cannot appear as a function argument');
+    };
+    UnknownClass.prototype.valueToString = function () {
+        throw new Error('Unknown cannot appear as a value');
+    };
+    UnknownClass.prototype.encodeType = function () {
+        throw new Error('Unknown cannot be serialized');
+    };
+    UnknownClass.prototype.decodeValue = function (b, t) {
+        var 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;
+        if (t instanceof RecClass) {
+            typeFunc = function () { return t.getType(); };
+        }
+        else {
+            typeFunc = function () { return 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.
+        // This in turn leads to problems if the decoded value is a variant because these values are
+        // only allowed to have a single property.
+        Object.defineProperty(decodedValue, 'type', {
+            value: typeFunc,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        });
+        return decodedValue;
+    };
+    UnknownClass.prototype._buildTypeTableImpl = function () {
+        throw new Error('Unknown cannot be serialized');
+    };
+    Object.defineProperty(UnknownClass.prototype, "name", {
+        get: function () {
+            return 'Unknown';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return UnknownClass;
+}(Type));
+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) {
+        return v.visitBool(this, d);
+    };
+    BoolClass.prototype.covariant = function (x) {
+        if (typeof x === 'boolean')
+            return true;
+        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
+    };
+    BoolClass.prototype.encodeValue = function (x) {
+        return new Uint8Array([x ? 1 : 0]);
+    };
+    BoolClass.prototype.encodeType = function () {
+        return (0, leb128_1.slebEncode)(-2 /* IDLTypeIds.Bool */);
+    };
+    BoolClass.prototype.decodeValue = function (b, t) {
+        this.checkType(t);
+        switch ((0, leb128_1.safeReadUint8)(b)) {
+            case 0:
+                return false;
+            case 1:
+                return true;
+            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));
+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) {
+        return v.visitNull(this, d);
+    };
+    NullClass.prototype.covariant = function (x) {
+        if (x === null)
+            return true;
+        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
+    };
+    NullClass.prototype.encodeValue = function () {
+        return new ArrayBuffer(0);
+    };
+    NullClass.prototype.encodeType = function () {
+        return (0, leb128_1.slebEncode)(-1 /* IDLTypeIds.Null */);
+    };
+    NullClass.prototype.decodeValue = function (b, t) {
+        this.checkType(t);
+        return null;
+    };
+    Object.defineProperty(NullClass.prototype, "name", {
+        get: function () {
+            return 'null';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return NullClass;
+}(PrimitiveType));
+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) {
+        return v.visitReserved(this, d);
+    };
+    ReservedClass.prototype.covariant = function (x) {
+        return true;
+    };
+    ReservedClass.prototype.encodeValue = function () {
+        return new ArrayBuffer(0);
+    };
+    ReservedClass.prototype.encodeType = function () {
+        return (0, leb128_1.slebEncode)(-16 /* IDLTypeIds.Reserved */);
+    };
+    ReservedClass.prototype.decodeValue = function (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));
+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) {
+        return v.visitText(this, d);
+    };
+    TextClass.prototype.covariant = function (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);
+        return (0, buffer_1.concat)(len, buf);
+    };
+    TextClass.prototype.encodeType = function () {
+        return (0, leb128_1.slebEncode)(-15 /* IDLTypeIds.Text */);
+    };
+    TextClass.prototype.decodeValue = function (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 });
+        return decoder.decode(buf);
+    };
+    Object.defineProperty(TextClass.prototype, "name", {
+        get: function () {
+            return 'text';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TextClass.prototype.valueToString = function (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) {
+        return v.visitInt(this, d);
+    };
+    IntClass.prototype.covariant = function (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) {
+        return (0, leb128_1.slebEncode)(x);
+    };
+    IntClass.prototype.encodeType = function () {
+        return (0, leb128_1.slebEncode)(-4 /* IDLTypeIds.Int */);
+    };
+    IntClass.prototype.decodeValue = function (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) {
+        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) {
+        return v.visitNat(this, d);
+    };
+    NatClass.prototype.covariant = function (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) {
+        return (0, leb128_1.lebEncode)(x);
+    };
+    NatClass.prototype.encodeType = function () {
+        return (0, leb128_1.slebEncode)(-3 /* IDLTypeIds.Nat */);
+    };
+    NatClass.prototype.decodeValue = function (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) {
+        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;
+        if (_bits !== 32 && _bits !== 64) {
+            throw new Error('not a valid float type');
+        }
+        return _this;
+    }
+    FloatClass.prototype.accept = function (v, d) {
+        return v.visitFloat(this, d);
+    };
+    FloatClass.prototype.covariant = function (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);
+        if (this._bits === 32) {
+            view.setFloat32(0, x, true);
+        }
+        else {
+            view.setFloat64(0, x, true);
+        }
+        return buf;
+    };
+    FloatClass.prototype.encodeType = function () {
+        var opcode = this._bits === 32 ? -13 /* IDLTypeIds.Float32 */ : -14 /* IDLTypeIds.Float64 */;
+        return (0, leb128_1.slebEncode)(opcode);
+    };
+    FloatClass.prototype.decodeValue = function (b, t) {
+        this.checkType(t);
+        var bytes = (0, leb128_1.safeRead)(b, this._bits / 8);
+        var 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) {
+        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) {
+        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;
+        if (typeof x === 'bigint') {
+            ok = x >= min && x <= max;
+        }
+        else if (Number.isInteger(x)) {
+            var v = BigInt(x);
+            ok = v >= min && v <= max;
+        }
+        else {
+            ok = false;
+        }
+        if (ok)
+            return true;
+        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
+    };
+    FixedIntClass.prototype.encodeValue = function (x) {
+        return (0, leb128_1.writeIntLE)(x, this._bits / 8);
+    };
+    FixedIntClass.prototype.encodeType = function () {
+        var offset = Math.log2(this._bits) - 3;
+        return (0, leb128_1.slebEncode)(-9 - offset);
+    };
+    FixedIntClass.prototype.decodeValue = function (b, t) {
+        this.checkType(t);
+        var 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) {
+        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) {
+        return v.visitFixedNat(this, d);
+    };
+    FixedNatClass.prototype.covariant = function (x) {
+        var max = iexp2(this._bits);
+        var ok = false;
+        if (typeof x === 'bigint' && x >= BigInt(0)) {
+            ok = x < max;
+        }
+        else if (Number.isInteger(x) && x >= 0) {
+            var v = BigInt(x);
+            ok = v < max;
+        }
+        else {
+            ok = false;
+        }
+        if (ok)
+            return true;
+        throw new Error("Invalid ".concat(this.display(), " argument: ").concat(toReadableString(x)));
+    };
+    FixedNatClass.prototype.encodeValue = function (x) {
+        return (0, leb128_1.writeUIntLE)(x, this._bits / 8);
+    };
+    FixedNatClass.prototype.encodeType = function () {
+        var offset = Math.log2(this._bits) - 3;
+        return (0, leb128_1.slebEncode)(-5 - offset);
+    };
+    FixedNatClass.prototype.decodeValue = function (b, t) {
+        this.checkType(t);
+        var 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) {
+        return x.toString();
+    };
+    return FixedNatClass;
+}(PrimitiveType));
+exports.FixedNatClass = FixedNatClass;
+/**
+ * Represents an IDL Array
+ *
+ * Arrays of fixed-sized nat/int type (e.g. nat8), are encoded from and decoded to TypedArrays (e.g. Uint8Array).
+ * Arrays of float or other non-primitive types are encoded/decoded as untyped array in Javascript.
+ *
+ * @param {Type} t
+ */
+var VecClass = /** @class */ (function (_super) {
+    __extends(VecClass, _super);
+    function VecClass(_type) {
+        var _this = _super.call(this) || this;
+        _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;
+        if (_type instanceof FixedNatClass && _type._bits === 8) {
+            _this._blobOptimization = true;
+        }
+        return _this;
+    }
+    VecClass.prototype.accept = function (v, d) {
+        return v.visitVec(this, this._type, d);
+    };
+    VecClass.prototype.covariant = function (x) {
+        var _this = this;
+        // Special case for ArrayBuffer
+        var 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) {
+                    try {
+                        return _this._type.covariant(v);
+                    }
+                    catch (e) {
+                        throw new Error("Invalid ".concat(_this.display(), " argument: \n\nindex ").concat(idx, " -> ").concat(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);
+        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);
+        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; }
+        }
+        return buf.buffer;
+    };
+    VecClass.prototype._buildTypeTableImpl = function (typeTable) {
+        this._type.buildTypeTable(typeTable);
+        var opCode = (0, leb128_1.slebEncode)(-19 /* IDLTypeIds.Vector */);
+        var 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);
+        if (!(vec instanceof VecClass)) {
+            throw new Error('Not a vector type');
+        }
+        var len = Number((0, leb128_1.lebDecode)(b));
+        if (this._type instanceof FixedNatClass) {
+            if (this._type._bits == 8) {
+                return new Uint8Array(b.read(len));
+            }
+            if (this._type._bits == 16) {
+                return new Uint16Array(b.read(len * 2));
+            }
+            if (this._type._bits == 32) {
+                return new Uint32Array(b.read(len * 4));
+            }
+            if (this._type._bits == 64) {
+                return new BigUint64Array(b.read(len * 8));
+            }
+        }
+        if (this._type instanceof FixedIntClass) {
+            if (this._type._bits == 8) {
+                return new Int8Array(b.read(len));
+            }
+            if (this._type._bits == 16) {
+                return new Int16Array(b.read(len * 2));
+            }
+            if (this._type._bits == 32) {
+                return new Int32Array(b.read(len * 4));
+            }
+            if (this._type._bits == 64) {
+                return new BigInt64Array(b.read(len * 8));
+            }
+        }
+        var rets = [];
+        for (var 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); });
+        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) {
+        return v.visitOpt(this, this._type, d);
+    };
+    OptClass.prototype.covariant = function (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 ".concat(this.display(), " argument: ").concat(toReadableString(x)));
+    };
+    OptClass.prototype.encodeValue = function (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) {
+        this._type.buildTypeTable(typeTable);
+        var opCode = (0, leb128_1.slebEncode)(-18 /* IDLTypeIds.Opt */);
+        var 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);
+        if (!(opt instanceof OptClass)) {
+            throw new Error('Not an option type');
+        }
+        switch ((0, leb128_1.safeReadUint8)(b)) {
+            case 0:
+                return [];
+            case 1:
+                return [this._type.decodeValue(b, opt._type)];
+            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) {
+        if (x.length === 0) {
+            return 'null';
+        }
+        else {
+            return "opt ".concat(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) {
+        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, "_")) {
+                return null;
+            }
+            res.push(type);
+        }
+        return res;
+    };
+    RecordClass.prototype.covariant = function (x) {
+        var _this = this;
+        if (typeof x === 'object' &&
+            this._fields.every(function (_a) {
+                var _b = __read(_a, 2), k = _b[0], t = _b[1];
+                // eslint-disable-next-line
+                if (!x.hasOwnProperty(k)) {
+                    throw new Error("Record is missing key \"".concat(k, "\"."));
+                }
+                try {
+                    return t.covariant(x[k]);
+                }
+                catch (e) {
+                    throw new Error("Invalid ".concat(_this.display(), " argument: \n\nfield ").concat(k, " -> ").concat(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);
+        if (!(record instanceof RecordClass)) {
+            throw new Error('Not a record type');
+        }
+        var x = {};
+        var expectedRecordIdx = 0;
+        var actualRecordIdx = 0;
+        while (actualRecordIdx < record._fields.length) {
+            var _b = __read(record._fields[actualRecordIdx], 2), hash = _b[0], type = _b[1];
+            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);
+            if (expectedId === actualId) {
+                // the current field on the wire matches the expected field
+                x[expectKey] = expectType.decodeValue(b, type);
+                expectedRecordIdx++;
+                actualRecordIdx++;
+            }
+            else if (actualId > expectedId) {
+                // The expected field does not exist on the wire
+                if (expectType instanceof OptClass || expectType instanceof ReservedClass) {
+                    x[expectKey] = [];
+                    expectedRecordIdx++;
+                }
+                else {
+                    throw new Error('Cannot find required field ' + expectKey);
+                }
+            }
+            else {
+                // The field on the wire does not exist in the output type, so we can skip it
+                type.decodeValue(b, type);
+                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);
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            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));
+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) {
+        return v.visitTuple(this, this._components, d);
+    };
+    TupleClass.prototype.covariant = function (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) {
+                try {
+                    return t.covariant(x[i]);
+                }
+                catch (e) {
+                    throw new Error("Invalid ".concat(_this.display(), " argument: \n\nindex ").concat(i, " -> ").concat(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);
+        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));
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            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));
+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) {
+        return v.visitVariant(this, this._fields, d);
+    };
+    VariantClass.prototype.covariant = function (x) {
+        var _this = this;
+        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];
+                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));
+                }
+            }))
+            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];
+            // eslint-disable-next-line
+            if (x.hasOwnProperty(name_1)) {
+                var idx = (0, leb128_1.lebEncode)(i);
+                var buf = type.encodeValue(x[name_1]);
+                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];
+            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);
+        if (!(variant instanceof VariantClass)) {
+            throw new Error('Not a variant type');
+        }
+        var 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);
+            }
+            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, "}");
+                    }
+                }
+            }
+        }
+        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) {
+        if (!this._type) {
+            throw Error('Recursive type uninitialized.');
+        }
+        return v.visitRec(this, this._type, d);
+    };
+    RecClass.prototype.fill = function (t) {
+        this._type = t;
+    };
+    RecClass.prototype.getType = function () {
+        return this._type;
+    };
+    RecClass.prototype.covariant = function (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) {
+        if (!this._type) {
+            throw Error('Recursive type uninitialized.');
+        }
+        return this._type.encodeValue(x);
+    };
+    RecClass.prototype._buildTypeTableImpl = function (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) {
+        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 () {
+        if (!this._type) {
+            throw Error('Recursive type uninitialized.');
+        }
+        return "\u03BC".concat(this.name, ".").concat(this._type.name);
+    };
+    RecClass.prototype.valueToString = function (x) {
+        if (!this._type) {
+            throw Error('Recursive type uninitialized.');
+        }
+        return this._type.valueToString(x);
+    };
+    RecClass._counter = 0;
+    return RecClass;
+}(ConstructType));
+exports.RecClass = RecClass;
+function decodePrincipalId(b) {
+    var x = (0, leb128_1.safeReadUint8)(b);
+    if (x !== 1) {
+        throw new Error('Cannot decode principal');
+    }
+    var 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) {
+        return v.visitPrincipal(this, d);
+    };
+    PrincipalClass.prototype.covariant = function (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);
+        return (0, buffer_1.concat)(new Uint8Array([1]), len, buf);
+    };
+    PrincipalClass.prototype.encodeType = function () {
+        return (0, leb128_1.slebEncode)(-24 /* IDLTypeIds.Principal */);
+    };
+    PrincipalClass.prototype.decodeValue = function (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));
+exports.PrincipalClass = PrincipalClass;
+/**
+ * Represents an IDL function reference.
+ * @param argTypes Argument types.
+ * @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) {
+        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 v.visitFunc(this, d);
+    };
+    FuncClass.prototype.covariant = function (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);
+        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));
+        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);
+        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);
+        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) {
+        if (ann === 'query') {
+            return new Uint8Array([1]);
+        }
+        else if (ann === 'oneway') {
+            return new Uint8Array([2]);
+        }
+        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) {
+        return v.visitService(this, d);
+    };
+    ServiceClass.prototype.covariant = function (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);
+        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);
+            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) {
+        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));
+exports.ServiceClass = ServiceClass;
+/**
+ *
+ * @param x
+ * @returns {string}
+ */
+function toReadableString(x) {
+    var str = JSON.stringify(x, function (_key, value) { return (typeof value === 'bigint' ? "BigInt(".concat(value, ")") : value); });
+    return str && str.length > toReadableString_max ? str.substring(0, toReadableString_max - 3) + '...' : str;
+}
+/**
+ * Encode a array of values
+ * @param argTypes
+ * @param args
+ * @returns {Buffer} serialised value
+ */
+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) {
+        try {
+            t.covariant(x);
+        }
+        catch (e) {
+            var 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;
+/**
+ * Decode a binary value
+ * @param retTypes - Types expected in the buffer.
+ * @param bytes - hex-encoded string, or buffer.
+ * @returns Value deserialised to JS type
+ */
+function decode(retTypes, bytes) {
+    var 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);
+    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));
+            switch (ty) {
+                case -18 /* IDLTypeIds.Opt */:
+                case -19 /* IDLTypeIds.Vector */: {
+                    var 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;
+                    while (objectLength--) {
+                        var hash = Number((0, leb128_1.lebDecode)(pipe));
+                        if (hash >= Math.pow(2, 32)) {
+                            throw new Error('field id out of 32-bit range');
+                        }
+                        if (typeof prevHash === 'number' && prevHash >= hash) {
+                            throw new Error('field id collision or not sorted');
+                        }
+                        prevHash = hash;
+                        var 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));
+                    while (argLength--) {
+                        args.push(Number((0, leb128_1.slebDecode)(pipe)));
+                    }
+                    var returnValues = [];
+                    var 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));
+                    while (annotationLength--) {
+                        var annotation = Number((0, leb128_1.lebDecode)(pipe));
+                        switch (annotation) {
+                            case 1: {
+                                annotations.push('query');
+                                break;
+                            }
+                            case 2: {
+                                annotations.push('oneway');
+                                break;
+                            }
+                            default:
+                                throw new Error('unknown annotation');
+                        }
+                    }
+                    typeTable.push([ty, [args, returnValues, annotations]]);
+                    break;
+                }
+                case -23 /* IDLTypeIds.Service */: {
+                    var servLength = Number((0, leb128_1.lebDecode)(pipe));
+                    var 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);
+                        methods.push([funcName, funcType]);
+                    }
+                    typeTable.push([ty, methods]);
+                    break;
+                }
+                default:
+                    throw new Error('Illegal op_code: ' + ty);
+            }
+        }
+        var rawList = [];
+        var length = Number((0, leb128_1.lebDecode)(pipe));
+        for (var 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];
+    if (rawTypes.length < retTypes.length) {
+        throw new Error('Wrong number of return values');
+    }
+    var table = rawTable.map(function (_) { return Rec(); });
+    function getType(t) {
+        if (t < -24) {
+            throw new Error('future value not supported');
+        }
+        if (t < 0) {
+            switch (t) {
+                case -1:
+                    return exports.Null;
+                case -2:
+                    return exports.Bool;
+                case -3:
+                    return exports.Nat;
+                case -4:
+                    return exports.Int;
+                case -5:
+                    return exports.Nat8;
+                case -6:
+                    return exports.Nat16;
+                case -7:
+                    return exports.Nat32;
+                case -8:
+                    return exports.Nat64;
+                case -9:
+                    return exports.Int8;
+                case -10:
+                    return exports.Int16;
+                case -11:
+                    return exports.Int32;
+                case -12:
+                    return exports.Int64;
+                case -13:
+                    return exports.Float32;
+                case -14:
+                    return exports.Float64;
+                case -15:
+                    return exports.Text;
+                case -16:
+                    return exports.Reserved;
+                case -17:
+                    return exports.Empty;
+                case -24:
+                    return exports.Principal;
+                default:
+                    throw new Error('Illegal op_code: ' + t);
+            }
+        }
+        if (t >= rawTable.length) {
+            throw new Error('type index out of range');
+        }
+        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]);
+                return Vec(ty);
+            }
+            case -18 /* IDLTypeIds.Opt */: {
+                var 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);
+                    }
+                }
+                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();
+                if (Array.isArray(tuple)) {
+                    return Tuple.apply(void 0, __spreadArray([], __read(tuple), false));
+                }
+                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; }
+                }
+                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);
+            }
+            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;
+                    }
+                }
+                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);
+                    }
+                    finally { if (e_9) throw e_9.error; }
+                }
+                return Service(rec);
+            }
+            default:
+                throw new Error('Illegal op_code: ' + entry[0]);
+        }
+    }
+    rawTable.forEach(function (entry, i) {
+        var t = buildType(entry);
+        table[i].fill(t);
+    });
+    var types = rawTypes.map(function (t) { return getType(t); });
+    var output = retTypes.map(function (t, i) {
+        return t.decodeValue(b, types[i]);
+    });
+    // skip unused values
+    for (var ind = retTypes.length; ind < types.length; ind++) {
+        types[ind].decodeValue(b, types[ind]);
+    }
+    if (b.byteLength > 0) {
+        throw new Error('decode: Left-over bytes');
+    }
+    return output;
+}
+exports.decode = decode;
+// Export Types instances.
+exports.Empty = new EmptyClass();
+exports.Reserved = new ReservedClass();
+/**
+ * Client-only type for deserializing unknown data. Not supported by Candid, and its use is discouraged.
+ */
+exports.Unknown = new UnknownClass();
+exports.Bool = new BoolClass();
+exports.Null = new NullClass();
+exports.Text = new TextClass();
+exports.Int = new IntClass();
+exports.Nat = new NatClass();
+exports.Float32 = new FloatClass(32);
+exports.Float64 = new FloatClass(64);
+exports.Int8 = new FixedIntClass(8);
+exports.Int16 = new FixedIntClass(16);
+exports.Int32 = new FixedIntClass(32);
+exports.Int64 = new FixedIntClass(64);
+exports.Nat8 = new FixedNatClass(8);
+exports.Nat16 = new FixedNatClass(16);
+exports.Nat32 = new FixedNatClass(32);
+exports.Nat64 = new FixedNatClass(64);
+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];
+    }
+    return new TupleClass(types);
+}
+exports.Tuple = Tuple;
+/**
+ *
+ * @param t IDL Type
+ * @returns VecClass from that type
+ */
+function Vec(t) {
+    return new VecClass(t);
+}
+exports.Vec = Vec;
+/**
+ *
+ * @param t IDL Type
+ * @returns OptClass of Type
+ */
+function Opt(t) {
+    return new OptClass(t);
+}
+exports.Opt = Opt;
+/**
+ *
+ * @param t Record of string and IDL Type
+ * @returns RecordClass of string and Type
+ */
+function Record(t) {
+    return new RecordClass(t);
+}
+exports.Record = Record;
+/**
+ *
+ * @param fields Record of string and IDL Type
+ * @returns VariantClass
+ */
+function Variant(fields) {
+    return new VariantClass(fields);
+}
+exports.Variant = Variant;
+/**
+ *
+ * @returns new RecClass
+ */
+function Rec() {
+    return new RecClass();
+}
+exports.Rec = Rec;
+/**
+ *
+ * @param args array of IDL Types
+ * @param ret array of IDL Types
+ * @param annotations array of strings, [] by default
+ * @returns new FuncClass
+ */
+function Func(args, ret, annotations) {
+    if (annotations === void 0) { annotations = []; }
+    return new FuncClass(args, ret, annotations);
+}
+exports.Func = Func;
+/**
+ *
+ * @param t Record of string and FuncClass
+ * @returns ServiceClass
+ */
+function Service(t) {
+    return new ServiceClass(t);
+}
+exports.Service = Service;
+//# sourceMappingURL=idl.js.map