Issue 4350 - Update punycode.js to 2.0.0

lib/punycode.js

+/*
+ * Copyright (C) 2011-2016 Mathias Bynens <https://mathiasbynens.be/>
+ * Copyright (C) 2016 Eyeo GmbH (Minor modifications for compatibility.)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal 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.
+ */
+
 'use strict';
 
 /** Highest positive signed 32-bit float value */
 const maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1
 
 /** Bootstring parameters */
 const base = 36;
 const tMin = 1;
 const tMax = 26;
 const skew = 38;
@@ skipping 112 matching lines @@
 }
 
 /**
  * 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).
  */
-const ucs2encode = array => String.fromCodePoint(...array);
+const ucs2encode = array => String.fromCodePoint.apply(null, array);
 
 /**
  * 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.
  */
@@ skipping 123 matching lines @@
                 }
 
                 n += floor(i / out);
                 i %= out;
 
                 // Insert `n` at position `i` of the output.
                 output.splice(i++, 0, n);
 
         }
 
-        return String.fromCodePoint(...output);
+        return String.fromCodePoint.apply(null, 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.
  */
 const encode = function(input) {
         const output = [];
 
         // Convert the input in UCS-2 to an array of Unicode code points.
         input = ucs2decode(input);
 
         // Cache the length.
         let inputLength = input.length;
 
         // Initialize the state.
         let n = initialN;
         let delta = 0;
         let bias = initialBias;
 
         // Handle the basic code points.
-        for (const currentValue of input) {
+        for (let currentValue of input) {
                 if (currentValue < 0x80) {
                         output.push(stringFromCharCode(currentValue));
                 }
         }
 
         let basicLength = output.length;
         let handledCPCount = basicLength;
 
         // `handledCPCount` is the number of code points that have been handled;
         // `basicLength` is the number of basic code points.
 
         // Finish the basic string with a delimiter unless it's empty.
         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:
                 let m = maxInt;
-                for (const currentValue of input) {
+                for (let currentValue of input) {
                         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.
                 const handledCPCountPlusOne = handledCPCount + 1;
                 if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
                         error('overflow');
                 }
 
                 delta += (m - n) * handledCPCountPlusOne;
                 n = m;
 
-                for (const currentValue of input) {
+                for (let currentValue of input) {
                         if (currentValue < n && ++delta > maxInt) {
                                 error('overflow');
                         }
                         if (currentValue == n) {
                                 // Represent delta as a generalized variable-length integer.
                                 let q = delta;
                                 for (let k = base; /* no condition */; k += base) {
                                         const t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
                                         if (q < t) {
                                                 break;
@@ skipping 54 matching lines @@
         return mapDomain(input, function(string) {
                 return regexNonASCII.test(string)
                         ? 'xn--' + encode(string)
                         : string;
         });
 };
 
 /*--------------------------------------------------------------------------*/
 
 /** Define the public API */
-const punycode = {
+exports = {
         /**
          * A string representing the current Punycode.js version number.
          * @memberOf punycode
          * @type String
          */
         'version': '2.0.0',
         /**
          * 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
 };
-
-module.exports = punycode;