@waku/core 0.0.17 → 0.0.19

package/bundle/{peer_exchange-1229c8b0.js → version_0-9c941081.js}

@@ -1,36 +1,4 @@
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-function getAugmentedNamespace(n) {
-  if (n.__esModule) return n;
-  var f = n.default;
-	if (typeof f == "function") {
-		var a = function a () {
-			if (this instanceof a) {
-				var args = [null];
-				args.push.apply(args, arguments);
-				var Ctor = Function.bind.apply(f, args);
-				return new Ctor();
-			}
-			return f.apply(this, arguments);
-		};
-		a.prototype = f.prototype;
-  } else a = {};
-  Object.defineProperty(a, '__esModule', {value: true});
-	Object.keys(n).forEach(function (k) {
-		var d = Object.getOwnPropertyDescriptor(n, k);
-		Object.defineProperty(a, k, d.get ? d : {
-			enumerable: true,
-			get: function () {
-				return n[k];
-			}
-		});
-	});
-	return a;
-}
+import { c as commonjsGlobal, g as getDefaultExportFromCjs, d as debug } from './browser-bde977a3.js';
 
 var minimal = {};
 
@@ -226,7 +194,7 @@ var base64$1 = {};
 	 */
 	base64.test = function test(string) {
 	    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
-	};
+	}; 
 } (base64$1));
 
 var eventemitter = EventEmitter;
@@ -762,7 +730,7 @@ var utf8$2 = {};
 	        }
 	    }
 	    return offset - start;
-	};
+	}; 
 } (utf8$2));
 
 var pool_1 = pool;
@@ -1463,8 +1431,8 @@ function requireMinimal () {
 		        function Buffer_allocUnsafe(size) {
 		            return new Buffer(size);
 		        };
-		};
-} (minimal));
+		}; 
+	} (minimal));
 	return minimal;
 }
 
@@ -1879,6 +1847,8 @@ Reader$1._configure = function(BufferReader_) {
     });
 };
 
+var ReaderClass = /*@__PURE__*/getDefaultExportFromCjs(reader$1);
+
 var reader_buffer = BufferReader;
 
 // extends Reader
@@ -1930,6 +1900,8 @@ BufferReader.prototype.string = function read_string_buffer() {
 
 BufferReader._configure();
 
+var ReaderBufferClass = /*@__PURE__*/getDefaultExportFromCjs(reader_buffer);
+
 var minimalExports = requireMinimal();
 var util$2 = /*@__PURE__*/getDefaultExportFromCjs(minimalExports);
 
@@ -2398,6 +2370,8 @@ Writer$1._configure = function(BufferWriter_) {
     BufferWriter$1._configure();
 };
 
+var WriterClass = /*@__PURE__*/getDefaultExportFromCjs(writer$1);
+
 var writer_buffer = BufferWriter;
 
 // extends Writer
@@ -2483,11 +2457,13 @@ BufferWriter.prototype.string = function write_string_buffer(value) {
 
 BufferWriter._configure();
 
+var WriterBufferClass = /*@__PURE__*/getDefaultExportFromCjs(writer_buffer);
+
 // @ts-expect-error no types
 function configure() {
     util$2._configure();
-    reader$1._configure(reader_buffer);
-    writer$1._configure(writer_buffer);
+    ReaderClass._configure(ReaderBufferClass);
+    WriterClass._configure(WriterBufferClass);
 }
 // Set up buffer utility according to the environment
 configure();
@@ -2508,7 +2484,7 @@ function patchReader(obj) {
     return obj;
 }
 function reader(buf) {
-    return patchReader(new reader$1(buf));
+    return patchReader(new ReaderClass(buf));
 }
 function patchWriter(obj) {
     for (const method of methods) {
@@ -2523,7 +2499,7 @@ function patchWriter(obj) {
     return obj;
 }
 function writer() {
-    return patchWriter(writer$1.create());
+    return patchWriter(WriterClass.create());
 }
 
 function decodeMessage(buf, codec) {
@@ -2584,7 +2560,7 @@ function message$1(encode, decode) {
 }
 
 /* eslint-disable import/export */
-var RateLimitProof$3;
+var RateLimitProof$4;
 (function (RateLimitProof) {
     let _codec;
     RateLimitProof.codec = () => {
@@ -2675,8 +2651,8 @@ var RateLimitProof$3;
     RateLimitProof.decode = (buf) => {
         return decodeMessage(buf, RateLimitProof.codec());
     };
-})(RateLimitProof$3 || (RateLimitProof$3 = {}));
-var WakuMessage$3;
+})(RateLimitProof$4 || (RateLimitProof$4 = {}));
+var WakuMessage$4;
 (function (WakuMessage) {
     let _codec;
     WakuMessage.codec = () => {
@@ -2707,7 +2683,7 @@ var WakuMessage$3;
                 }
                 if (obj.rateLimitProof != null) {
                     w.uint32(170);
-                    RateLimitProof$3.codec().encode(obj.rateLimitProof, w);
+                    RateLimitProof$4.codec().encode(obj.rateLimitProof, w);
                 }
                 if (obj.ephemeral != null) {
                     w.uint32(248);
@@ -2741,7 +2717,7 @@ var WakuMessage$3;
                             obj.meta = reader.bytes();
                             break;
                         case 21:
-                            obj.rateLimitProof = RateLimitProof$3.codec().decode(reader, reader.uint32());
+                            obj.rateLimitProof = RateLimitProof$4.codec().decode(reader, reader.uint32());
                             break;
                         case 31:
                             obj.ephemeral = reader.bool();
@@ -2762,12 +2738,12 @@ var WakuMessage$3;
     WakuMessage.decode = (buf) => {
         return decodeMessage(buf, WakuMessage.codec());
     };
-})(WakuMessage$3 || (WakuMessage$3 = {}));
+})(WakuMessage$4 || (WakuMessage$4 = {}));
 
 var message = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	get RateLimitProof () { return RateLimitProof$3; },
-	get WakuMessage () { return WakuMessage$3; }
+    __proto__: null,
+    get RateLimitProof () { return RateLimitProof$4; },
+    get WakuMessage () { return WakuMessage$4; }
 });
 
 /* eslint-disable import/export */
@@ -2876,7 +2852,7 @@ var FilterRequest;
         return decodeMessage(buf, FilterRequest.codec());
     };
 })(FilterRequest || (FilterRequest = {}));
