@leofcoin/peernet 0.15.2 → 0.16.0

package/dist/browser/peernet-swarm.js

@@ -1,841 +0,0 @@
-(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
-           debug(`peer:connected ${this}`)
-           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 (!this.#connection || message.to !== this.id || message.from !== this.#peerId) 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
-    if (this.#connection?.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, network = 'leofcoin:peach', stars = ['wss://peach.leofcoin.org']) {
-    this.id = id || Math.random().toString(36).slice(-12);
-    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(network, stars)
-  }
-
-  async _init(network, stars = []) {
-    this.network = network
-    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, network)
-        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.network)
-          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`)
-  }
-
-  async close() {
-
-    this.socketClient.unsubscribe('peer:joined', this.peerJoined)
-    this.socketClient.unsubscribe('peer:left', this.peerLeft)
-    this.socketClient.unsubscribe('star:left', this.starLeft)
-
-    const promises = [
-      Object.values(this.#connections).map(connection => connection.close()),
-      Object.values(this.#stars).map(connection => connection.close()),
-      this.socketClient.close()
-    ]
-    
-    return Promise.allSettled(promises)
-    
-  }
-
-}
-
-
-/***/ }),
-
-/***/ 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"};
-
-/***/ })
-
-}]);