@leofcoin/peernet 0.14.18 → 0.14.20

package/dist/browser/peernet-swarm.js

@@ -0,0 +1,829 @@
+(self["webpackChunk_leofcoin_peernet"] = self["webpackChunk_leofcoin_peernet"] || []).push([[629],{
+
+/***/ 96:
+/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "default": function() { return /* binding */ Client; }
+});
+
+;// CONCATENATED MODULE: ./node_modules/socket-request-client/dist/es/index.js
+/* provided dependency */ var process = __webpack_require__(155);
+/* socket-request-client version 1.6.3 */
+const ENVIRONMENT = {version: '1.6.3', production: true};
+
+class LittlePubSub {
+  constructor(verbose = true) {
+    this.subscribers = {};
+    this.verbose = verbose;
+  }
+  subscribe(event, handler, context) {
+    if (typeof context === 'undefined') {
+      context = handler;
+    }
+    this.subscribers[event] = this.subscribers[event] || { handlers: [], value: null};
+    this.subscribers[event].handlers.push(handler.bind(context));
+  }
+  unsubscribe(event, handler, context) {
+    if (typeof context === 'undefined') {
+      context = handler;
+    }
+    if (this.subscribers[event]) {
+      const index = this.subscribers[event].handlers.indexOf(handler.bind(context));
+      this.subscribers[event].handlers.splice(index);
+      if (this.subscribers[event].handlers.length === 0) delete this.subscribers[event];
+    }
+  }
+  publish(event, change) {
+    if (this.subscribers[event]) {
+      if (this.verbose || this.subscribers[event].value !== change) {
+        this.subscribers[event].value = change;
+        this.subscribers[event].handlers.forEach(handler => {
+          handler(change, this.subscribers[event].value);
+        });
+      }
+    }
+  }
+}
+
+var clientApi = _pubsub => {
+  const subscribe = (topic, cb) => {
+    _pubsub.subscribe(topic, cb);
+  };
+  const unsubscribe = (topic, cb) => {
+    _pubsub.unsubscribe(topic, cb);
+  };
+  const publish = (topic, value) => {
+    _pubsub.publish(topic, value);
+  };
+  const _connectionState = (state) => {
+    switch (state) {
+      case 0:
+        return 'connecting'
+      case 1:
+        return 'open'
+      case 2:
+        return 'closing'
+      case 3:
+        return 'closed'
+    }
+  };
+  const request = (client, request) => {
+    return new Promise((resolve, reject) => {
+      const state = _connectionState(client.readyState);
+      if (state !== 'open') return reject(`coudn't send request to ${client.id}, no open connection found.`)
+      request.id = Math.random().toString(36).slice(-12);
+      const handler = result => {
+        if (result && result.error) return reject(result.error)
+        resolve({result, id: request.id, handler});
+        unsubscribe(request.id, handler);
+      };
+      subscribe(request.id, handler);
+      send(client, request);
+    });
+  };
+  const send = async (client, request) => {
+    return client.send(JSON.stringify(request))
+  };
+  const pubsub = client => {
+    return {
+      publish: (topic = 'pubsub', value) => {
+        return send(client, {url: 'pubsub', params: { topic, value }})
+      },
+      subscribe: (topic = 'pubsub', cb) => {
+        subscribe(topic, cb);
+        return send(client, {url: 'pubsub', params: { topic, subscribe: true }})
+      },
+      unsubscribe: (topic = 'pubsub', cb) => {
+        unsubscribe(topic, cb);
+        return send(client, {url: 'pubsub', params: { topic, unsubscribe: true }})
+      },
+      subscribers: _pubsub.subscribers
+    }
+  };
+  const server = (client) => {
+    return {
+      uptime: async () => {
+        try {
+          const { result, id, handler } = await request(client, {url: 'uptime'});
+          unsubscribe(id, handler);
+          return result
+        } catch (e) {
+          throw e
+        }
+      },
+      ping: async () => {
+        try {
+          const now = new Date().getTime();
+          const { result, id, handler } = await request(client, {url: 'ping'});
+          unsubscribe(id, handler);
+          return (Number(result) - now)
+        } catch (e) {
+          throw e
+        }
+      }
+    }
+  };
+  const peernet = (client) => {
+    return {
+      join: async (params) => {
+        try {
+          params.join = true;
+          const requested = { url: 'peernet', params };
+          const { result, id, handler } = await request(client, requested);
+          unsubscribe(id, handler);
+          return result
+        } catch (e) {
+          throw e
+        }
+      },
+      leave: async (params) => {
+        try {
+          params.join = false;
+          const requested = { url: 'peernet', params };
+          const { result, id, handler } = await request(client, requested);
+          unsubscribe(id, handler);
+          return result
+        } catch (e) {
+          throw e
+        }
+      }
+    }
+  };
+  return { send, request, pubsub, server, subscribe, unsubscribe, publish, peernet }
+};
+
+if (!globalThis.PubSub) globalThis.PubSub = LittlePubSub;
+if (!globalThis.pubsub) globalThis.pubsub = new LittlePubSub({verbose: false});
+const socketRequestClient = (url, protocols = 'echo-protocol', options = { retry: false }) => {
+  const { retry } = options;
+  const api = clientApi(pubsub);
+  let tries = 0;
+  const onerror = error => {
+    if (pubsub.subscribers['error']) {
+      pubsub.publish('error', error);
+    } else {
+      console.error(error);
+    }
+  };
+  const onmessage = message => {
+    const {value, url, status, id} = JSON.parse(message.data.toString());
+    const publisher = id ? id : url;
+    if (status === 200) {
+      pubsub.publish(publisher, value);
+    } else {
+      pubsub.publish(publisher, {error: value});
+    }
+  };
+  const clientConnection = client => {
+    const startTime = new Date().getTime();
+    return {
+      client,
+      request: async req => {
+        const { result, id, handler } = await api.request(client, req);
+        pubsub.unsubscribe(id, handler);
+        return result
+      },
+      send: req => api.send(client, req),
+      subscribe: api.subscribe,
+      unsubscribe: api.unsubscribe,
+      subscribers: api.subscribers,
+      publish: api.publish,
+      pubsub: api.pubsub(client),
+      uptime: () => {
+        const now = new Date().getTime();
+        return (now - startTime)
+      },
+      peernet: api.peernet(client),
+      server: api.server(client),
+      close: exit => {
+        client.close();
+      }
+    }
+  };
+  return new Promise((resolve, reject) => {
+    const init = () => {
+      let ws;
+      if (typeof process === 'object' && !globalThis.WebSocket) {
+        ws = (__webpack_require__(840).w3cwebsocket);
+      } else {
+        ws = WebSocket;
+      }
+      const client = new ws(url, protocols);
+      client.onmessage = onmessage;
+      client.onerror = onerror;
+      client.onopen = () => {
+        tries = 0;
+        resolve(clientConnection(client));
+      };
+      client.onclose = message => {
+        tries++;
+        if (!retry) return reject(options)
+        if (tries > 5) {
+          console.log(`${protocols} Client Closed`);
+          console.error(`could not connect to - ${url}/`);
+          return resolve(clientConnection(client))
+        }
+        if (message.code === 1006) {
+          console.log('Retrying in 10 seconds');
+          setTimeout(() => {
+            return init();
+          }, retry);
+        }
+      };
+    };
+    return init();
+  });
+};
+
+
+
+// EXTERNAL MODULE: ./node_modules/@vandeurenglenn/debug/debug.js
+var debug_debug = __webpack_require__(307);
+;// CONCATENATED MODULE: ./node_modules/@leofcoin/peernet-swarm/src/client/peer.js
+
+
+class Peer {
+  #connection
+  #connected = false
+  #messageQue = []
+  #chunksQue = {}
+  #channel
+  #peerId
+  #channelName
+  #chunkSize = 16 * 1024 // 16384
+  #queRunning = false
+  #MAX_BUFFERED_AMOUNT = 16 * 1024 * 1024
+
+  get connection() {
+    return this.#connection
+  }
+
+  get connected() {
+    return this.#connected
+  }
+
+  get readyState() {
+    return this.#channel?.readyState
+  }
+
+/**
+ * @params {Object} options
+ * @params {string} options.channelName - this peerid : otherpeer id
+ */
+ constructor(options = {}) {
+    this._in = this._in.bind(this);
+    this.offerOptions = options.offerOptions
+    this.initiator = options.initiator
+    this.streams = options.streams
+    this.socketClient = options.socketClient
+    this.id = options.id
+    this.to = options.to
+    this.bw = {
+      up: 0,
+      down: 0
+    }
+
+    this.#channelName = options.channelName
+
+    this.#peerId = options.peerId
+    this.options = options
+    return this.#init()
+   }
+
+   get peerId() {
+     return this.#peerId
+   }
+
+   set socketClient(value) {
+     // this.socketClient?.pubsub.unsubscribe('signal', this._in)
+     this._socketClient = value
+     this._socketClient.pubsub.subscribe('signal', this._in)
+   }
+
+   get socketClient() {
+     return this._socketClient
+   }
+
+   splitMessage(message) {
+     const chunks = []
+     message = pako.deflate(message)
+     const size = message.byteLength || message.length
+     let offset = 0
+     return new Promise((resolve, reject) => {
+       const splitMessage = () => {
+         const chunk = message.slice(offset, offset + this.#chunkSize > size ? size : offset + this.#chunkSize)
+         offset += this.#chunkSize
+         chunks.push(chunk)
+         if (offset < size) return splitMessage()
+         else resolve({chunks, size})
+       }
+
+       splitMessage()
+     })
+   }
+
+   async #runQue() {
+     this.#queRunning = true
+     if (this.#messageQue.length > 0 && this.#channel?.bufferedAmount + this.#messageQue[0]?.length < this.#MAX_BUFFERED_AMOUNT) {
+       const message = this.#messageQue.shift()
+
+       switch (this.#channel?.readyState) {
+         case 'open':
+          await this.#channel.send(message);
+          if (this.#messageQue.length > 0) return this.#runQue()
+          else this.#queRunning = false
+         break;
+         case 'closed':
+         case 'closing':
+          this.#messageQue = []
+          this.#queRunning = false
+          debug('channel already closed, this usually means a bad implementation, try checking the readyState or check if the peer is connected before sending');
+         break;
+         case undefined:
+          this.#messageQue = []
+          this.#queRunning = false
+          debug(`trying to send before a channel is created`);
+         break;
+       }
+
+
+     } else {
+       return setTimeout(() => this.#runQue(), 50)
+     }
+   }
+
+   #trySend({ size, id, chunks }) {
+     let offset = 0
+
+     for (const chunk of chunks) {
+       const start = offset
+       const end = offset + chunk.length
+
+       const message = new TextEncoder().encode(JSON.stringify({ size, id, chunk, start, end }));
+       this.#messageQue.push(message)
+     }
+
+     if (!this.queRunning) return this.#runQue()
+   }
+
+   async send(message, id) {
+     const { chunks, size } = await this.splitMessage(message)
+     return this.#trySend({ size, id, chunks })
+   }
+
+   request(data) {
+    return new Promise((resolve, reject) => {
+      const id = Math.random().toString(36).slice(-12)
+
+      const _onData = message => {
+        if (message.id === id) {
+          resolve(message.data)
+          pubsub.unsubscribe(`peer:data`, _onData)
+        }
+      }
+
+      pubsub.subscribe(`peer:data`, _onData)
+
+      // cleanup subscriptions
+      // setTimeout(() => {
+      //   pubsub.unsubscribe(`peer:data-request-${id}`, _onData)
+      // }, 5000);
+
+      this.send(data, id)
+    })
+  }
+
+   async #init() {
+     try {
+
+       if (!globalThis.pako) {
+         const importee = await __webpack_require__.e(/* import() | pako */ 682).then(__webpack_require__.bind(__webpack_require__, 885))
+         globalThis.pako = importee.default
+       }
+
+       const iceServers = [{
+         urls: 'stun:stun.l.google.com:19302' // Google's public STUN server
+       }, {
+         urls: "stun:openrelay.metered.ca:80",
+       }, {
+        urls: "turn:openrelay.metered.ca:443",
+        username: "openrelayproject",
+        credential: "openrelayproject",
+       }, {
+        urls: "turn:openrelay.metered.ca:443?transport=tcp",
+        username: "openrelayproject",
+        credential: "openrelayproject",
+       }]
+
+       this.#connection = new wrtc.RTCPeerConnection({iceServers});
+
+       this.#connection.onicecandidate = ({ candidate }) => {
+         if (candidate) {
+           this.address = candidate.address
+           this.port = candidate.port
+           this.protocol = candidate.protocol
+           this.ipFamily = this.address.includes('::') ? 'ipv6': 'ipv4'
+           this._sendMessage({candidate})
+         }
+       }
+       // if (this.initiator) this.#connection.onnegotiationneeded = () => {
+         // console.log('create offer');
+       this.#connection.ondatachannel = (message) => {
+         message.channel.onopen = () => {
+           this.#connected = true
+           pubsub.publish('peer:connected', this)
+         }
+         message.channel.onclose = () => this.close.bind(this)
+
+         message.channel.onmessage = (message) => {
+           this._handleMessage(this.id, message)
+         }
+         this.#channel = message.channel
+       }
+      if (this.initiator) {
+
+        this.#channel = this.#connection.createDataChannel('messageChannel')
+        this.#channel.onopen = () => {
+          this.#connected = true
+          pubsub.publish('peer:connected', this)
+          // this.#channel.send('hi')
+        }
+        this.#channel.onclose = () => this.close.bind(this)
+
+        this.#channel.onmessage = (message) => {
+          this._handleMessage(this.peerId, message)
+        }
+
+       const offer = await this.#connection.createOffer()
+       await this.#connection.setLocalDescription(offer)
+
+       this._sendMessage({'sdp': this.#connection.localDescription})
+     }
+     } catch (e) {
+       console.log(e);
+     }
+
+     return this
+   }
+
+   _handleMessage(peerId, message) {
+     debug(`incoming message from ${peerId}`)
+
+     message = JSON.parse(new TextDecoder().decode(message.data))
+     // allow sharding (multiple peers share data)
+     pubsub.publish('peernet:shard', message)
+     const { id } = message
+
+     if (!this.#chunksQue[id]) this.#chunksQue[id] = []
+
+     if (message.size > this.#chunksQue[id].length || message.size === this.#chunksQue[id].length) {
+       for (const value of Object.values(message.chunk)) {
+         this.#chunksQue[id].push(value)
+       }
+     }
+
+     if (message.size === this.#chunksQue[id].length) {
+       let data = new Uint8Array(Object.values(this.#chunksQue[id]))
+       delete this.#chunksQue[id]
+       data = pako.inflate(data)
+       pubsub.publish('peer:data', { id, data, from: this.peerId })
+     }
+     this.bw.down += message.byteLength || message.length
+   }
+
+   _sendMessage(message) {
+     this.socketClient.send({url: 'signal', params: {
+       to: this.to,
+       from: this.id,
+       channelName: this.options.channelName,
+       ...message
+     }})
+   }
+
+   async _in(message, data) {
+    // message = JSON.parse(message);
+    if (message.to !== this.id) return
+    // if (data.videocall) return this._startStream(true, false); // start video and audio stream
+    // if (data.call) return this._startStream(true, true); // start audio stream
+    const signalinState = this.#connection.signalinState
+    if (signalinState === 'stable' && this.#connection.remoteDescription !== null && this.#connection.localDescription !== null) return
+
+    if (message.candidate) {
+      debug(`incoming candidate ${this.#channelName}`)
+      // debug(message.candidate.candidate)
+      this.remoteAddress = message.candidate.address
+      this.remotePort = message.candidate.port
+      this.remoteProtocol = message.candidate.protocol
+      this.remoteIpFamily = this.remoteAddress?.includes('::') ? 'ipv6': 'ipv4'      
+      return this.#connection.addIceCandidate(new wrtc.RTCIceCandidate(message.candidate));
+    }
+    try {
+      if (message.sdp) {
+        if (message.sdp.type === 'offer') {
+          debug(`incoming offer ${this.#channelName}`)
+          await this.#connection.setRemoteDescription(new wrtc.RTCSessionDescription(message.sdp))
+          const answer = await this.#connection.createAnswer();
+          await this.#connection.setLocalDescription(answer)
+          this._sendMessage({'sdp': this.#connection.localDescription})
+        }
+        if (message.sdp.type === 'answer') {
+          debug(`incoming answer ${this.#channelName}`)
+          await this.#connection.setRemoteDescription(new wrtc.RTCSessionDescription(message.sdp))
+        }
+     }
+    } catch (e) {
+      console.log(e);
+    }
+ }
+
+ close() {
+   debug(`closing ${this.peerId}`)
+   this.#connected = false
+   this.#channel?.close()
+   this.#connection?.close()
+
+   this.socketClient.pubsub.unsubscribe('signal', this._in)
+ }
+}
+
+;// CONCATENATED MODULE: ./node_modules/@leofcoin/peernet-swarm/src/client/client.js
+
+
+
+
+class Client {
+  #peerConnection
+  #connections = {}
+  #stars = {}
+
+  get connections() {
+    return { ...this.#connections }
+  }
+
+  get peers() {
+    return Object.entries(this.#connections)
+  }
+
+  constructor(id, identifiers = ['peernet-v0.1.0'], stars = []) {
+    this.id = id || Math.random().toString(36).slice(-12);
+    if (!Array.isArray(identifiers)) identifiers = [identifiers]
+    this.peerJoined = this.peerJoined.bind(this)
+    this.peerLeft = this.peerLeft.bind(this)
+    this.starLeft = this.starLeft.bind(this)
+    this.starJoined = this.starJoined.bind(this)
+
+    this._init(identifiers, stars)
+  }
+
+  async _init(identifiers, stars = []) {
+    if (stars.length === 0) {
+      stars.push('wss://star.leofcoin.org')
+    }
+    this.identifiers = identifiers
+    this.starsConfig = stars
+    // reconnectJob()
+
+    if (!globalThis.RTCPeerConnection) globalThis.wrtc = await __webpack_require__.e(/* import() | wrtc */ 228).then(__webpack_require__.t.bind(__webpack_require__, 347, 19))
+    else globalThis.wrtc = {
+      RTCPeerConnection,
+      RTCSessionDescription,
+      RTCIceCandidate
+    }
+
+    for (const star of stars) {
+      try {
+        this.socketClient = await socketRequestClient(star, identifiers[0])
+        const id = await this.socketClient.request({url: 'id', params: {from: this.id}})
+        this.socketClient.peerId = id
+        this.#stars[id] = this.socketClient
+      } catch (e) {
+        if (stars.indexOf(star) === stars.length -1 && !this.socketClient) throw new Error(`No star available to connect`);
+      }
+    }
+    const peers = await this.socketClient.peernet.join({id: this.id})
+    for (const id of peers) {
+      if (id !== this.id && !this.#connections[id]) this.#connections[id] = await new Peer({channelName: `${id}:${this.id}`, socketClient: this.socketClient, id: this.id, to: id, peerId: id})
+    }
+    this.setupListeners()
+  }
+
+  setupListeners() {
+    this.socketClient.subscribe('peer:joined', this.peerJoined)
+    this.socketClient.subscribe('peer:left', this.peerLeft)
+    this.socketClient.subscribe('star:left', this.starLeft)
+  }
+
+  starJoined(id) {
+    if (this.#stars[id]) {
+      this.#stars[id].close()
+      delete this.#stars[id]
+    }
+    console.log(`star ${id} joined`);
+  }
+
+  async starLeft(id) {
+    if (this.#stars[id]) {
+      this.#stars[id].close()
+      delete this.#stars[id]
+    }
+    if (this.socketClient?.peerId === id) {
+
+      this.socketClient.unsubscribe('peer:joined', this.peerJoined)
+      this.socketClient.unsubscribe('peer:left', this.peerLeft)
+      this.socketClient.unsubscribe('star:left', this.starLeft)
+      this.socketClient.close()
+      this.socketClient = undefined
+
+      for (const star of this.starsConfig) {
+        try {
+          this.socketClient = await socketRequestClient(star, this.identifiers[0])
+          if (!this.socketClient?.client?._connection.connected) return
+          const id = await this.socketClient.request({url: 'id', params: {from: this.id}})
+          this.#stars[id] = this.socketClient
+
+          this.socketClient.peerId = id
+
+          const peers = await this.socketClient.peernet.join({id: this.id})
+          this.setupListeners()
+          for (const id of peers) {
+            if (id !== this.id) {
+              // close connection
+              if (this.#connections[id]) {
+                if (this.#connections[id].connected) await this.#connections[id].close()
+                delete this.#connections[id]
+              }
+              // reconnect
+              if (id !== this.id) this.#connections[id] = await new Peer({channelName: `${id}:${this.id}`, socketClient: this.socketClient, id: this.id, to: id, peerId: id})
+            }
+
+          }
+        } catch (e) {
+          console.log(e);
+          if (this.starsConfig.indexOf(star) === this.starsConfig.length -1 && !this.socketClient) throw new Error(`No star available to connect`);
+        }
+      }
+    }
+    debug(`star ${id} left`);
+  }
+
+  peerLeft(peer) {
+    const id = peer.peerId || peer
+    if (this.#connections[id]) {
+      this.#connections[id].close()
+      delete this.#connections[id]
+    }
+    debug(`peer ${id} left`)
+  }
+
+  async peerJoined(peer, signal) {
+    const id = peer.peerId || peer
+    if (this.#connections[id]) {
+      if (this.#connections[id].connected) this.#connections[id].close()
+      delete this.#connections[id]
+    }
+    // RTCPeerConnection
+    this.#connections[id] = await new Peer({initiator: true, channelName: `${this.id}:${id}`, socketClient: this.socketClient, id: this.id, to: id, peerId: id})
+    debug(`peer ${id} joined`)
+  }
+
+  removePeer(peer) {
+    const id = peer.peerId || peer
+    if (this.#connections[id]) {
+      this.#connections[id].connected && this.#connections[id].close()
+      delete this.#connections[id]
+    }
+    debug(`peer ${id} removed`)
+  }
+
+
+}
+
+
+/***/ }),
+
+/***/ 284:
+/***/ (function(module) {
+
+var naiveFallback = function () {
+	if (typeof self === "object" && self) return self;
+	if (typeof window === "object" && window) return window;
+	throw new Error("Unable to resolve global `this`");
+};
+
+module.exports = (function () {
+	if (this) return this;
+
+	// Unexpected strict mode (may happen if e.g. bundled into ESM module)
+
+	// Fallback to standard globalThis if available
+	if (typeof globalThis === "object" && globalThis) return globalThis;
+
+	// Thanks @mathiasbynens -> https://mathiasbynens.be/notes/globalthis
+	// In all ES5+ engines global object inherits from Object.prototype
+	// (if you approached one that doesn't please report)
+	try {
+		Object.defineProperty(Object.prototype, "__global__", {
+			get: function () { return this; },
+			configurable: true
+		});
+	} catch (error) {
+		// Unfortunate case of updates to Object.prototype being restricted
+		// via preventExtensions, seal or freeze
+		return naiveFallback();
+	}
+	try {
+		// Safari case (window.__global__ works, but __global__ does not)
+		if (!__global__) return naiveFallback();
+		return __global__;
+	} finally {
+		delete Object.prototype.__global__;
+	}
+})();
+
+
+/***/ }),
+
+/***/ 840:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+var _globalThis;
+if (typeof globalThis === 'object') {
+	_globalThis = globalThis;
+} else {
+	try {
+		_globalThis = __webpack_require__(284);
+	} catch (error) {
+	} finally {
+		if (!_globalThis && typeof window !== 'undefined') { _globalThis = window; }
+		if (!_globalThis) { throw new Error('Could not determine global this'); }
+	}
+}
+
+var NativeWebSocket = _globalThis.WebSocket || _globalThis.MozWebSocket;
+var websocket_version = __webpack_require__(387);
+
+
+/**
+ * Expose a W3C WebSocket class with just one or two arguments.
+ */
+function W3CWebSocket(uri, protocols) {
+	var native_instance;
+
+	if (protocols) {
+		native_instance = new NativeWebSocket(uri, protocols);
+	}
+	else {
+		native_instance = new NativeWebSocket(uri);
+	}
+
+	/**
+	 * 'native_instance' is an instance of nativeWebSocket (the browser's WebSocket
+	 * class). Since it is an Object it will be returned as it is when creating an
+	 * instance of W3CWebSocket via 'new W3CWebSocket()'.
+	 *
+	 * ECMAScript 5: http://bclary.com/2004/11/07/#a-13.2.2
+	 */
+	return native_instance;
+}
+if (NativeWebSocket) {
+	['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'].forEach(function(prop) {
+		Object.defineProperty(W3CWebSocket, prop, {
+			get: function() { return NativeWebSocket[prop]; }
+		});
+	});
+}
+
+/**
+ * Module exports.
+ */
+module.exports = {
+    'w3cwebsocket' : NativeWebSocket ? W3CWebSocket : null,
+    'version'      : websocket_version
+};
+
+
+/***/ }),
+
+/***/ 387:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+module.exports = __webpack_require__(794).version;
+
+
+/***/ }),
+
+/***/ 794:
+/***/ (function(module) {
+
+"use strict";
+module.exports = {"version":"1.0.34"};
+
+/***/ })
+
+}]);