-var MessagePush;
+var MessagePush$1;
 (function (MessagePush) {
     let _codec;
     MessagePush.codec = () => {
@@ -2888,7 +2864,7 @@ var MessagePush;
                 if (obj.messages != null) {
                     for (const value of obj.messages) {
                         w.uint32(10);
-                        WakuMessage$2.codec().encode(value, w);
+                        WakuMessage$3.codec().encode(value, w);
                     }
                 }
                 if (opts.lengthDelimited !== false) {
@@ -2903,7 +2879,7 @@ var MessagePush;
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
                         case 1:
-                            obj.messages.push(WakuMessage$2.codec().decode(reader, reader.uint32()));
+                            obj.messages.push(WakuMessage$3.codec().decode(reader, reader.uint32()));
                             break;
                         default:
                             reader.skipType(tag & 7);
@@ -2921,7 +2897,7 @@ var MessagePush;
     MessagePush.decode = (buf) => {
         return decodeMessage(buf, MessagePush.codec());
     };
-})(MessagePush || (MessagePush = {}));
+})(MessagePush$1 || (MessagePush$1 = {}));
 var FilterRpc$1;
 (function (FilterRpc) {
     let _codec;
@@ -2941,7 +2917,7 @@ var FilterRpc$1;
                 }
                 if (obj.push != null) {
                     w.uint32(26);
-                    MessagePush.codec().encode(obj.push, w);
+                    MessagePush$1.codec().encode(obj.push, w);
                 }
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
@@ -2961,7 +2937,7 @@ var FilterRpc$1;
                             obj.request = FilterRequest.codec().decode(reader, reader.uint32());
                             break;
                         case 3:
-                            obj.push = MessagePush.codec().decode(reader, reader.uint32());
+                            obj.push = MessagePush$1.codec().decode(reader, reader.uint32());
                             break;
                         default:
                             reader.skipType(tag & 7);
@@ -2980,7 +2956,7 @@ var FilterRpc$1;
         return decodeMessage(buf, FilterRpc.codec());
     };
 })(FilterRpc$1 || (FilterRpc$1 = {}));
