firt parsen: remove tabs in js files

2 files changed, 803 insertions, 804 deletions

diff --git a/lib/publicsuffixlist.js b/lib/publicsuffixlist.js
index a823188..c0625ab 100644
--- a/lib/publicsuffixlist.js
+++ b/lib/publicsuffixlist.js
@@ -22,9 +22,9 @@
 /*! Home: https://github.com/gorhill/publicsuffixlist.js */
 
 /*
-    This code is mostly dumb: I consider this to be lower-level code, thus
-    in order to ensure efficiency, the caller is responsible for sanitizing
-    the inputs.
+  This code is mostly dumb: I consider this to be lower-level code, thus
+  in order to ensure efficiency, the caller is responsible for sanitizing
+  the inputs.
 */
 
 /******************************************************************************/
@@ -33,337 +33,336 @@
 
 ;(function(root) {
 
-'use strict';
+    'use strict';
 
-/******************************************************************************/
+    /******************************************************************************/
 
-var exceptions = {};
-var rules = {};
-var selfieMagic = 'iscjsfsaolnm';
+    var exceptions = {};
+    var rules = {};
+    var selfieMagic = 'iscjsfsaolnm';
 
-// This value dictate how the search will be performed:
-//    < this.cutoffLength = indexOf()
-//   >= this.cutoffLength = binary search
-var cutoffLength = 256;
-var mustPunycode = /[^\w.*-]/;
+    // This value dictate how the search will be performed:
+    //    < this.cutoffLength = indexOf()
+    //   >= this.cutoffLength = binary search
+    var cutoffLength = 256;
+    var mustPunycode = /[^\w.*-]/;
 
-var onChangedListeners = [];
+    var onChangedListeners = [];
 
-/******************************************************************************/
+    /******************************************************************************/
 
-// In the context of this code, a domain is defined as:
-//   "{label}.{public suffix}".
-// A single standalone label is a public suffix as per
-// http://publicsuffix.org/list/:
-//   "If no rules match, the prevailing rule is '*' "
-// This means 'localhost' is not deemed a domain by this
-// code, since according to the definition above, it would be
-// evaluated as a public suffix. The caller is therefore responsible to
-// decide how to further interpret such public suffix.
-//
-// `hostname` must be a valid ascii-based hostname.
-
-function getDomain(hostname) {
-    // A hostname starting with a dot is not a valid hostname.
-    if ( !hostname || hostname.charAt(0) === '.' ) {
-        return '';
-    }
-    hostname = hostname.toLowerCase();
-    var suffix = getPublicSuffix(hostname);
-    if ( suffix === hostname ) {
-        return '';
-    }
-    var pos = hostname.lastIndexOf('.', hostname.lastIndexOf('.', hostname.length - suffix.length) - 1);
-    if ( pos <= 0 ) {
-        return hostname;
+    // In the context of this code, a domain is defined as:
+    //   "{label}.{public suffix}".
+    // A single standalone label is a public suffix as per
+    // http://publicsuffix.org/list/:
+    //   "If no rules match, the prevailing rule is '*' "
+    // This means 'localhost' is not deemed a domain by this
+    // code, since according to the definition above, it would be
+    // evaluated as a public suffix. The caller is therefore responsible to
+    // decide how to further interpret such public suffix.
+    //
+    // `hostname` must be a valid ascii-based hostname.
+
+    function getDomain(hostname) {
+        // A hostname starting with a dot is not a valid hostname.
+        if ( !hostname || hostname.charAt(0) === '.' ) {
+            return '';
+        }
+        hostname = hostname.toLowerCase();
+        var suffix = getPublicSuffix(hostname);
+        if ( suffix === hostname ) {
+            return '';
+        }
+        var pos = hostname.lastIndexOf('.', hostname.lastIndexOf('.', hostname.length - suffix.length) - 1);
+        if ( pos <= 0 ) {
+            return hostname;
+        }
+        return hostname.slice(pos + 1);
     }
-    return hostname.slice(pos + 1);
-}
 
-/******************************************************************************/
+    /******************************************************************************/
 
-// Return longest public suffix.
-//
-// `hostname` must be a valid ascii-based string which respect hostname naming.
+    // Return longest public suffix.
+    //
+    // `hostname` must be a valid ascii-based string which respect hostname naming.
 
-function getPublicSuffix(hostname) {
-    if ( !hostname ) {
-        return '';
+    function getPublicSuffix(hostname) {
+        if ( !hostname ) {
+            return '';
+        }
+        // Since we slice down the hostname with each pass, the first match
+        // is the longest, so no need to find all the matching rules.
+        var pos;
+        while ( true ) {
+            pos = hostname.indexOf('.');
+            if ( pos < 0 ) {
+                return hostname;
+            }
+            if ( search(exceptions, hostname) ) {
+                return hostname.slice(pos + 1);
+            }
+            if ( search(rules, hostname) ) {
+                return hostname;
+            }
+            if ( search(rules, '*' + hostname.slice(pos)) ) {
+                return hostname;
+            }
+            hostname = hostname.slice(pos + 1);
+        }
+        // unreachable
     }
-    // Since we slice down the hostname with each pass, the first match
-    // is the longest, so no need to find all the matching rules.
-    var pos;
-    while ( true ) {
-        pos = hostname.indexOf('.');
+
+    /******************************************************************************/
+
+    // Look up a specific hostname.
+
+    function search(store, hostname) {
+        // Extract TLD
+        var pos = hostname.lastIndexOf('.');
+        var tld, remainder;
         if ( pos < 0 ) {
-            return hostname;
+            tld = hostname;
+            remainder = hostname;
+        } else {
+            tld = hostname.slice(pos + 1);
+            remainder = hostname.slice(0, pos);
         }
-        if ( search(exceptions, hostname) ) {
-            return hostname.slice(pos + 1);
+        var substore = store[tld];
+        if ( !substore ) {
+            return false;
         }
-        if ( search(rules, hostname) ) {
-            return hostname;
+        // If substore is a string, use indexOf()
+        if ( typeof substore === 'string' ) {
+            return substore.indexOf(' ' + remainder + ' ') >= 0;
         }
-        if ( search(rules, '*' + hostname.slice(pos)) ) {
-            return hostname;
+        // It is an array: use binary search.
+        var l = remainder.length;
+        var haystack = substore[l];
+        if ( !haystack ) {
+            return false;
         }
-        hostname = hostname.slice(pos + 1);
+        var left = 0;
+        var right = Math.floor(haystack.length / l + 0.5);
+        var i, needle;
+        while ( left < right ) {
+            i = left + right >> 1;
+            needle = haystack.substr( l * i, l );
+            if ( remainder < needle ) {
+                right = i;
+            } else if ( remainder > needle ) {
+                left = i + 1;
+            } else {
+                return true;
+            }
+        }
+        return false;
     }
-    // unreachable
-}
 
-/******************************************************************************/
+    /******************************************************************************/
 
-// Look up a specific hostname.
-
-function search(store, hostname) {
-    // Extract TLD
-    var pos = hostname.lastIndexOf('.');
-    var tld, remainder;
-    if ( pos < 0 ) {
-        tld = hostname;
-        remainder = hostname;
-    } else {
-        tld = hostname.slice(pos + 1);
-        remainder = hostname.slice(0, pos);
-    }
-    var substore = store[tld];
-    if ( !substore ) {
-        return false;
-    }
-    // If substore is a string, use indexOf()
-    if ( typeof substore === 'string' ) {
-        return substore.indexOf(' ' + remainder + ' ') >= 0;
-    }
-    // It is an array: use binary search.
-    var l = remainder.length;
-    var haystack = substore[l];
-    if ( !haystack ) {
-        return false;
-    }
-    var left = 0;
-    var right = Math.floor(haystack.length / l + 0.5);
-    var i, needle;
-    while ( left < right ) {
-        i = left + right >> 1;
-        needle = haystack.substr( l * i, l );
-        if ( remainder < needle ) {
-            right = i;
-        } else if ( remainder > needle ) {
-            left = i + 1;
-        } else {
-            return true;
-        }
-    }
-    return false;
-}
+    // Parse and set a UTF-8 text-based suffix list. Format is same as found at:
+    // http://publicsuffix.org/list/
+    //
+    // `toAscii` is a converter from unicode to punycode. Required since the
+    // Public Suffix List contains unicode characters.
+    // Suggestion: use <https://github.com/bestiejs/punycode.js> it's quite good.
 
-/******************************************************************************/
+    function parse(text, toAscii) {
+        exceptions = {};
+        rules = {};
+
+        var lineBeg = 0, lineEnd;
+        var textEnd = text.length;
+        var line, store, pos, tld;
 
-// Parse and set a UTF-8 text-based suffix list. Format is same as found at:
-// http://publicsuffix.org/list/
-//
-// `toAscii` is a converter from unicode to punycode. Required since the
-// Public Suffix List contains unicode characters.
-// Suggestion: use <https://github.com/bestiejs/punycode.js> it's quite good.
-
-function parse(text, toAscii) {
-    exceptions = {};
-    rules = {};
-
-    var lineBeg = 0, lineEnd;
-    var textEnd = text.length;
-    var line, store, pos, tld;
-
-    while ( lineBeg < textEnd ) {
-        lineEnd = text.indexOf('\n', lineBeg);
-        if ( lineEnd < 0 ) {
-            lineEnd = text.indexOf('\r', lineBeg);
+        while ( lineBeg < textEnd ) {
+            lineEnd = text.indexOf('\n', lineBeg);
             if ( lineEnd < 0 ) {
-                lineEnd = textEnd;
+                lineEnd = text.indexOf('\r', lineBeg);
+                if ( lineEnd < 0 ) {
+                    lineEnd = textEnd;
+                }
             }
-        }
-        line = text.slice(lineBeg, lineEnd).trim();
-        lineBeg = lineEnd + 1;
+            line = text.slice(lineBeg, lineEnd).trim();
+            lineBeg = lineEnd + 1;
 
-        if ( line.length === 0 ) {
-            continue;
-        }
+            if ( line.length === 0 ) {
+                continue;
+            }
 
-        // Ignore comments
-        pos = line.indexOf('//');
-        if ( pos >= 0 ) {
-            line = line.slice(0, pos);
-        }
+            // Ignore comments
+            pos = line.indexOf('//');
+            if ( pos >= 0 ) {
+                line = line.slice(0, pos);
+            }
 
-        // Ignore surrounding whitespaces
-        line = line.trim();
-        if ( !line ) {
-            continue;
-        }
+            // Ignore surrounding whitespaces
+            line = line.trim();
+            if ( !line ) {
+                continue;
+            }
 
-        // Is this an exception rule?
-        if ( line.charAt(0) === '!' ) {
-            store = exceptions;
-            line = line.slice(1);
-        } else {
-            store = rules;
-        }
+            // Is this an exception rule?
+            if ( line.charAt(0) === '!' ) {
+                store = exceptions;
+                line = line.slice(1);
+            } else {
+                store = rules;
+            }
 
-        if ( mustPunycode.test(line) ) {
-            line = toAscii(line);
-        }
+            if ( mustPunycode.test(line) ) {
+                line = toAscii(line);
+            }
 
-        // http://publicsuffix.org/list/:
-        // "... all rules must be canonicalized in the normal way
-        // for hostnames - lower-case, Punycode ..."
-        line = line.toLowerCase();
+            // http://publicsuffix.org/list/:
+            // "... all rules must be canonicalized in the normal way
+            // for hostnames - lower-case, Punycode ..."
+            line = line.toLowerCase();
+
+            // Extract TLD
+            pos = line.lastIndexOf('.');
+            if ( pos < 0 ) {
+                tld = line;
+            } else {
+                tld = line.slice(pos + 1);
+                line = line.slice(0, pos);
+            }
 
-        // Extract TLD
-        pos = line.lastIndexOf('.');
-        if ( pos < 0 ) {
-            tld = line;
-        } else {
-            tld = line.slice(pos + 1);
-            line = line.slice(0, pos);
+            // Store suffix using tld as key
+            if ( !store.hasOwnProperty(tld) ) {
+                store[tld] = [];
+            }
+            if ( line ) {
+                store[tld].push(line);
+            }
         }
+        crystallize(exceptions);
+        crystallize(rules);
 
-        // Store suffix using tld as key
-        if ( !store.hasOwnProperty(tld) ) {
-            store[tld] = [];
-        }
-        if ( line ) {
-            store[tld].push(line);
-        }
+        callListeners(onChangedListeners);
     }
-    crystallize(exceptions);
-    crystallize(rules);
 
-    callListeners(onChangedListeners);
-}
+    /******************************************************************************/
 
-/******************************************************************************/
-
-// Cristallize the storage of suffixes using optimal internal representation
-// for future look up.
+    // Cristallize the storage of suffixes using optimal internal representation
+    // for future look up.
 
-function crystallize(store) {
-    var suffixes, suffix, i, l;
+    function crystallize(store) {
+        var suffixes, suffix, i, l;
 
-    for ( var tld in store ) {
-        if ( !store.hasOwnProperty(tld) ) {
-            continue;
-        }
-        suffixes = store[tld].join(' ');
-        // No suffix
-        if ( !suffixes ) {
-            store[tld] = '';
-            continue;
-        }
-        // Concatenated list of suffixes less than cutoff length:
-        //   Store as string, lookup using indexOf()
-        if ( suffixes.length < cutoffLength ) {
-            store[tld] = ' ' + suffixes + ' ';
-            continue;
-        }
-        // Concatenated list of suffixes greater or equal to cutoff length
-        //   Store as array keyed on suffix length, lookup using binary search.
-        // I borrowed the idea to key on string length here:
-        //   http://ejohn.org/blog/dictionary-lookups-in-javascript/#comment-392072
-
-        i = store[tld].length;
-        suffixes = [];
-        while ( i-- ) {
-            suffix = store[tld][i];
-            l = suffix.length;
-            if ( !suffixes[l] ) {
-                suffixes[l] = [];
+        for ( var tld in store ) {
+            if ( !store.hasOwnProperty(tld) ) {
+                continue;
             }
-            suffixes[l].push(suffix);
-        }
-        l = suffixes.length;
-        while ( l-- ) {
-            if ( suffixes[l] ) {
-                suffixes[l] = suffixes[l].sort().join('');
+            suffixes = store[tld].join(' ');
+            // No suffix
+            if ( !suffixes ) {
+                store[tld] = '';
+                continue;
             }
+            // Concatenated list of suffixes less than cutoff length:
+            //   Store as string, lookup using indexOf()
+            if ( suffixes.length < cutoffLength ) {
+                store[tld] = ' ' + suffixes + ' ';
+                continue;
+            }
+            // Concatenated list of suffixes greater or equal to cutoff length
+            //   Store as array keyed on suffix length, lookup using binary search.
+            // I borrowed the idea to key on string length here:
+            //   http://ejohn.org/blog/dictionary-lookups-in-javascript/#comment-392072
+
+            i = store[tld].length;
+            suffixes = [];
+            while ( i-- ) {
+                suffix = store[tld][i];
+                l = suffix.length;
+                if ( !suffixes[l] ) {
+                    suffixes[l] = [];
+                }
+                suffixes[l].push(suffix);
+            }
+            l = suffixes.length;
+            while ( l-- ) {
+                if ( suffixes[l] ) {
+                    suffixes[l] = suffixes[l].sort().join('');
+                }
+            }
+            store[tld] = suffixes;
         }
-        store[tld] = suffixes;
+        return store;
     }
-    return store;
-}
 
-/******************************************************************************/
+    /******************************************************************************/
 
-function toSelfie() {
-    return {
-        magic: selfieMagic,
-        rules: rules,
-        exceptions: exceptions
-    };
-}
+    function toSelfie() {
+        return {
+            magic: selfieMagic,
+            rules: rules,
+            exceptions: exceptions
+        };
+    }
 
-function fromSelfie(selfie) {
-    if ( typeof selfie !== 'object' || typeof selfie.magic !== 'string' || selfie.magic !== selfieMagic ) {
-        return false;
+    function fromSelfie(selfie) {
+        if ( typeof selfie !== 'object' || typeof selfie.magic !== 'string' || selfie.magic !== selfieMagic ) {
+            return false;
+        }
+        rules = selfie.rules;
+        exceptions = selfie.exceptions;
+        callListeners(onChangedListeners);
+        return true;
     }
-    rules = selfie.rules;
-    exceptions = selfie.exceptions;
-    callListeners(onChangedListeners);
-    return true;
-}
 
-/******************************************************************************/
+    /******************************************************************************/
 
-var addListener = function(listeners, callback) {
-    if ( typeof callback !== 'function' ) {
-        return;
-    }
-    if ( listeners.indexOf(callback) === -1 ) {
-        listeners.push(callback);
-    }
-};
+    var addListener = function(listeners, callback) {
+        if ( typeof callback !== 'function' ) {
+            return;
+        }
+        if ( listeners.indexOf(callback) === -1 ) {
+            listeners.push(callback);
+        }
+    };
 
-var removeListener = function(listeners, callback) {
-    var pos = listeners.indexOf(callback);
-    if ( pos !== -1 ) {
-        listeners.splice(pos, 1);
-    }
-};
+    var removeListener = function(listeners, callback) {
+        var pos = listeners.indexOf(callback);
+        if ( pos !== -1 ) {
+            listeners.splice(pos, 1);
+        }
+    };
 
-var callListeners = function(listeners) {
-    for ( var i = 0; i < listeners.length; i++ ) {
-        listeners[i]();
-    }
-};
+    var callListeners = function(listeners) {
+        for ( var i = 0; i < listeners.length; i++ ) {
+            listeners[i]();
+        }
+    };
 
-/******************************************************************************/
+    /******************************************************************************/
 
-var onChanged = {
-    addListener: function(callback) {
-        addListener(onChangedListeners, callback);
-    },
-    removeListener: function(callback) {
-        removeListener(onChangedListeners, callback);
-    }
-};
+    var onChanged = {
+        addListener: function(callback) {
+            addListener(onChangedListeners, callback);
+        },
+        removeListener: function(callback) {
+            removeListener(onChangedListeners, callback);
+        }
+    };
 
-/******************************************************************************/
+    /******************************************************************************/
 
-// Public API
+    // Public API
 
-root = root || window;
+    root = root || window;
 
-root.publicSuffixList = {
-    'version': '1.0',
-    'parse': parse,
-    'getDomain': getDomain,
-    'getPublicSuffix': getPublicSuffix,
-    'toSelfie': toSelfie,
-    'fromSelfie': fromSelfie,
-    'onChanged': onChanged
-};
+    root.publicSuffixList = {
+        'version': '1.0',
+        'parse': parse,
+        'getDomain': getDomain,
+        'getPublicSuffix': getPublicSuffix,
+        'toSelfie': toSelfie,
+        'fromSelfie': fromSelfie,
+        'onChanged': onChanged
+    };
 
-/******************************************************************************/
+    /******************************************************************************/
 
 })(this);
-
diff --git a/lib/punycode.js b/lib/punycode.js
index c965f8b..b66096e 100644
--- a/lib/punycode.js
+++ b/lib/punycode.js
@@ -23,530 +23,530 @@
 /*! 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 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.
-	 * http://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;
-	}
+    /** 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 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.
+     * http://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;
+    }
 
 }(this));