punycode: replace with Mathias Bynens's implementation

The currently bundled library doesn't pass all the test cases from RFC 3492.
Mathias's library does.

Home: https://github.com/bestiejs/punycode.js

LICENSE

@@ -69,7 +69,8 @@ The externally maintained libraries used by Node are:
   - lib/buffer_ieee754.js is copyright 2008 Fair Oaks Labs, Inc. and released
     under the New BSD license.
 
-  - lib/punycode.js is copyright 2011 Ben Noordhuis and released under the MIT license.
+  - lib/punycode.js is copyright 2011 Mathias Bynens <http://mathiasbynens.be/>
+    and released under the MIT license.
 
   - tools/gyp GYP is a meta-build system copyright 2009 Google Inc and
     licensed under the three clause BSD license. See tools/gyp/LICENSE.

lib/punycode.js

@@ -1,219 +1,560 @@
-// Copyright (C) 2011 by Ben Noordhuis <info@bnoordhuis.nl>
+/*!
-//
+ * Punycode.js <http://mths.be/punycode>
-// Permission is hereby granted, free of charge, to any person obtaining a copy
+ * Copyright 2011 Mathias Bynens <http://mathiasbynens.be/>
-// of this software and associated documentation files (the "Software"), to deal
+ * Available under MIT license <http://mths.be/mit>
-// in the Software without restriction, including without limitation the rights
+ */
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
 