-var RateLimitProof$2;
+var RateLimitProof$3;
 (function (RateLimitProof) {
     let _codec;
     RateLimitProof.codec = () => {
@@ -3071,8 +3047,8 @@ var RateLimitProof$2;
     RateLimitProof.decode = (buf) => {
         return decodeMessage(buf, RateLimitProof.codec());
     };
-})(RateLimitProof$2 || (RateLimitProof$2 = {}));
-var WakuMessage$2;
+})(RateLimitProof$3 || (RateLimitProof$3 = {}));
+var WakuMessage$3;
 (function (WakuMessage) {
     let _codec;
     WakuMessage.codec = () => {
@@ -3103,7 +3079,7 @@ var WakuMessage$2;
                 }
                 if (obj.rateLimitProof != null) {
                     w.uint32(170);
-                    RateLimitProof$2.codec().encode(obj.rateLimitProof, w);
+                    RateLimitProof$3.codec().encode(obj.rateLimitProof, w);
                 }
                 if (obj.ephemeral != null) {
                     w.uint32(248);
@@ -3137,7 +3113,7 @@ var WakuMessage$2;
                             obj.meta = reader.bytes();
                             break;
                         case 21:
-                            obj.rateLimitProof = RateLimitProof$2.codec().decode(reader, reader.uint32());
+                            obj.rateLimitProof = RateLimitProof$3.codec().decode(reader, reader.uint32());
                             break;
                         case 31:
                             obj.ephemeral = reader.bool();
@@ -3158,7 +3134,7 @@ var WakuMessage$2;
     WakuMessage.decode = (buf) => {
         return decodeMessage(buf, WakuMessage.codec());
     };
-})(WakuMessage$2 || (WakuMessage$2 = {}));
+})(WakuMessage$3 || (WakuMessage$3 = {}));
 
 /* eslint-disable import/export */
 var TopicOnlyMessage;
@@ -3206,6 +3182,385 @@ var TopicOnlyMessage;
     };
 })(TopicOnlyMessage || (TopicOnlyMessage = {}));
 
