@libp2p/floodsub 11.0.14 → 11.0.15

package/dist/src/message/rpc.js

@@ -1,5 +1,4 @@
-/* eslint-disable complexity */
-import { decodeMessage, encodeMessage, MaxLengthError, message } from 'protons-runtime';
+import { decodeMessage, encodeMessage, MaxLengthError, message, streamMessage } from 'protons-runtime';
 export var RPC;
 (function (RPC) {
     let SubOpts;
@@ -43,16 +42,47 @@ export var RPC;
                         }
                     }
                     return obj;
+                }, function* (reader, length, prefix, opts = {}) {
+                    const end = length == null ? reader.len : reader.pos + length;
+                    while (reader.pos < end) {
+                        const tag = reader.uint32();
+                        switch (tag >>> 3) {
+                            case 1: {
+                                yield {
+                                    field: `${prefix}.subscribe`,
+                                    value: reader.bool()
+                                };
+                                break;
+                            }
+                            case 2: {
+                                yield {
+                                    field: `${prefix}.topic`,
+                                    value: reader.string()
+                                };
+                                break;
+                            }
+                            default: {
+                                reader.skipType(tag & 7);
+                                break;
+                            }
+                        }
+                    }
                 });
             }
             return _codec;
         };
-        SubOpts.encode = (obj) => {
+        function encode(obj) {
             return encodeMessage(obj, SubOpts.codec());
-        };
-        SubOpts.decode = (buf, opts) => {
+        }
+        SubOpts.encode = encode;
+        function decode(buf, opts) {
             return decodeMessage(buf, SubOpts.codec(), opts);
-        };
+        }
+        SubOpts.decode = decode;
+        function stream(buf, opts) {
+            return streamMessage(buf, SubOpts.codec(), opts);
+        }
+        SubOpts.stream = stream;
     })(SubOpts = RPC.SubOpts || (RPC.SubOpts = {}));
     let Message;
     (function (Message) {
@@ -127,16 +157,75 @@ export var RPC;
                         }
                     }
                     return obj;
+                }, function* (reader, length, prefix, opts = {}) {
+                    const end = length == null ? reader.len : reader.pos + length;
+                    while (reader.pos < end) {
+                        const tag = reader.uint32();
+                        switch (tag >>> 3) {
+                            case 1: {
+                                yield {
+                                    field: `${prefix}.from`,
+                                    value: reader.bytes()
+                                };
+                                break;
+                            }
+                            case 2: {
+                                yield {
+                                    field: `${prefix}.data`,
+                                    value: reader.bytes()
+                                };
+                                break;
+                            }
+                            case 3: {
+                                yield {
+                                    field: `${prefix}.sequenceNumber`,
+                                    value: reader.bytes()
+                                };
+                                break;
+                            }
+                            case 4: {
+                                yield {
+                                    field: `${prefix}.topic`,
+                                    value: reader.string()
+                                };
+                                break;
+                            }
+                            case 5: {
+                                yield {
+                                    field: `${prefix}.signature`,
+                                    value: reader.bytes()
+                                };
+                                break;
+                            }
+                            case 6: {
+                                yield {
+                                    field: `${prefix}.key`,
+                                    value: reader.bytes()
+                                };
+                                break;
+                            }
+                            default: {
+                                reader.skipType(tag & 7);
+                                break;
+                            }
+                        }
+                    }
                 });
             }
             return _codec;
         };
