runet-censorship-bypass/extensions/webRequest/install.js

'use strict';

function installRkn(cb) {

  var RKN = {

    csvMirrors: [
      'https://raw.githubusercontent.com/zapret-info/z-i/master/dump.csv',
      'http://sourceforge.net/p/z-i/code-0/HEAD/tree/dump.csv?format=raw',
      'https://www.assembla.com/spaces/z-i/git/source/master/dump.csv?_format=raw'
    ],

    antizapret: {
      ignorehostsMirror: 'https://bitbucket.org/ValdikSS/antizapret/raw/master/ignorehosts.txt',
      proxyHost: 'proxy.antizapret.prostovpn.org',
      proxyIp: '195.154.110.37',

      update: function(cb) {
        var cb = cb || (() => {});
        return this.updateIgnorehosts(
          () => this.updateIp(cb)
        );
      },
      updateIp: function(cb) {
        var cb = cb || (() => {});
        var req = new XMLHttpRequest();
        var ifAsync = true;
    	  req.open('GET', 'http://www.dns-lg.com/google1/'+this.proxyHost+'/A', ifAsync);
    	  req.onload = event => {
          if (req.status === 404)
            return cb(req.status);

          var res = JSON.parse(req.responseText);
          this.proxyIp = res.answer[0].rdata;
          window.PROXY_IP = this.proxyIp;
          return cb(null, this);
        };
        req.onerror = cb;
    	  req.send(null);
      },
      updateIgnorehosts: function(cb) {
        var cb = cb || (() => {});
        var req = new XMLHttpRequest();
        var ifAsync = true;
    	  req.open('GET', this.ignorehostsMirror, ifAsync);
    	  req.onload = event => {
          if (req.status === 404)
            return cb(req.status);
          this.ignorehosts = req.responseText.split(/\r?\n/g);
          return cb(null, this.ignorehosts);
        };
        req.onerror = cb;
    	  req.send(null);
      }
    },

    lastUpdate: (new Date(0)).toString(),
    updatePeriodInMinutes: 7*60,
    ifEnabled: false,

    updateIcon: function(cb) {
      var cb = cb || (() => {});
      return chrome.browserAction.setIcon(
        { path: this.ifEnabled ? './assets/icons/rkn.png' : './assets/icons/rkn-disabled.png' },
        cb
      );
    },

    reset: function(cb) {
      var cb = cb || (() => {});
      return chrome.storage.local.clear( () => chrome.proxy.settings.clear({}, cb) );
    },

    disable: function(cb) {
      var cb = cb || (() => {});

      this.checkForUpdates( (err, res) => {
        if (err) return cb(err);
        this.ifEnabled = false;
        return this.persistToStorage( () => this.updateIcon(cb) );
      });

    },

    enable: function(cb) {
	  this.reset(() => {
        this.ifEnabled = true;
        return this.persistToStorage( () => this.updateIcon(cb) );
      });
    },

    switch: function(cb) {
      var cb = cb || (() => {});
      return this.ifEnabled ? this.disable(cb) : this.enable(cb);
    },

    persistToStorage: function(cb) {
      var cb = cb || (() => {});
      var storage = {};
      for(var key of Object.keys(this))
        storage[key] = JSON.stringify(this[key]);
      chrome.storage.local.set(storage, cb);
    },
    syncWithStorage: function(cb) {
      var cb = cb || (() => {});
      chrome.storage.local.get(
        null,
        storage => {
          if (!Object.keys(storage).length)
            return this.persistToStorage(cb);

          for(var key of Object.keys(storage))
            this[key] = JSON.parse( storage[key] );

          return cb(this);
        }
      );
    },

    install: function(cb) {
		  this.reset(
		    () => this.disable(cb)
		  );
    },

    rescheduleUpdates: function(period) {
      var checkNewBlocked = 'Check for new blocked sites';
      var period = period || this.updatePeriodInMinutes;
      chrome.alarms.clearAll( ifWasCleared => {

        chrome.alarms.create(checkNewBlocked, {
          delayInMinutes: period
        });

        chrome.alarms.onAlarm.addListener(
          alarm => {
            if (alarm.name === checkNewBlocked)
              this.checkForUpdates();
          });

      });
    },
    checkForUpdates: function(url, cb) {

      if (!url || !cb)
        return this._useTheMirrorsLuke(this.checkForUpdates, url, cb);

  	  var req = new XMLHttpRequest();
      var ifAsync = true;
  	  req.open('HEAD', url, ifAsync);
  	  req.onload = event => {
        if (req.status === 404)
          return cb(req.status);

        var date = Date.parse(req.getResponseHeader('Date'));
        if (date > Date.parse(this.lastUpdate))
          return this.update(url, cb);

        return cb(null);
      };
      req.onerror = cb;
  	  req.send(null);
    },
    update: function(url, cb) {

      if (!url || !cb)
        return this._useTheMirrorsLuke(this.update, url, cb);

  	  var req = new XMLHttpRequest();
      var ifAsync = true;
  	  req.open('GET', url, ifAsync);
  	  req.onload =
        () => this.antizapret.update(
          (err, res) => {
            if (err)
              return cb(err);
            this.lastUpdate = (new Date()).toString();
            this.applyCsv(req.responseText, this.antizapret.ignorehosts);
            this.persistToStorage();
            this.rescheduleUpdates();
            return cb(null);
          }
        );
      req.onerror = cb;
  	  req.send(null);
    },
    applyCsv: function(csv, ignorehosts) {

      var ignorehosts = ignorehosts || []; // Hosts from csv that must be ignored.

      var columnsSep = ';';
      var valuesSep = /\s*\|\s*/g;

      var ips = [], hosts = [], urls = [], orgs = [], date, reason;

      var lines = csv.trim().split(/\r?\n/g).slice(1);
      lines.forEach( function(line) {
        var values = line.split( columnsSep );
        var newIps    = values.shift().split( valuesSep );
        var newHosts  = values.shift().split( valuesSep ).map( punycode.toASCII ).map( h => h.replace(/\.+$/g) ).filter( h => ignorehosts.indexOf(h) === -1 );
        var newUrls   = values.shift().split( valuesSep );
        var newOrgs   = values.shift().split( valuesSep );
        var newDate   = values.pop();
        var newReason = values.join(';');
        ips.push.apply(ips, newIps);
        hosts.push.apply(hosts, newHosts);
      });

      function toHash(arr) {
        var res = {};
        arr.forEach( el => res[el] = true );
        return res;
      }

      var ipsHash   = toHash(ips);
      var hostsHash = toHash(hosts);

      // Remove duplicates and sort.
      var ips   = Object.keys(ipsHash).sort();
      var hosts = Object.keys(hostsHash).sort();

      // REVERSED HOSTS SWITCH

      function populateTrie(trie, doms) {

        var dom = doms.pop();
        if (!doms.length || doms.length === 1 && doms[0] === 'www') {
          trie[''] = trie[''] || [];
          trie[''].push( dom )
          return trie;
        }

        if (trie[''] && trie[''].indexOf(dom) !== -1) // Subdomain of a blocked domain.
        return trie;

        trie[dom] = trie[dom] || {};

        populateTrie( trie[dom], doms );
        return trie;

      }

      var trie = {};
      hosts.forEach( function(host) {
        var doms = host.replace(/\.+$/).split('.');
        populateTrie(trie, doms);
      });

      function trieToSwitch(trie, indent) {

        var _indent = indent || '';
        var indent = _indent + '  ';
        var keys = Object.keys(trie).sort();

        if (!trie[''] && keys.length === 1) {
          var key = keys[0];
          return _indent + 'if (pop() === "'+key+'")\n'+ trieToSwitch(trie[key], indent);
        }

        var cases = '';
        if (trie['']) {
          var values = trie[''].sort();

          if (values.length === 1 && keys.length === 1)
            return _indent + 'return pop() === "'+values[0]+'" && !doms.length;\n';

          cases =
            values.filter( function(v) { return v; } ).map( function(val) { return indent +'case "'+val+'":\n'; } ).join('') + indent +'  return !domsLeft;\n';

          delete trie[''];
          keys = Object.keys(trie).sort();
        }

        cases += keys.filter( function(k) { return k; } ).map(
          function(key) {
            var tmp = trieToSwitch( trie[key], indent+'  ');
            if (!/^\s*return/.test(tmp))
              tmp += indent+'  break;\n';
            return indent +'case "'+key+'":\n' +tmp;
          }).join('');

        return ''
        + _indent +'switch( pop() ) {\n'
        + cases
        + _indent +'}\n';
      }

      var ifBlocked = function() {
        var doms = host.replace(/\.+$/).toLowerCase().split('.');
        var domsLeft = doms.length;
        var pop = () => domsLeft ? doms[--domsLeft] : undefined ;

        "{SWITCH}"
        return false;
      }

      this.ifBlockedFunAsStr = ifBlocked.toString().replace('"{SWITCH}"', trieToSwitch(trie, '  '));

	  var proxy = 'HTTPS proxy.antizapret.prostovpn.org:3143; PROXY proxy.antizapret.prostovpn.org:3128';
	  var pac = 'function FindProxyForURL(url, host) { return ('+this.ifBlockedFunAsStr+')() ? "'+proxy+'" : "DIRECT"; }';
	  this.applyPac(pac);
    return this.ifBlockedFunAsStr;
  },
	applyPac: function(pac, cb) {
	  return chrome.proxy.settings.clear( {}, () => {
      var config = {
        mode: 'pac_script',
        pacScript: {
          mandatory: false,
          data: pac
        }
      };
      chrome.proxy.settings.set( {value: config}, cb || (() => {}) );
	  });
	},
    _useTheMirrorsLuke: function(method, url, cb) {

      if (!cb)
        if (typeof url === 'function') {
          cb = url;
          url = undefined;
        } else cb = () => {};

      var it;
      if (typeof url === 'string')
        it = [url][Symbol.iterator]();
      else
        it = url || this.csvMirrors[Symbol.iterator]();

      var self = this;
      function cbb(err, res) {
        var cur = it.next();
        if (cur.done || !err)
          return cb(err, res);

        method.call(self, cur.value, cbb);
      }

      var url = it.next().value;
      return method.call(this, url, cbb);
    }
  };

  RKN.install(cb);

  //==============PUNYCODE====================================

  /*! https://mths.be/punycode v1.3.2 by @mathias */
  ;(function(root) {

  	/** Detect free variables */
  	var freeExports = typeof exports == 'object' && exports &&
  		!exports.nodeType && exports;
  	var freeModule = typeof module == 'object' && module &&
  		!module.nodeType && module;
  	var freeGlobal = typeof global == 'object' && global;
  	if (
  		freeGlobal.global === freeGlobal ||
  		freeGlobal.window === freeGlobal ||
  		freeGlobal.self === freeGlobal
  	) {
  		root = freeGlobal;
  	}

  	/**
  	 * The `punycode` object.
  	 * @name punycode
  	 * @type Object
  	 */
  	var punycode,

  	/** Highest positive signed 32-bit float value */
  	maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1

  	/** Bootstring parameters */
  	base = 36,
  	tMin = 1,
  	tMax = 26,
  	skew = 38,
  	damp = 700,
  	initialBias = 72,
  	initialN = 128, // 0x80
  	delimiter = '-', // '\x2D'

  	/** Regular expressions */
  	regexPunycode = /^xn--/,
  	regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
  	regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators

  	/** Error messages */
  	errors = {
  		'overflow': 'Overflow: input needs wider integers to process',
  		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
  		'invalid-input': 'Invalid input'
  	},

  	/** Convenience shortcuts */
  	baseMinusTMin = base - tMin,
  	floor = Math.floor,
  	stringFromCharCode = String.fromCharCode,

  	/** Temporary variable */
  	key;

  	/*--------------------------------------------------------------------------*/

  	/**
  	 * A generic error utility function.
  	 * @private
  	 * @param {String} type The error type.
  	 * @returns {Error} Throws a `RangeError` with the applicable error message.
  	 */
  	function error(type) {
  		throw new RangeError(errors[type]);
  	}

  	/**
  	 * A generic `Array#map` utility function.
  	 * @private
  	 * @param {Array} array The array to iterate over.
  	 * @param {Function} callback The function that gets called for every array
  	 * item.
  	 * @returns {Array} A new array of values returned by the callback function.
  	 */
  	function map(array, fn) {
  		var length = array.length;
  		var result = [];
  		while (length--) {
  			result[length] = fn(array[length]);
  		}
  		return result;
  	}

  	/**
  	 * A simple `Array#map`-like wrapper to work with domain name strings or email
  	 * addresses.
  	 * @private
  	 * @param {String} domain The domain name or email address.
  	 * @param {Function} callback The function that gets called for every
  	 * character.
  	 * @returns {Array} A new string of characters returned by the callback
  	 * function.
  	 */
  	function mapDomain(string, fn) {
  		var parts = string.split('@');
  		var result = '';
  		if (parts.length > 1) {
  			// In email addresses, only the domain name should be punycoded. Leave
  			// the local part (i.e. everything up to `@`) intact.
  			result = parts[0] + '@';
  			string = parts[1];
  		}
  		// Avoid `split(regex)` for IE8 compatibility. See #17.
  		string = string.replace(regexSeparators, '\x2E');
  		var labels = string.split('.');
  		var encoded = map(labels, fn).join('.');
  		return result + encoded;
  	}

  	/**
  	 * Creates an array containing the numeric code points of each Unicode
  	 * character in the string. While JavaScript uses UCS-2 internally,
  	 * this function will convert a pair of surrogate halves (each of which
  	 * UCS-2 exposes as separate characters) into a single code point,
  	 * matching UTF-16.
  	 * @see `punycode.ucs2.encode`
  	 * @see <https://mathiasbynens.be/notes/javascript-encoding>
  	 * @memberOf punycode.ucs2
  	 * @name decode
  	 * @param {String} string The Unicode input string (UCS-2).
  	 * @returns {Array} The new array of code points.
  	 */
  	function ucs2decode(string) {
  		var output = [],
  		    counter = 0,
  		    length = string.length,
  		    value,
  		    extra;
  		while (counter < length) {
  			value = string.charCodeAt(counter++);
  			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
  				// high surrogate, and there is a next character
  				extra = string.charCodeAt(counter++);
  				if ((extra & 0xFC00) == 0xDC00) { // low surrogate
  					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
  				} else {
  					// unmatched surrogate; only append this code unit, in case the next
  					// code unit is the high surrogate of a surrogate pair
  					output.push(value);
  					counter--;
  				}
  			} else {
  				output.push(value);
  			}
  		}
  		return output;
  	}

  	/**
  	 * Creates a string based on an array of numeric code points.
  	 * @see `punycode.ucs2.decode`
  	 * @memberOf punycode.ucs2
  	 * @name encode
  	 * @param {Array} codePoints The array of numeric code points.
  	 * @returns {String} The new Unicode string (UCS-2).
  	 */
  	function ucs2encode(array) {
  		return map(array, function(value) {
  			var output = '';
  			if (value > 0xFFFF) {
  				value -= 0x10000;
  				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
  				value = 0xDC00 | value & 0x3FF;
  			}
  			output += stringFromCharCode(value);
  			return output;
  		}).join('');
  	}

  	/**
  	 * Converts a basic code point into a digit/integer.
  	 * @see `digitToBasic()`
  	 * @private
  	 * @param {Number} codePoint The basic numeric code point value.
  	 * @returns {Number} The numeric value of a basic code point (for use in
  	 * representing integers) in the range `0` to `base - 1`, or `base` if
  	 * the code point does not represent a value.
  	 */
  	function basicToDigit(codePoint) {
  		if (codePoint - 48 < 10) {
  			return codePoint - 22;
  		}
  		if (codePoint - 65 < 26) {
  			return codePoint - 65;
  		}
  		if (codePoint - 97 < 26) {
  			return codePoint - 97;
  		}
  		return base;
  	}

  	/**
  	 * Converts a digit/integer into a basic code point.
  	 * @see `basicToDigit()`
  	 * @private
  	 * @param {Number} digit The numeric value of a basic code point.
  	 * @returns {Number} The basic code point whose value (when used for
  	 * representing integers) is `digit`, which needs to be in the range
  	 * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
  	 * used; else, the lowercase form is used. The behavior is undefined
  	 * if `flag` is non-zero and `digit` has no uppercase form.
  	 */
  	function digitToBasic(digit, flag) {
  		//  0..25 map to ASCII a..z or A..Z
  		// 26..35 map to ASCII 0..9
  		return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
  	}

  	/**
  	 * Bias adaptation function as per section 3.4 of RFC 3492.
  	 * https://tools.ietf.org/html/rfc3492#section-3.4
  	 * @private
  	 */
  	function adapt(delta, numPoints, firstTime) {
  		var k = 0;
  		delta = firstTime ? floor(delta / damp) : delta >> 1;
  		delta += floor(delta / numPoints);
  		for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
  			delta = floor(delta / baseMinusTMin);
  		}
  		return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
  	}

  	/**
  	 * Converts a Punycode string of ASCII-only symbols to a string of Unicode
  	 * symbols.
  	 * @memberOf punycode
  	 * @param {String} input The Punycode string of ASCII-only symbols.
  	 * @returns {String} The resulting string of Unicode symbols.
  	 */
  	function decode(input) {
  		// Don't use UCS-2
  		var output = [],
  		    inputLength = input.length,
  		    out,
  		    i = 0,
  		    n = initialN,
  		    bias = initialBias,
  		    basic,
  		    j,
  		    index,
  		    oldi,
  		    w,
  		    k,
  		    digit,
  		    t,
  		    /** Cached calculation results */
  		    baseMinusT;

  		// Handle the basic code points: let `basic` be the number of input code
  		// points before the last delimiter, or `0` if there is none, then copy
  		// the first basic code points to the output.

  		basic = input.lastIndexOf(delimiter);
  		if (basic < 0) {
  			basic = 0;
  		}

  		for (j = 0; j < basic; ++j) {
  			// if it's not a basic code point
  			if (input.charCodeAt(j) >= 0x80) {
  				error('not-basic');
  			}
  			output.push(input.charCodeAt(j));
  		}

  		// Main decoding loop: start just after the last delimiter if any basic code
  		// points were copied; start at the beginning otherwise.

  		for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {

  			// `index` is the index of the next character to be consumed.
  			// Decode a generalized variable-length integer into `delta`,
  			// which gets added to `i`. The overflow checking is easier
  			// if we increase `i` as we go, then subtract off its starting
  			// value at the end to obtain `delta`.
  			for (oldi = i, w = 1, k = base; /* no condition */; k += base) {

  				if (index >= inputLength) {
  					error('invalid-input');
  				}

  				digit = basicToDigit(input.charCodeAt(index++));

  				if (digit >= base || digit > floor((maxInt - i) / w)) {
  					error('overflow');
  				}

  				i += digit * w;
  				t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);

  				if (digit < t) {
  					break;
  				}

  				baseMinusT = base - t;
  				if (w > floor(maxInt / baseMinusT)) {
  					error('overflow');
  				}

  				w *= baseMinusT;

  			}

  			out = output.length + 1;
  			bias = adapt(i - oldi, out, oldi == 0);

  			// `i` was supposed to wrap around from `out` to `0`,
  			// incrementing `n` each time, so we'll fix that now:
  			if (floor(i / out) > maxInt - n) {
  				error('overflow');
  			}

  			n += floor(i / out);
  			i %= out;

  			// Insert `n` at position `i` of the output
  			output.splice(i++, 0, n);

  		}

  		return ucs2encode(output);
  	}

  	/**
  	 * Converts a string of Unicode symbols (e.g. a domain name label) to a
  	 * Punycode string of ASCII-only symbols.
  	 * @memberOf punycode
  	 * @param {String} input The string of Unicode symbols.
  	 * @returns {String} The resulting Punycode string of ASCII-only symbols.
  	 */
  	function encode(input) {
  		var n,
  		    delta,
  		    handledCPCount,
  		    basicLength,
  		    bias,
  		    j,
  		    m,
  		    q,
  		    k,
  		    t,
  		    currentValue,
  		    output = [],
  		    /** `inputLength` will hold the number of code points in `input`. */
  		    inputLength,
  		    /** Cached calculation results */
  		    handledCPCountPlusOne,
  		    baseMinusT,
  		    qMinusT;

  		// Convert the input in UCS-2 to Unicode
  		input = ucs2decode(input);

  		// Cache the length
  		inputLength = input.length;

  		// Initialize the state
  		n = initialN;
  		delta = 0;
  		bias = initialBias;

  		// Handle the basic code points
  		for (j = 0; j < inputLength; ++j) {
  			currentValue = input[j];
  			if (currentValue < 0x80) {
  				output.push(stringFromCharCode(currentValue));
  			}
  		}

  		handledCPCount = basicLength = output.length;

  		// `handledCPCount` is the number of code points that have been handled;
  		// `basicLength` is the number of basic code points.

  		// Finish the basic string - if it is not empty - with a delimiter
  		if (basicLength) {
  			output.push(delimiter);
  		}

  		// Main encoding loop:
  		while (handledCPCount < inputLength) {

  			// All non-basic code points < n have been handled already. Find the next
  			// larger one:
  			for (m = maxInt, j = 0; j < inputLength; ++j) {
  				currentValue = input[j];
  				if (currentValue >= n && currentValue < m) {
  					m = currentValue;
  				}
  			}

  			// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
  			// but guard against overflow
  			handledCPCountPlusOne = handledCPCount + 1;
  			if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
  				error('overflow');
  			}

  			delta += (m - n) * handledCPCountPlusOne;
  			n = m;

  			for (j = 0; j < inputLength; ++j) {
  				currentValue = input[j];

  				if (currentValue < n && ++delta > maxInt) {
  					error('overflow');
  				}

  				if (currentValue == n) {
  					// Represent delta as a generalized variable-length integer
  					for (q = delta, k = base; /* no condition */; k += base) {
  						t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
  						if (q < t) {
  							break;
  						}
  						qMinusT = q - t;
  						baseMinusT = base - t;
  						output.push(
  							stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
  						);
  						q = floor(qMinusT / baseMinusT);
  					}

  					output.push(stringFromCharCode(digitToBasic(q, 0)));
  					bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
  					delta = 0;
  					++handledCPCount;
  				}
  			}

  			++delta;
  			++n;

  		}
  		return output.join('');
  	}

  	/**
  	 * Converts a Punycode string representing a domain name or an email address
  	 * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
  	 * it doesn't matter if you call it on a string that has already been
  	 * converted to Unicode.
  	 * @memberOf punycode
  	 * @param {String} input The Punycoded domain name or email address to
  	 * convert to Unicode.
  	 * @returns {String} The Unicode representation of the given Punycode
  	 * string.
  	 */
  	function toUnicode(input) {
  		return mapDomain(input, function(string) {
  			return regexPunycode.test(string)
  				? decode(string.slice(4).toLowerCase())
  				: string;
  		});
  	}

  	/**
  	 * Converts a Unicode string representing a domain name or an email address to
  	 * Punycode. Only the non-ASCII parts of the domain name will be converted,
  	 * i.e. it doesn't matter if you call it with a domain that's already in
  	 * ASCII.
  	 * @memberOf punycode
  	 * @param {String} input The domain name or email address to convert, as a
  	 * Unicode string.
  	 * @returns {String} The Punycode representation of the given domain name or
  	 * email address.
  	 */
  	function toASCII(input) {
  		return mapDomain(input, function(string) {
  			return regexNonASCII.test(string)
  				? 'xn--' + encode(string)
  				: string;
  		});
  	}

  	/*--------------------------------------------------------------------------*/

  	/** Define the public API */
  	punycode = {
  		/**
  		 * A string representing the current Punycode.js version number.
  		 * @memberOf punycode
  		 * @type String
  		 */
  		'version': '1.3.2',
  		/**
  		 * An object of methods to convert from JavaScript's internal character
  		 * representation (UCS-2) to Unicode code points, and back.
  		 * @see <https://mathiasbynens.be/notes/javascript-encoding>
  		 * @memberOf punycode
  		 * @type Object
  		 */
  		'ucs2': {
  			'decode': ucs2decode,
  			'encode': ucs2encode
  		},
  		'decode': decode,
  		'encode': encode,
  		'toASCII': toASCII,
  		'toUnicode': toUnicode
  	};

  	/** Expose `punycode` */
  	// Some AMD build optimizers, like r.js, check for specific condition patterns
  	// like the following:
  	if (
  		typeof define == 'function' &&
  		typeof define.amd == 'object' &&
  		define.amd
  	) {
  		define('punycode', function() {
  			return punycode;
  		});
  	} else if (freeExports && freeModule) {
  		if (module.exports == freeExports) { // in Node.js or RingoJS v0.8.0+
  			freeModule.exports = punycode;
  		} else { // in Narwhal or RingoJS v0.7.0-
  			for (key in punycode) {
  				punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
  			}
  		}
  	} else { // in Rhino or a web browser
  		root.punycode = punycode;
  	}

  }(window));

}