+/* eslint-disable import/export */
+var FilterSubscribeRequest;
+(function (FilterSubscribeRequest) {
+    let FilterSubscribeType;
+    (function (FilterSubscribeType) {
+        FilterSubscribeType["SUBSCRIBER_PING"] = "SUBSCRIBER_PING";
+        FilterSubscribeType["SUBSCRIBE"] = "SUBSCRIBE";
+        FilterSubscribeType["UNSUBSCRIBE"] = "UNSUBSCRIBE";
+        FilterSubscribeType["UNSUBSCRIBE_ALL"] = "UNSUBSCRIBE_ALL";
+    })(FilterSubscribeType = FilterSubscribeRequest.FilterSubscribeType || (FilterSubscribeRequest.FilterSubscribeType = {}));
+    let __FilterSubscribeTypeValues;
+    (function (__FilterSubscribeTypeValues) {
+        __FilterSubscribeTypeValues[__FilterSubscribeTypeValues["SUBSCRIBER_PING"] = 0] = "SUBSCRIBER_PING";
+        __FilterSubscribeTypeValues[__FilterSubscribeTypeValues["SUBSCRIBE"] = 1] = "SUBSCRIBE";
+        __FilterSubscribeTypeValues[__FilterSubscribeTypeValues["UNSUBSCRIBE"] = 2] = "UNSUBSCRIBE";
+        __FilterSubscribeTypeValues[__FilterSubscribeTypeValues["UNSUBSCRIBE_ALL"] = 3] = "UNSUBSCRIBE_ALL";
+    })(__FilterSubscribeTypeValues || (__FilterSubscribeTypeValues = {}));
+    (function (FilterSubscribeType) {
+        FilterSubscribeType.codec = () => {
+            return enumeration(__FilterSubscribeTypeValues);
+        };
+    })(FilterSubscribeType = FilterSubscribeRequest.FilterSubscribeType || (FilterSubscribeRequest.FilterSubscribeType = {}));
+    let _codec;
+    FilterSubscribeRequest.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.requestId != null && obj.requestId !== "") {
+                    w.uint32(10);
+                    w.string(obj.requestId);
+                }
+                if (obj.filterSubscribeType != null &&
+                    __FilterSubscribeTypeValues[obj.filterSubscribeType] !== 0) {
+                    w.uint32(16);
+                    FilterSubscribeRequest.FilterSubscribeType.codec().encode(obj.filterSubscribeType, w);
+                }
+                if (obj.pubsubTopic != null) {
+                    w.uint32(82);
+                    w.string(obj.pubsubTopic);
+                }
+                if (obj.contentTopics != null) {
+                    for (const value of obj.contentTopics) {
+                        w.uint32(90);
+                        w.string(value);
+                    }
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    requestId: "",
+                    filterSubscribeType: FilterSubscribeType.SUBSCRIBER_PING,
+                    contentTopics: [],
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.requestId = reader.string();
+                            break;
+                        case 2:
+                            obj.filterSubscribeType =
+                                FilterSubscribeRequest.FilterSubscribeType.codec().decode(reader);
+                            break;
+                        case 10:
+                            obj.pubsubTopic = reader.string();
+                            break;
+                        case 11:
+                            obj.contentTopics.push(reader.string());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    FilterSubscribeRequest.encode = (obj) => {
+        return encodeMessage(obj, FilterSubscribeRequest.codec());
+    };
+    FilterSubscribeRequest.decode = (buf) => {
+        return decodeMessage(buf, FilterSubscribeRequest.codec());
+    };
+})(FilterSubscribeRequest || (FilterSubscribeRequest = {}));
+var FilterSubscribeResponse$1;
+(function (FilterSubscribeResponse) {
+    let _codec;
+    FilterSubscribeResponse.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.requestId != null && obj.requestId !== "") {
+                    w.uint32(10);
+                    w.string(obj.requestId);
+                }
+                if (obj.statusCode != null && obj.statusCode !== 0) {
+                    w.uint32(80);
+                    w.uint32(obj.statusCode);
+                }
+                if (obj.statusDesc != null) {
+                    w.uint32(90);
+                    w.string(obj.statusDesc);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    requestId: "",
+                    statusCode: 0,
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.requestId = reader.string();
+                            break;
+                        case 10:
+                            obj.statusCode = reader.uint32();
+                            break;
+                        case 11:
+                            obj.statusDesc = reader.string();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    FilterSubscribeResponse.encode = (obj) => {
+        return encodeMessage(obj, FilterSubscribeResponse.codec());
+    };
+    FilterSubscribeResponse.decode = (buf) => {
+        return decodeMessage(buf, FilterSubscribeResponse.codec());
+    };
+})(FilterSubscribeResponse$1 || (FilterSubscribeResponse$1 = {}));
+var MessagePush;
+(function (MessagePush) {
+    let _codec;
+    MessagePush.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.wakuMessage != null) {
+                    w.uint32(10);
+                    WakuMessage$2.codec().encode(obj.wakuMessage, w);
+                }
+                if (obj.pubsubTopic != null) {
+                    w.uint32(18);
+                    w.string(obj.pubsubTopic);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.wakuMessage = WakuMessage$2.codec().decode(reader, reader.uint32());
+                            break;
+                        case 2:
+                            obj.pubsubTopic = reader.string();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    MessagePush.encode = (obj) => {
+        return encodeMessage(obj, MessagePush.codec());
+    };
+    MessagePush.decode = (buf) => {
+        return decodeMessage(buf, MessagePush.codec());
+    };
+})(MessagePush || (MessagePush = {}));
+var RateLimitProof$2;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.proof != null && obj.proof.byteLength > 0) {
+                    w.uint32(10);
+                    w.bytes(obj.proof);
+                }
+                if (obj.merkleRoot != null && obj.merkleRoot.byteLength > 0) {
+                    w.uint32(18);
+                    w.bytes(obj.merkleRoot);
+                }
+                if (obj.epoch != null && obj.epoch.byteLength > 0) {
+                    w.uint32(26);
+                    w.bytes(obj.epoch);
+                }
+                if (obj.shareX != null && obj.shareX.byteLength > 0) {
+                    w.uint32(34);
+                    w.bytes(obj.shareX);
+                }
+                if (obj.shareY != null && obj.shareY.byteLength > 0) {
+                    w.uint32(42);
+                    w.bytes(obj.shareY);
+                }
+                if (obj.nullifier != null && obj.nullifier.byteLength > 0) {
+                    w.uint32(50);
+                    w.bytes(obj.nullifier);
+                }
+                if (obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0) {
+                    w.uint32(58);
+                    w.bytes(obj.rlnIdentifier);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    proof: new Uint8Array(0),
+                    merkleRoot: new Uint8Array(0),
+                    epoch: new Uint8Array(0),
+                    shareX: new Uint8Array(0),
+                    shareY: new Uint8Array(0),
+                    nullifier: new Uint8Array(0),
+                    rlnIdentifier: new Uint8Array(0),
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.proof = reader.bytes();
+                            break;
+                        case 2:
+                            obj.merkleRoot = reader.bytes();
+                            break;
+                        case 3:
+                            obj.epoch = reader.bytes();
+                            break;
+                        case 4:
+                            obj.shareX = reader.bytes();
+                            break;
+                        case 5:
+                            obj.shareY = reader.bytes();
+                            break;
+                        case 6:
+                            obj.nullifier = reader.bytes();
+                            break;
+                        case 7:
+                            obj.rlnIdentifier = reader.bytes();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    RateLimitProof.encode = (obj) => {
+        return encodeMessage(obj, RateLimitProof.codec());
+    };
+    RateLimitProof.decode = (buf) => {
+        return decodeMessage(buf, RateLimitProof.codec());
+    };
+})(RateLimitProof$2 || (RateLimitProof$2 = {}));
+var WakuMessage$2;
+(function (WakuMessage) {
+    let _codec;
+    WakuMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.payload != null && obj.payload.byteLength > 0) {
+                    w.uint32(10);
+                    w.bytes(obj.payload);
+                }
+                if (obj.contentTopic != null && obj.contentTopic !== "") {
+                    w.uint32(18);
+                    w.string(obj.contentTopic);
+                }
+                if (obj.version != null) {
+                    w.uint32(24);
+                    w.uint32(obj.version);
+                }
+                if (obj.timestamp != null) {
+                    w.uint32(80);
+                    w.sint64(obj.timestamp);
+                }
+                if (obj.meta != null) {
+                    w.uint32(90);
+                    w.bytes(obj.meta);
+                }
+                if (obj.rateLimitProof != null) {
+                    w.uint32(170);
+                    RateLimitProof$2.codec().encode(obj.rateLimitProof, w);
+                }
+                if (obj.ephemeral != null) {
+                    w.uint32(248);
+                    w.bool(obj.ephemeral);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    payload: new Uint8Array(0),
+                    contentTopic: "",
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.payload = reader.bytes();
+                            break;
+                        case 2:
+                            obj.contentTopic = reader.string();
+                            break;
+                        case 3:
+                            obj.version = reader.uint32();
+                            break;
+                        case 10:
+                            obj.timestamp = reader.sint64();
+                            break;
+                        case 11:
+                            obj.meta = reader.bytes();
+                            break;
+                        case 21:
+                            obj.rateLimitProof = RateLimitProof$2.codec().decode(reader, reader.uint32());
+                            break;
+                        case 31:
+                            obj.ephemeral = reader.bool();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    WakuMessage.encode = (obj) => {
+        return encodeMessage(obj, WakuMessage.codec());
+    };
+    WakuMessage.decode = (buf) => {
+        return decodeMessage(buf, WakuMessage.codec());
+    };
+})(WakuMessage$2 || (WakuMessage$2 = {}));
+
 /* eslint-disable import/export */
 var PushRequest;
 (function (PushRequest) {
@@ -4299,4 +4654,155 @@ var PeerExchangeRPC;
     };
 })(PeerExchangeRPC || (PeerExchangeRPC = {}));
 