-        Message.encode = (obj) => {
+        function encode(obj) {
             return encodeMessage(obj, Message.codec());
-        };
-        Message.decode = (buf, opts) => {
+        }
+        Message.encode = encode;
+        function decode(buf, opts) {
             return decodeMessage(buf, Message.codec(), opts);
-        };
+        }
+        Message.decode = decode;
+        function stream(buf, opts) {
+            return streamMessage(buf, Message.codec(), opts);
+        }
+        Message.stream = stream;
     })(Message = RPC.Message || (RPC.Message = {}));
     let _codec;
     RPC.codec = () => {
@@ -145,13 +234,13 @@ export var RPC;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.subscriptions != null) {
+                if (obj.subscriptions != null && obj.subscriptions.length > 0) {
                     for (const value of obj.subscriptions) {
                         w.uint32(10);
                         RPC.SubOpts.codec().encode(value, w);
                     }
                 }
-                if (obj.messages != null) {
+                if (obj.messages != null && obj.messages.length > 0) {
                     for (const value of obj.messages) {
                         w.uint32(18);
                         RPC.Message.codec().encode(value, w);
@@ -175,7 +264,7 @@ export var RPC;
                     switch (tag >>> 3) {
                         case 1: {
                             if (opts.limits?.subscriptions != null && obj.subscriptions.length === opts.limits.subscriptions) {
-                                throw new MaxLengthError('Decode error - map field "subscriptions" had too many elements');
+                                throw new MaxLengthError('Decode error - repeated field "subscriptions" had too many elements');
                             }
                             obj.subscriptions.push(RPC.SubOpts.codec().decode(reader, reader.uint32(), {
                                 limits: opts.limits?.subscriptions$
@@ -184,7 +273,7 @@ export var RPC;
                         }
                         case 2: {
                             if (opts.limits?.messages != null && obj.messages.length === opts.limits.messages) {
-                                throw new MaxLengthError('Decode error - map field "messages" had too many elements');
+                                throw new MaxLengthError('Decode error - repeated field "messages" had too many elements');
                             }
                             obj.messages.push(RPC.Message.codec().decode(reader, reader.uint32(), {
                                 limits: opts.limits?.messages$
@@ -204,16 +293,73 @@ export var RPC;
                     }
                 }
                 return obj;
+            }, function* (reader, length, prefix, opts = {}) {
+                const obj = {
+                    subscriptions: 0,
+                    messages: 0
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            if (opts.limits?.subscriptions != null && obj.subscriptions === opts.limits.subscriptions) {
+                                throw new MaxLengthError('Streaming decode error - repeated field "subscriptions" had too many elements');
+                            }
+                            for (const evt of RPC.SubOpts.codec().stream(reader, reader.uint32(), `${prefix}.subscriptions[]`, {
+                                limits: opts.limits?.subscriptions$
+                            })) {
+                                yield {
+                                    ...evt,
+                                    index: obj.subscriptions
+                                };
+                            }
+                            obj.subscriptions++;
+                            break;
+                        }
+                        case 2: {
+                            if (opts.limits?.messages != null && obj.messages === opts.limits.messages) {
+                                throw new MaxLengthError('Streaming decode error - repeated field "messages" had too many elements');
+                            }
+                            for (const evt of RPC.Message.codec().stream(reader, reader.uint32(), `${prefix}.messages[]`, {
+                                limits: opts.limits?.messages$
+                            })) {
+                                yield {
+                                    ...evt,
+                                    index: obj.messages
+                                };
+                            }
+                            obj.messages++;
+                            break;
+                        }
+                        case 3: {
+                            yield* ControlMessage.codec().stream(reader, reader.uint32(), `${prefix}.control`, {
+                                limits: opts.limits?.control
+                            });
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
             });
         }
         return _codec;
     };
-    RPC.encode = (obj) => {
+    function encode(obj) {
         return encodeMessage(obj, RPC.codec());
-    };
-    RPC.decode = (buf, opts) => {
+    }
+    RPC.encode = encode;
+    function decode(buf, opts) {
         return decodeMessage(buf, RPC.codec(), opts);
-    };
+    }
+    RPC.decode = decode;
+    function stream(buf, opts) {
+        return streamMessage(buf, RPC.codec(), opts);
+    }
+    RPC.stream = stream;
 })(RPC || (RPC = {}));
 export var ControlMessage;
 (function (ControlMessage) {
@@ -224,25 +370,25 @@ export var ControlMessage;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.ihave != null) {
+                if (obj.ihave != null && obj.ihave.length > 0) {
                     for (const value of obj.ihave) {
                         w.uint32(10);
                         ControlIHave.codec().encode(value, w);
                     }
                 }
-                if (obj.iwant != null) {
+                if (obj.iwant != null && obj.iwant.length > 0) {
                     for (const value of obj.iwant) {
                         w.uint32(18);
                         ControlIWant.codec().encode(value, w);
                     }
                 }
-                if (obj.graft != null) {
+                if (obj.graft != null && obj.graft.length > 0) {
                     for (const value of obj.graft) {
                         w.uint32(26);
                         ControlGraft.codec().encode(value, w);
                     }
                 }
-                if (obj.prune != null) {
+                if (obj.prune != null && obj.prune.length > 0) {
                     for (const value of obj.prune) {
                         w.uint32(34);
                         ControlPrune.codec().encode(value, w);
@@ -264,7 +410,7 @@ export var ControlMessage;
                     switch (tag >>> 3) {
                         case 1: {
                             if (opts.limits?.ihave != null && obj.ihave.length === opts.limits.ihave) {
-                                throw new MaxLengthError('Decode error - map field "ihave" had too many elements');
+                                throw new MaxLengthError('Decode error - repeated field "ihave" had too many elements');
                             }
                             obj.ihave.push(ControlIHave.codec().decode(reader, reader.uint32(), {
                                 limits: opts.limits?.ihave$
@@ -273,7 +419,7 @@ export var ControlMessage;
                         }
                         case 2: {
                             if (opts.limits?.iwant != null && obj.iwant.length === opts.limits.iwant) {
-                                throw new MaxLengthError('Decode error - map field "iwant" had too many elements');
+                                throw new MaxLengthError('Decode error - repeated field "iwant" had too many elements');
                             }
                             obj.iwant.push(ControlIWant.codec().decode(reader, reader.uint32(), {
                                 limits: opts.limits?.iwant$
@@ -282,7 +428,7 @@ export var ControlMessage;
                         }
                         case 3: {
                             if (opts.limits?.graft != null && obj.graft.length === opts.limits.graft) {
-                                throw new MaxLengthError('Decode error - map field "graft" had too many elements');
+                                throw new MaxLengthError('Decode error - repeated field "graft" had too many elements');
                             }
                             obj.graft.push(ControlGraft.codec().decode(reader, reader.uint32(), {
                                 limits: opts.limits?.graft$
@@ -291,7 +437,7 @@ export var ControlMessage;
                         }
                         case 4: {
                             if (opts.limits?.prune != null && obj.prune.length === opts.limits.prune) {
-                                throw new MaxLengthError('Decode error - map field "prune" had too many elements');
+                                throw new MaxLengthError('Decode error - repeated field "prune" had too many elements');
                             }
                             obj.prune.push(ControlPrune.codec().decode(reader, reader.uint32(), {
                                 limits: opts.limits?.prune$
@@ -305,16 +451,99 @@ export var ControlMessage;
                     }
                 }
                 return obj;
+            }, function* (reader, length, prefix, opts = {}) {
+                const obj = {
+                    ihave: 0,
+                    iwant: 0,
+                    graft: 0,
+                    prune: 0
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            if (opts.limits?.ihave != null && obj.ihave === opts.limits.ihave) {
+                                throw new MaxLengthError('Streaming decode error - repeated field "ihave" had too many elements');
+                            }
+                            for (const evt of ControlIHave.codec().stream(reader, reader.uint32(), `${prefix}.ihave[]`, {
+                                limits: opts.limits?.ihave$
+                            })) {
+                                yield {
+                                    ...evt,
+                                    index: obj.ihave
+                                };
+                            }
+                            obj.ihave++;
+                            break;
+                        }
+                        case 2: {
+                            if (opts.limits?.iwant != null && obj.iwant === opts.limits.iwant) {
+                                throw new MaxLengthError('Streaming decode error - repeated field "iwant" had too many elements');
+                            }
+                            for (const evt of ControlIWant.codec().stream(reader, reader.uint32(), `${prefix}.iwant[]`, {
+                                limits: opts.limits?.iwant$
+                            })) {
+                                yield {
+                                    ...evt,
+                                    index: obj.iwant
+                                };
+                            }
+                            obj.iwant++;
+                            break;
+                        }
+                        case 3: {
+                            if (opts.limits?.graft != null && obj.graft === opts.limits.graft) {
+                                throw new MaxLengthError('Streaming decode error - repeated field "graft" had too many elements');
+                            }
+                            for (const evt of ControlGraft.codec().stream(reader, reader.uint32(), `${prefix}.graft[]`, {
+                                limits: opts.limits?.graft$
+                            })) {
+                                yield {
+                                    ...evt,
+                                    index: obj.graft
+                                };
+                            }
+                            obj.graft++;
+                            break;
+                        }
+                        case 4: {
+                            if (opts.limits?.prune != null && obj.prune === opts.limits.prune) {
+                                throw new MaxLengthError('Streaming decode error - repeated field "prune" had too many elements');
+                            }
+                            for (const evt of ControlPrune.codec().stream(reader, reader.uint32(), `${prefix}.prune[]`, {
+                                limits: opts.limits?.prune$
+                            })) {
+                                yield {
+                                    ...evt,
+                                    index: obj.prune
+                                };
+                            }
+                            obj.prune++;
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
             });
         }
         return _codec;
     };
-    ControlMessage.encode = (obj) => {
+    function encode(obj) {
         return encodeMessage(obj, ControlMessage.codec());
-    };
-    ControlMessage.decode = (buf, opts) => {
+    }
+    ControlMessage.encode = encode;
+    function decode(buf, opts) {
         return decodeMessage(buf, ControlMessage.codec(), opts);
-    };
+    }
+    ControlMessage.decode = decode;
+    function stream(buf, opts) {
+        return streamMessage(buf, ControlMessage.codec(), opts);
+    }
+    ControlMessage.stream = stream;
 })(ControlMessage || (ControlMessage = {}));
 export var ControlIHave;
 (function (ControlIHave) {
@@ -329,7 +558,7 @@ export var ControlIHave;
                     w.uint32(10);
                     w.string(obj.topic);
                 }
-                if (obj.messageIDs != null) {
+                if (obj.messageIDs != null && obj.messageIDs.length > 0) {
                     for (const value of obj.messageIDs) {
                         w.uint32(18);
                         w.bytes(value);
@@ -352,7 +581,7 @@ export var ControlIHave;
                         }
                         case 2: {
                             if (opts.limits?.messageIDs != null && obj.messageIDs.length === opts.limits.messageIDs) {
-                                throw new MaxLengthError('Decode error - map field "messageIDs" had too many elements');
+                                throw new MaxLengthError('Decode error - repeated field "messageIDs" had too many elements');
                             }
                             obj.messageIDs.push(reader.bytes());
                             break;
@@ -364,16 +593,55 @@ export var ControlIHave;
                     }
                 }
                 return obj;
+            }, function* (reader, length, prefix, opts = {}) {
+                const obj = {
+                    messageIDs: 0
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            yield {
+                                field: `${prefix}.topic`,
+                                value: reader.string()
+                            };
+                            break;
+                        }
+                        case 2: {
+                            if (opts.limits?.messageIDs != null && obj.messageIDs === opts.limits.messageIDs) {
+                                throw new MaxLengthError('Streaming decode error - repeated field "messageIDs" had too many elements');
+                            }
+                            yield {
+                                field: `${prefix}.messageIDs[]`,
+                                index: obj.messageIDs,
+                                value: reader.bytes()
+                            };
+                            obj.messageIDs++;
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
             });
         }
         return _codec;
     };
-    ControlIHave.encode = (obj) => {
+    function encode(obj) {
         return encodeMessage(obj, ControlIHave.codec());
-    };
-    ControlIHave.decode = (buf, opts) => {
+    }
+    ControlIHave.encode = encode;
+    function decode(buf, opts) {
         return decodeMessage(buf, ControlIHave.codec(), opts);
-    };
+    }
+    ControlIHave.decode = decode;
+    function stream(buf, opts) {
+        return streamMessage(buf, ControlIHave.codec(), opts);
+    }
+    ControlIHave.stream = stream;
 })(ControlIHave || (ControlIHave = {}));
 export var ControlIWant;
 (function (ControlIWant) {
@@ -384,7 +652,7 @@ export var ControlIWant;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if (obj.messageIDs != null) {
+                if (obj.messageIDs != null && obj.messageIDs.length > 0) {
                     for (const value of obj.messageIDs) {
                         w.uint32(10);
                         w.bytes(value);
@@ -403,7 +671,7 @@ export var ControlIWant;
                     switch (tag >>> 3) {
                         case 1: {
                             if (opts.limits?.messageIDs != null && obj.messageIDs.length === opts.limits.messageIDs) {
-                                throw new MaxLengthError('Decode error - map field "messageIDs" had too many elements');
+                                throw new MaxLengthError('Decode error - repeated field "messageIDs" had too many elements');
                             }
                             obj.messageIDs.push(reader.bytes());
                             break;
@@ -415,16 +683,48 @@ export var ControlIWant;
                     }
                 }
                 return obj;
+            }, function* (reader, length, prefix, opts = {}) {
+                const obj = {
+                    messageIDs: 0
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            if (opts.limits?.messageIDs != null && obj.messageIDs === opts.limits.messageIDs) {
+                                throw new MaxLengthError('Streaming decode error - repeated field "messageIDs" had too many elements');
+                            }
+                            yield {
+                                field: `${prefix}.messageIDs[]`,
+                                index: obj.messageIDs,
+                                value: reader.bytes()
+                            };
+                            obj.messageIDs++;
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
             });
         }
         return _codec;
     };
-    ControlIWant.encode = (obj) => {
+    function encode(obj) {
         return encodeMessage(obj, ControlIWant.codec());
-    };
-    ControlIWant.decode = (buf, opts) => {
+    }
+    ControlIWant.encode = encode;
+    function decode(buf, opts) {
         return decodeMessage(buf, ControlIWant.codec(), opts);
-    };
+    }
+    ControlIWant.decode = decode;
+    function stream(buf, opts) {
+        return streamMessage(buf, ControlIWant.codec(), opts);
+    }
+    ControlIWant.stream = stream;
 })(ControlIWant || (ControlIWant = {}));
 export var ControlGraft;
 (function (ControlGraft) {
@@ -459,16 +759,40 @@ export var ControlGraft;
                     }
                 }
                 return obj;
+            }, function* (reader, length, prefix, opts = {}) {
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            yield {
+                                field: `${prefix}.topic`,
+                                value: reader.string()
+                            };
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
             });
         }
         return _codec;
     };
-    ControlGraft.encode = (obj) => {
+    function encode(obj) {
         return encodeMessage(obj, ControlGraft.codec());
-    };
-    ControlGraft.decode = (buf, opts) => {
+    }
+    ControlGraft.encode = encode;
+    function decode(buf, opts) {
         return decodeMessage(buf, ControlGraft.codec(), opts);
-    };
+    }
+    ControlGraft.decode = decode;
+    function stream(buf, opts) {
+        return streamMessage(buf, ControlGraft.codec(), opts);
+    }
+    ControlGraft.stream = stream;
 })(ControlGraft || (ControlGraft = {}));
 export var ControlPrune;
 (function (ControlPrune) {
@@ -483,7 +807,7 @@ export var ControlPrune;
                     w.uint32(10);
                     w.string(obj.topic);
                 }
-                if (obj.peers != null) {
+                if (obj.peers != null && obj.peers.length > 0) {
                     for (const value of obj.peers) {
                         w.uint32(18);
                         PeerInfo.codec().encode(value, w);
@@ -510,7 +834,7 @@ export var ControlPrune;
                         }
                         case 2: {
                             if (opts.limits?.peers != null && obj.peers.length === opts.limits.peers) {
-                                throw new MaxLengthError('Decode error - map field "peers" had too many elements');
+                                throw new MaxLengthError('Decode error - repeated field "peers" had too many elements');
                             }
                             obj.peers.push(PeerInfo.codec().decode(reader, reader.uint32(), {
                                 limits: opts.limits?.peers$
@@ -528,16 +852,65 @@ export var ControlPrune;
                     }
                 }
                 return obj;
+            }, function* (reader, length, prefix, opts = {}) {
+                const obj = {
+                    peers: 0
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            yield {
+                                field: `${prefix}.topic`,
+                                value: reader.string()
+                            };
+                            break;
+                        }
+                        case 2: {
+                            if (opts.limits?.peers != null && obj.peers === opts.limits.peers) {
+                                throw new MaxLengthError('Streaming decode error - repeated field "peers" had too many elements');
+                            }
+                            for (const evt of PeerInfo.codec().stream(reader, reader.uint32(), `${prefix}.peers[]`, {
+                                limits: opts.limits?.peers$
+                            })) {
+                                yield {
+                                    ...evt,
+                                    index: obj.peers
+                                };
+                            }
+                            obj.peers++;
+                            break;
+                        }
+                        case 3: {
+                            yield {
+                                field: `${prefix}.backoff`,
+                                value: reader.uint64()
+                            };
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
             });
         }
         return _codec;
     };
-    ControlPrune.encode = (obj) => {
+    function encode(obj) {
         return encodeMessage(obj, ControlPrune.codec());
-    };
-    ControlPrune.decode = (buf, opts) => {
+    }
+    ControlPrune.encode = encode;
+    function decode(buf, opts) {
         return decodeMessage(buf, ControlPrune.codec(), opts);
-    };
+    }
+    ControlPrune.decode = decode;
+    function stream(buf, opts) {
+        return streamMessage(buf, ControlPrune.codec(), opts);
+    }
+    ControlPrune.stream = stream;
 })(ControlPrune || (ControlPrune = {}));
 export var PeerInfo;
 (function (PeerInfo) {
@@ -580,15 +953,46 @@ export var PeerInfo;
                     }
                 }
                 return obj;
+            }, function* (reader, length, prefix, opts = {}) {
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            yield {
+                                field: `${prefix}.peerID`,
+                                value: reader.bytes()
+                            };
+                            break;
+                        }
+                        case 2: {
+                            yield {
+                                field: `${prefix}.signedPeerRecord`,
+                                value: reader.bytes()
+                            };
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
             });
         }
         return _codec;
     };
-    PeerInfo.encode = (obj) => {
+    function encode(obj) {
         return encodeMessage(obj, PeerInfo.codec());
-    };
-    PeerInfo.decode = (buf, opts) => {
+    }
+    PeerInfo.encode = encode;
+    function decode(buf, opts) {
         return decodeMessage(buf, PeerInfo.codec(), opts);
-    };
+    }
+    PeerInfo.decode = decode;
+    function stream(buf, opts) {
+        return streamMessage(buf, PeerInfo.codec(), opts);
+    }
+    PeerInfo.stream = stream;
 })(PeerInfo || (PeerInfo = {}));
 //# sourceMappingURL=rpc.js.map