-exports.encode = encode;
+;(function(window) {
-exports.decode = decode;
 
-var TMIN = 1;
+	/**
-var TMAX = 26;
+	 * The `Punycode` object.
-var BASE = 36;
+	 * @name Punycode
-var SKEW = 38;
+	 * @type Object
-var DAMP = 700; // initial bias scaler
+	 */
-var INITIAL_N = 128;
+	var Punycode,
-var INITIAL_BIAS = 72;
-var MAX_INTEGER = Math.pow(2, 53);
 
-function adapt_bias(delta, n_points, is_first) {
+	/** Detect free variables `define`, `exports`, and `require` */
-  // scale back, then increase delta
+	freeDefine = typeof define == 'function' && typeof define.amd == 'object' &&
-  delta /= is_first ? DAMP : 2;
+		define.amd && define,
-  delta += ~~(delta / n_points);
+	freeExports = typeof exports == 'object' && exports &&
+		(typeof global == 'object' && global && global == global.global &&
+		(window = global), exports),
+	freeRequire = typeof require == 'function' && require,
 
-  var s = (BASE - TMIN);
+	/** Highest positive signed 32-bit float value */
-  var t = ~~((s * TMAX) / 2); // threshold=455
+	maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
 
-  for (var k = 0; delta > t; k += BASE) {
+	/** Bootstring parameters */
-    delta = ~~(delta / s);
+	base = 36,
-  }
+	tMin = 1,
+	tMax = 26,
+	skew = 38,
+	damp = 700,
+	initialBias = 72,
+	initialN = 128, // 0x80
+	delimiter = '-', // '\x2D'
 
-  var a = (BASE - TMIN + 1) * delta;
+	/** Error messages */
-  var b = (delta + SKEW);
+	errors = {
+		'overflow': 'Overflow: input needs wider integers to process.',
+		'utf16decode': 'UTF-16(decode): illegal UTF-16 sequence',
+		'utf16encode': 'UTF-16(encode): illegal UTF-16 value',
+		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
+		'invalid-input': 'Invalid input'
+	},
 
-  return k + ~~(a / b);
+	/** Convenience shortcuts */
-}
+	baseMinusTMin = base - tMin,
+	floor = Math.floor,
+	stringFromCharCode = String.fromCharCode;
 
-function next_smallest_codepoint(codepoints, n) {
+	/*--------------------------------------------------------------------------*/
-  var m = 0x110000; // unicode upper bound + 1
 
-  for (var i = 0, len = codepoints.length; i < len; ++i) {
+	/**
-    var c = codepoints[i];
+	 * A generic error utility function.
-    if (c >= n && c < m) {
+	 * @private
-      m = c;
+	 * @param {String} type The error type.
-    }
+	 * @returns {Error} Throws a `RangeError` with the applicable error message.
-  }
+	 */
+	function error(type) {
+		throw RangeError(errors[type]);
+	}
 
-  // sanity check - should not happen
+	/**
-  if (m >= 0x110000) {
+	 * A generic `Array#map` utility function.
-    throw new Error('Next smallest code point not found.');
+	 * @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;
+		while (length--) {
+			array[length] = fn(array[length]);
+		}
+		return array;
+	}
 
-  return m;
+	/**
-}
+	 * A simple `Array#map`-like wrapper to work with domain name strings.
+	 * @private
+	 * @param {String} domain The domain name.
+	 * @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 glue = '.';
+		return map(string.toLowerCase().split(glue), fn).join(glue);
+	}
 
-function encode_digit(d) {
+	/**
-  return d + (d < 26 ? 97 : 22);
+	 * Creates an array containing the decimal code points of each character in
-}
+	 * the string.
+	 * @see `Punycode.utf16.encode`
+	 * @memberOf Punycode.utf16
+	 * @name decode
+	 * @param {String} string The Unicode input string.
+	 * @returns {Array} The new array.
+	 */
+	function utf16decode(string) {
+		var output = [],
+		    counter = 0,
+		    length = string.length,
+		    value,
+		    extra;
+		while (counter < length) {
+			value = string.charCodeAt(counter++);
+			if ((value & 0xF800) == 0xD800) {
+				extra = string.charCodeAt(counter++);
+				if ((value & 0xFC00) != 0xD800 || (extra & 0xFC00) != 0xDC00) {
+					error('utf16decode');
+				}
+				value = ((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000;
+			}
+			output.push(value);
+		}
+		return output;
+	}
 
-function decode_digit(d) {
+	/**
-  if (d >= 48 && d <= 57) {
+	 * Creates a string based on an array of decimal code points.
-    return d - 22; // 0..9
+	 * @see `Punycode.utf16.decode`
-  }
+	 * @memberOf Punycode.utf16
-  if (d >= 65 && d <= 90) {
+	 * @name encode
-    return d - 65; // A..Z
+	 * @param {Array} codePoints The array of decimal code points.
-  }
+	 * @returns {String} The new string.
-  if (d >= 97 && d <= 122) {
+	 */
-    return d - 97; // a..z
+	function utf16encode(array) {
-  }
+		return map(array, function(value) {
-  throw new Error('Illegal digit #' + d);
+			var output = '';
-}
+			if ((value & 0xF800) == 0xD800) {
+				error('utf16encode');
+			}
+			if (value > 0xFFFF) {
+				value -= 0x10000;
+				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
+				value = 0xDC00 | value & 0x3FF;
+			}
+			output += stringFromCharCode(value);
+			return output;
+		}).join('');
+	}
 
-function threshold(k, bias) {
+	/**
-  if (k <= bias + TMIN) {
+	 * Converts a basic code point into a digit/integer.
-    return TMIN;
+	 * @see `digitToBasic()`
-  }
+	 * @private
-  if (k >= bias + TMAX) {
+	 * @param {Number} codePoint The basic (decimal) code point.
-    return TMAX;
+	 * @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
-  return k - bias;
+	 * the code point does not represent a value.
-}
+	 */
+	function basicToDigit(codePoint) {
+		return codePoint - 48 < 10
+			? codePoint - 22
+			: codePoint - 65 < 26
+				? codePoint - 65
+				: codePoint - 97 < 26
+					? codePoint - 97
+					: base;
+	}
 
-function encode_int(bias, delta) {
+	/**
-  var result = [];
+	 * 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);
+	}
 
-  for (var k = BASE, q = delta;; k += BASE) {
+	/**
-    var t = threshold(k, bias);
+	 * Bias adaptation function as per section 3.4 of RFC 3492.
-    if (q < t) {
+	 * http://tools.ietf.org/html/rfc3492#section-3.4
-      result.push(encode_digit(q));
+	 * @private
-      break;
+	 */
-    }
+	function adapt(delta, numPoints, firstTime) {
-    else {
+		var k = 0;
-      result.push(encode_digit(t + ((q - t) % (BASE - t))));
+		delta = firstTime ? floor(delta / damp) : delta >> 1;
-      q = ~~((q - t) / (BASE - t));
+		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));
+	}
 
-  return result;
+	/**
-}
+	 * Converts a basic code point to lowercase is `flag` is falsy, or to
+	 * caseless. The behavior is undefined if `codePoint` is not a basic code
+	 * point.
+	 * @private
+	 * @param {Number} codePoint The numeric value of a basic code point.
+	 * @returns {Number} The resulting basic code point.
+	 */
+	function encodeBasic(codePoint, flag) {
+		codePoint -= (codePoint - 97 < 26) << 5;
+		return codePoint + (!flag && codePoint - 65 < 26) << 5;
+	}
 
-function encode(input) {
+	/**
-  if (typeof input != 'string') {
+	 * Converts a Punycode string of ASCII code points to a string of Unicode
-    throw new Error('Argument must be a string.');
+	 * code points.
-  }
+	 * @memberOf Punycode
+	 * @param {String} input The Punycode string of ASCII code points.
+	 * @param {Boolean} preserveCase A boolean value indicating if character
+	 * case should be preserved or not.
+	 * @returns {String} The resulting string of Unicode code points.
+	 */
+	function decode(input, preserveCase) {
+		// Don't use UTF-16
+		var output = [],
+		    /**
+		     * The `caseFlags` array needs room for at least `output.length` values,
+		     * or it can be `undefined` if the case information is not needed. A
+		     * truthy value suggests that the corresponding Unicode character be
+		     * forced to uppercase (if possible), while falsy values suggest that it
+		     * be forced to lowercase (if possible). ASCII code points are output
+		     * already in the proper case, but their flags will be set appropriately
+		     * so that applying the flags would be harmless.
+		     */
+		    caseFlags = [],
+		    inputLength = input.length,
+		    out,
+		    i = 0,
+		    n = initialN,
+		    bias = initialBias,
+		    basic,
+		    j,
+		    index,
+		    oldi,
+		    w,
+		    k,
+		    digit,
+		    t,
+		    length,
+		    /** Cached calculation results */
+		    baseMinusT;
 
-  input = input.split('').map(function(c) {
+		// Handle the basic code points: let `basic` be the number of input code
-    return c.charCodeAt(0);
+		// points before the last delimiter, or `0` if there is none, then copy
-  });
+		// the first basic code points to the output.
 
-  var output = [];
+		basic = input.lastIndexOf(delimiter);
-  var non_basic = [];
+		if (basic < 0) {
+			basic = 0;
+		}
 
-  for (var i = 0, len = input.length; i < len; ++i) {
+		for (j = 0; j < basic; ++j) {
-    var c = input[i];
+			if (preserveCase) {
-    if (c < 128) {
+				caseFlags[output.length] = input.charCodeAt(j) - 65 < 26;
-      output.push(c);
+			}
-    }
+			// if it's not a basic code point
-    else {
+			if (input.charCodeAt(j) >= 0x80) {
-      non_basic.push(c);
+				error('not-basic');
-    }
+			}
-  }
+			output.push(input.charCodeAt(j));
+		}
 
-  var b, h;
+		// Main decoding loop: start just after the last delimiter if any basic
-  b = h = output.length;
+		// code points were copied; start at the beginning otherwise.
 
-  if (b) {
+		for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
-    output.push(45); // delimiter '-'
-  }
 
-  var n = INITIAL_N;
+			// `index` is the index of the next character to be consumed.
-  var bias = INITIAL_BIAS;
+			// Decode a generalized variable-length integer into `delta`,
-  var delta = 0;
+			// 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) {
 
-  for (var len = input.length; h < len; ++n, ++delta) {
+				if (index >= inputLength) {
-    var m = next_smallest_codepoint(non_basic, n);
+					error('invalid-input');
-    delta += (m - n) * (h + 1);
+				}
-    n = m;
 
-    for (var i = 0; i < len; ++i) {
+				digit = basicToDigit(input.charCodeAt(index++));
-      var c = input[i];
-      if (c < n) {
-        if (++delta == MAX_INTEGER) {
-          throw new Error('Delta overflow.');
-        }
-      }
-      else if (c == n) {
-        // TODO append in-place?
-        // i.e. -> output.push.apply(output, encode_int(bias, delta));
-        output = output.concat(encode_int(bias, delta));
-        bias = adapt_bias(delta, h + 1, b == h);
-        delta = 0;
-        h++;
-      }
-    }
-  }
 
-  return String.fromCharCode.apply(String, output);
+				if (digit >= base || digit > floor((maxInt - i) / w)) {
-}
+					error('overflow');
+				}
 
-function decode(input) {
+				i += digit * w;
-  if (typeof input != 'string') {
+				t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
-    throw new Error('Argument must be a string.');
-  }
 
-  // find basic code points/delta separator
+				if (digit < t) {
-  var b = 1 + input.lastIndexOf('-');
+					break;
+				}
 
-  input = input.split('').map(function(c) {
+				baseMinusT = base - t;
-    return c.charCodeAt(0);
+				if (w > floor(maxInt / baseMinusT)) {
-  });
+					error('overflow');
+				}
 
-  // start with a copy of the basic code points
+				w *= baseMinusT;
-  var output = input.slice(0, b ? (b - 1) : 0);
 
-  var n = INITIAL_N;
+			}
-  var bias = INITIAL_BIAS;
 
-  for (var i = 0, len = input.length; b < len; ++i) {
+			out = output.length + 1;
-    var org_i = i;
+			bias = adapt(i - oldi, out, oldi == 0);
 
-    for (var k = BASE, w = 1;; k += BASE) {
+			// `i` was supposed to wrap around from `out` to `0`,
-      var d = decode_digit(input[b++]);
+			// incrementing `n` each time, so we'll fix that now:
+			if (floor(i / out) > maxInt - n) {
+				error('overflow');
+			}
 
-      // TODO overflow check
+			n += floor(i / out);
-      i += d * w;
+			i %= out;
 
-      var t = threshold(k, bias);
+			// Insert `n` at position `i` of the output
-      if (d < t) {
+			// The case of the last character determines `uppercase` flag
-        break;
+			if (preserveCase) {
-      }
+				caseFlags.splice(i, 0, input.charCodeAt(index - 1) - 65 < 26);
+			}
 
-      // TODO overflow check
+			output.splice(i, 0, n);
-      w *= BASE - t;
+			i++;
-    }
 
-    var x = 1 + output.length;
+		}
-    bias = adapt_bias(i - org_i, x, org_i == 0);
-    // TODO overflow check
-    n += ~~(i / x);
-    i %= x;
 
-    output.splice(i, 0, n);
+		if (preserveCase) {
-  }
+			for (i = 0, length = output.length; i < length; i++) {
+				if (caseFlags[i]) {
+					output[i] = (stringFromCharCode(output[i]).toUpperCase()).charCodeAt(0);
+				}
+			}
+		}
+		return utf16encode(output);
+	}
 
-  return String.fromCharCode.apply(String, output);
+	/**
-}
+	 * Converts a string of Unicode code points to a Punycode string of ASCII
+	 * code points.
+	 * @memberOf Punycode
+	 * @param {String} input The string of Unicode code points.
+	 * @param {Boolean} preserveCase A boolean value indicating if character
+	 * case should be preserved or not.
+	 * @returns {String} The resulting Punycode string of ASCII code points.
+	 */
+	function encode(input, preserveCase) {
+		var n,
+		    delta,
+		    handledCPCount,
+		    basicLength,
+		    bias,
+		    j,
+		    m,
+		    q,
+		    k,
+		    t,
+		    currentValue,
+		    /**
+		     * The `caseFlags` array will hold `inputLength` boolean values, where
+		     * `true` suggests that the corresponding Unicode character be forced
+		     * to uppercase after being decoded (if possible), and `false`
+		     * suggests that it be forced to lowercase (if possible). ASCII code
+		     * points are encoded literally, except that ASCII letters are forced
+		     * to uppercase or lowercase according to the corresponding uppercase
+		     * flags. If `caseFlags` remains `undefined` then ASCII letters are
+		     * left as they are, and other code points are treated as if their
+		     * uppercase flags were `true`.
+		     */
+		    caseFlags,
+		    output = [],
+		    /** `inputLength` will hold the number of code points in `input`. */
+		    inputLength,
+		    /** Cached calculation results */
+		    handledCPCountPlusOne,
+		    baseMinusT,
+		    qMinusT;
+
+		if (preserveCase) {
+			// Preserve case, step 1 of 2: get a list of the unaltered string
+			caseFlags = utf16decode(input);
+		}
+
+		// Convert the input in UTF-16 to Unicode
+		input = utf16decode(input);
+
+		// Cache the length
+		inputLength = input.length;
+
+		if (preserveCase) {
+			// Preserve case, step 2 of 2: modify the list to true/false
+			for (j = 0; j < inputLength; j++) {
+				caseFlags[j] = input[j] != caseFlags[j];
+			}
+		}
+
+		// 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(
+						caseFlags ? encodeBasic(currentValue, caseFlags[j]) : 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, preserveCase && caseFlags[j] ? 1 : 0)));
+					bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
+					delta = 0;
+					++handledCPCount;
+				}
+			}
+
+			++delta;
+			++n;
+
+		}
+		return output.join('');
+	}
+
+	/**
+	 * Converts a Unicode string representing a domain name 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} domain The domain name to convert, as a Unicode string.
+	 * @returns {String} The Punycode representation of the given domain name.
+	 */
+	function toASCII(domain) {
+		return mapDomain(domain, function(string) {
+			return string.match(/[^a-zA-Z0-9-]/)
+				? 'xn--' + encode(string)
+				: string;
+		});
+	}
+
+	/**
+	 * Converts a Punycode string representing a domain name to Unicode. Only the
+	 * Punycoded parts of the domain name 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} domain The Punycode domain name to convert to Unicode.
+	 * @returns {String} The Unicode representation of the given Punycode
+	 * string.
+	 */
+	function toUnicode(domain) {
+		return mapDomain(domain, function(string) {
+			return string.match(/^xn--/)
+				? decode(string.slice(4))
+				: string;
+		});
+	}
+
+	/*--------------------------------------------------------------------------*/
+
+	/** Define the public API */
+	Punycode = {
+		'version': '0.0.1337',
+		/**
+		 * An object of methods to convert from JavaScript's internal character
+		 * representation to Unicode and back.
+		 * @static
+		 * @memberOf Punycode
+		 * @type Object
+		 */
+		'utf16': {
+			'decode': utf16decode,
+			'encode': utf16encode
+		},
+		'decode': decode,
+		'encode': encode,
+		'toASCII': toASCII,
+		'toUnicode': toUnicode
+	};
+
+	/** Expose Punycode */
+	if (freeExports) {
+		if (typeof module == 'object' && module && module.exports == freeExports) {
+			// in Node.js
+			module.exports = Punycode;
+		} else {
+			// in Narwhal or Ringo
+			freeExports.Punycode = Punycode;
+		}
+	} else if (freeDefine) {
+		// via curl.js or RequireJS
+		freeDefine(function() {
+			return Punycode;
+		});
+	} else {
+		// in a browser or Rhino
+		window.Punycode = Punycode;
+	}
+
+}(this));