-export { FilterRpc$1 as F, HistoryRpc$1 as H, PushRpc$1 as P, TopicOnlyMessage as T, WakuMessage$3 as W, PushResponse as a, aspromise as b, base64$1 as c, commonjsGlobal as d, eventemitter as e, float as f, getDefaultExportFromCjs as g, getAugmentedNamespace as h, inquire_1 as i, PagingInfo as j, HistoryResponse as k, message as m, pool_1 as p, utf8$2 as u };
+const log = debug("waku:message:version-0");
+const OneMillion = BigInt(1000000);
+const Version = 0;
+class DecodedMessage {
+    pubSubTopic;
+    proto;
+    constructor(pubSubTopic, proto) {
+        this.pubSubTopic = pubSubTopic;
+        this.proto = proto;
+    }
+    get ephemeral() {
+        return Boolean(this.proto.ephemeral);
+    }
+    get payload() {
+        return this.proto.payload;
+    }
+    get contentTopic() {
+        return this.proto.contentTopic;
+    }
+    get _rawTimestamp() {
+        return this.proto.timestamp;
+    }
+    get timestamp() {
+        // In the case we receive a value that is bigger than JS's max number,
+        // we catch the error and return undefined.
+        try {
+            if (this.proto.timestamp) {
+                // nanoseconds 10^-9 to milliseconds 10^-3
+                const timestamp = this.proto.timestamp / OneMillion;
+                return new Date(Number(timestamp));
+            }
+            return;
+        }
+        catch (e) {
+            return;
+        }
+    }
+    get meta() {
+        return this.proto.meta;
+    }
+    get version() {
+        // https://rfc.vac.dev/spec/14/
+        // > If omitted, the value SHOULD be interpreted as version 0.
+        return this.proto.version ?? 0;
+    }
+    get rateLimitProof() {
+        return this.proto.rateLimitProof;
+    }
+}
+class Encoder {
+    contentTopic;
+    ephemeral;
+    metaSetter;
+    constructor(contentTopic, ephemeral = false, metaSetter) {
+        this.contentTopic = contentTopic;
+        this.ephemeral = ephemeral;
+        this.metaSetter = metaSetter;
+        if (!contentTopic || contentTopic === "") {
+            throw new Error("Content topic must be specified");
+        }
+    }
+    async toWire(message$1) {
+        return WakuMessage$4.encode(await this.toProtoObj(message$1));
+    }
+    async toProtoObj(message) {
+        const timestamp = message.timestamp ?? new Date();
+        const protoMessage = {
+            payload: message.payload,
+            version: Version,
+            contentTopic: this.contentTopic,
+            timestamp: BigInt(timestamp.valueOf()) * OneMillion,
+            meta: undefined,
+            rateLimitProof: message.rateLimitProof,
+            ephemeral: this.ephemeral,
+        };
+        if (this.metaSetter) {
+            const meta = this.metaSetter(protoMessage);
+            return { ...protoMessage, meta };
+        }
+        return protoMessage;
+    }
+}
+/**
+ * Creates an encoder that encode messages without Waku level encryption or signature.
+ *
+ * An encoder is used to encode messages in the [`14/WAKU2-MESSAGE](https://rfc.vac.dev/spec/14/)
+ * format to be sent over the Waku network. The resulting encoder can then be
+ * pass to { @link @waku/interfaces.LightPush.push } or
+ * { @link @waku/interfaces.Relay.send } to automatically encode outgoing
+ * messages.
+ */
+function createEncoder({ contentTopic, ephemeral, metaSetter, }) {
+    return new Encoder(contentTopic, ephemeral, metaSetter);
+}
+class Decoder {
+    contentTopic;
+    constructor(contentTopic) {
+        this.contentTopic = contentTopic;
+        if (!contentTopic || contentTopic === "") {
+            throw new Error("Content topic must be specified");
+        }
+    }
+    fromWireToProtoObj(bytes) {
+        const protoMessage = WakuMessage$4.decode(bytes);
+        log("Message decoded", protoMessage);
+        return Promise.resolve({
+            payload: protoMessage.payload,
+            contentTopic: protoMessage.contentTopic,
+            version: protoMessage.version ?? undefined,
+            timestamp: protoMessage.timestamp ?? undefined,
+            meta: protoMessage.meta ?? undefined,
+            rateLimitProof: protoMessage.rateLimitProof ?? undefined,
+            ephemeral: protoMessage.ephemeral ?? false,
+        });
+    }
+    async fromProtoObj(pubSubTopic, proto) {
+        // https://rfc.vac.dev/spec/14/
+        // > If omitted, the value SHOULD be interpreted as version 0.
+        if (proto.version ?? 0 !== Version) {
+            log("Failed to decode due to incorrect version, expected:", Version, ", actual:", proto.version);
+            return Promise.resolve(undefined);
+        }
+        return new DecodedMessage(pubSubTopic, proto);
+    }
+}
+/**
+ * Creates a decoder that decode messages without Waku level encryption.
+ *
+ * A decoder is used to decode messages from the [14/WAKU2-MESSAGE](https://rfc.vac.dev/spec/14/)
+ * format when received from the Waku network. The resulting decoder can then be
+ * pass to { @link @waku/interfaces.Filter.subscribe } or
+ * { @link @waku/interfaces.Relay.subscribe } to automatically decode incoming
+ * messages.
+ *
+ * @param contentTopic The resulting decoder will only decode messages with this content topic.
+ */
+function createDecoder(contentTopic) {
+    return new Decoder(contentTopic);
+}
+
+var version_0 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    DecodedMessage: DecodedMessage,
+    Decoder: Decoder,
+    Encoder: Encoder,
+    Version: Version,
+    createDecoder: createDecoder,
+    createEncoder: createEncoder,
+    proto: message
+});
+
+export { DecodedMessage as D, Encoder as E, FilterRpc$1 as F, HistoryRpc$1 as H, MessagePush as M, PushRpc$1 as P, Version as V, FilterSubscribeRequest as a, FilterSubscribeResponse$1 as b, createEncoder as c, PushResponse as d, PagingInfo as e, HistoryResponse as f, createDecoder as g, Decoder as h, message as m, version_0 as v };