Replace deprecated punycode with userland package

closes: #967

dist/markdown-it.js

@@ -7455,32 +7455,31 @@
 	 * Override to modify basic RegExp-s.
 	 **/  LinkifyIt.prototype.onCompile = function onCompile() {};
   var linkifyIt = LinkifyIt;
-  /*! https://mths.be/punycode v1.4.1 by @mathias */
+  /** Highest positive signed 32-bit float value */  const maxInt = 2147483647;
-  /** Highest positive signed 32-bit float value */  var maxInt = 2147483647;
  // aka. 0x7FFFFFFF or 2^31-1
-  /** Bootstring parameters */  var base = 36;
+  /** Bootstring parameters */  const base = 36;
-  var tMin = 1;
+  const tMin = 1;
-  var tMax = 26;
+  const tMax = 26;
-  var skew = 38;
+  const skew = 38;
-  var damp = 700;
+  const damp = 700;
-  var initialBias = 72;
+  const initialBias = 72;
-  var initialN = 128;
+  const initialN = 128;
  // 0x80
-    var delimiter = "-";
+    const delimiter = "-";
  // '\x2D'
-  /** Regular expressions */  var regexPunycode = /^xn--/;
+  /** Regular expressions */  const regexPunycode = /^xn--/;
-  var regexNonASCII = /[^\x20-\x7E]/;
+  const regexNonASCII = /[^\0-\x7F]/;
- // unprintable ASCII chars + non-ASCII chars
+ // Note: U+007F DEL is excluded too.
-    var regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g;
+    const regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g;
  // RFC 3490 separators
-  /** Error messages */  var errors = {
+  /** Error messages */  const 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 */  var baseMinusTMin = base - tMin;
+  /** Convenience shortcuts */  const baseMinusTMin = base - tMin;
-  var floor = Math.floor;
+  const floor = Math.floor;
-  var stringFromCharCode = String.fromCharCode;
+  const stringFromCharCode = String.fromCharCode;
   /*--------------------------------------------------------------------------*/
   /**
 	 * A generic error utility function.
@@ -7497,11 +7496,11 @@
 	 * @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) {
+	 */  function map(array, callback) {
-    var length = array.length;
+    const result = [];
-    var result = [];
+    let length = array.length;
     while (length--) {
-      result[length] = fn(array[length]);
+      result[length] = callback(array[length]);
     }
     return result;
   }
@@ -7512,21 +7511,21 @@
 	 * @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
+	 * @returns {String} A new string of characters returned by the callback
 	 * function.
-	 */  function mapDomain(string, fn) {
+	 */  function mapDomain(domain, callback) {
-    var parts = string.split("@");
+    const parts = domain.split("@");
-    var result = "";
+    let 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];
+      domain = parts[1];
     }
     // Avoid `split(regex)` for IE8 compatibility. See #17.
-        string = string.replace(regexSeparators, ".");
+        domain = domain.replace(regexSeparators, ".");
-    var labels = string.split(".");
+    const labels = domain.split(".");
-    var encoded = map(labels, fn).join(".");
+    const encoded = map(labels, callback).join(".");
     return result + encoded;
   }
   /**
@@ -7542,18 +7541,20 @@
 	 * @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;
+    const output = [];
+    let counter = 0;
+    const length = string.length;
     while (counter < length) {
-      value = string.charCodeAt(counter++);
+      const value = string.charCodeAt(counter++);
       if (value >= 55296 && value <= 56319 && counter < length) {
-        // high surrogate, and there is a next character
+        // It's a high surrogate, and there is a next character.
-        extra = string.charCodeAt(counter++);
+        const extra = string.charCodeAt(counter++);
         if ((extra & 64512) == 56320) {
-          // low surrogate
+          // Low surrogate.
           output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
         } else {
-          // unmatched surrogate; only append this code unit, in case the next
+          // It's an unmatched surrogate; only append this code unit, in case the
-          // code unit is the high surrogate of a surrogate pair
+          // next code unit is the high surrogate of a surrogate pair.
           output.push(value);
           counter--;
         }
@@ -7570,18 +7571,7 @@
 	 * @name encode
 	 * @param {Array} codePoints The array of numeric code points.
 	 * @returns {String} The new Unicode string (UCS-2).
-	 */  function ucs2encode(array) {
+	 */  const ucs2encode = codePoints => String.fromCodePoint(...codePoints)
-    return map(array, (function(value) {
-      var output = "";
-      if (value > 65535) {
-        value -= 65536;
-        output += stringFromCharCode(value >>> 10 & 1023 | 55296);
-        value = 56320 | value & 1023;
-      }
-      output += stringFromCharCode(value);
-      return output;
-    })).join("");
-  }
   /**
 	 * Converts a basic code point into a digit/integer.
 	 * @see `digitToBasic()`
@@ -7590,18 +7580,19 @@
 	 * @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) {
+  const basicToDigit = function(codePoint) {
-      return codePoint - 22;
+    if (codePoint >= 48 && codePoint < 58) {
+      return 26 + (codePoint - 48);
     }
-    if (codePoint - 65 < 26) {
+    if (codePoint >= 65 && codePoint < 91) {
       return codePoint - 65;
     }
-    if (codePoint - 97 < 26) {
+    if (codePoint >= 97 && codePoint < 123) {
       return codePoint - 97;
     }
     return base;
-  }
+  };
   /**
 	 * Converts a digit/integer into a basic code point.
 	 * @see `basicToDigit()`
@@ -7612,43 +7603,45 @@
 	 * `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) {
+	 */  const digitToBasic = function(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) {
+	 */  const adapt = function(delta, numPoints, firstTime) {
-    var k = 0;
+    let k = 0;
     delta = firstTime ? floor(delta / damp) : delta >> 1;
     delta += floor(delta / numPoints);
     for (;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) {
+	 */  const decode = function(input) {
-    // Don't use UCS-2
+    // 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, 
+    const output = [];
-    /** Cached calculation results */
+    const inputLength = input.length;
-    baseMinusT;
+    let i = 0;
+    let n = initialN;
+    let bias = initialBias;
     // 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);
+        let basic = input.lastIndexOf(delimiter);
     if (basic < 0) {
       basic = 0;
     }
-    for (j = 0; j < basic; ++j) {
+    for (let j = 0; j < basic; ++j) {
       // if it's not a basic code point
       if (input.charCodeAt(j) >= 128) {
         error("not-basic");
@@ -7657,32 +7650,36 @@
     }
     // 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; ) {
+        for (let index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {
       // `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; ;k += base) {
+      const oldi = i;
+      for (let w = 1, k = base; ;k += base) {
         if (index >= inputLength) {
           error("invalid-input");
         }
-        digit = basicToDigit(input.charCodeAt(index++));
+        const digit = basicToDigit(input.charCodeAt(index++));
-        if (digit >= base || digit > floor((maxInt - i) / w)) {
+        if (digit >= base) {
+          error("invalid-input");
+        }
+        if (digit > floor((maxInt - i) / w)) {
           error("overflow");
         }
         i += digit * w;
-        t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+        const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
         if (digit < t) {
           break;
         }
-        baseMinusT = base - t;
+        const baseMinusT = base - t;
         if (w > floor(maxInt / baseMinusT)) {
           error("overflow");
         }
         w *= baseMinusT;
       }
-      out = output.length + 1;
+      const 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:
@@ -7691,42 +7688,38 @@
       }
       n += floor(i / out);
       i %= out;
-      // Insert `n` at position `i` of the output
+      // Insert `n` at position `i` of the output.
             output.splice(i++, 0, n);
     }
-    return ucs2encode(output);
+    return String.fromCodePoint(...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) {
+	 */  const encode = function(input) {
-    var n, delta, handledCPCount, basicLength, bias, j, m, q, k, t, currentValue, output = [], 
+    const output = [];
-    /** `inputLength` will hold the number of code points in `input`. */
+    // Convert the input in UCS-2 to an array of Unicode code points.
-    inputLength, 
-    /** Cached calculation results */
-    handledCPCountPlusOne, baseMinusT, qMinusT;
-    // Convert the input in UCS-2 to Unicode
         input = ucs2decode(input);
-    // Cache the length
+    // Cache the length.
-        inputLength = input.length;
+        const inputLength = input.length;
-    // Initialize the state
+    // Initialize the state.
-        n = initialN;
+        let n = initialN;
-    delta = 0;
+    let delta = 0;
-    bias = initialBias;
+    let bias = initialBias;
-    // Handle the basic code points
+    // Handle the basic code points.
-        for (j = 0; j < inputLength; ++j) {
+        for (const currentValue of input) {
-      currentValue = input[j];
       if (currentValue < 128) {
         output.push(stringFromCharCode(currentValue));
       }
     }
-    handledCPCount = basicLength = output.length;
+    const 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 - if it is not empty - with a delimiter
+    // Finish the basic string with a delimiter unless it's empty.
         if (basicLength) {
       output.push(delimiter);
     }
@@ -7734,39 +7727,39 @@
         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) {
+      let m = maxInt;
-        currentValue = input[j];
+      for (const 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
+      // but guard against overflow.
-            handledCPCountPlusOne = handledCPCount + 1;
+            const handledCPCountPlusOne = handledCPCount + 1;
       if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
         error("overflow");
       }
       delta += (m - n) * handledCPCountPlusOne;
       n = m;
-      for (j = 0; j < inputLength; ++j) {
+      for (const currentValue of input) {
-        currentValue = input[j];
         if (currentValue < n && ++delta > maxInt) {
           error("overflow");
         }
-        if (currentValue == n) {
+        if (currentValue === n) {
-          // Represent delta as a generalized variable-length integer
+          // Represent delta as a generalized variable-length integer.
-          for (q = delta, k = base; ;k += base) {
+          let q = delta;
-            t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+          for (let k = base; ;k += base) {
+            const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
             if (q < t) {
               break;
             }
-            qMinusT = q - t;
+            const qMinusT = q - t;
-            baseMinusT = base - t;
+            const 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);
+          bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
           delta = 0;
           ++handledCPCount;
         }
@@ -7775,7 +7768,7 @@
       ++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.
@@ -7786,11 +7779,11 @@
 	 * convert to Unicode.
 	 * @returns {String} The Unicode representation of the given Punycode
 	 * string.
-	 */  function toUnicode(input) {
+	 */  const toUnicode = function(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,
@@ -7801,38 +7794,43 @@
 	 * Unicode string.
 	 * @returns {String} The Punycode representation of the given domain name or
 	 * email address.
-	 */  function toASCII(input) {
+	 */  const toASCII = function(input) {
     return mapDomain(input, (function(string) {
       return regexNonASCII.test(string) ? "xn--" + encode(string) : string;
     }));
-  }
+  };
-  var version = "1.4.1";
+  /*--------------------------------------------------------------------------*/
+  /** Define the public API */  const punycode$1 = {
+    /**
+		 * A string representing the current Punycode.js version number.
+		 * @memberOf punycode
+		 * @type String
+		 */
+    version: "2.3.1",
     /**
 		 * 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
-	 */  var ucs2 = {
+		 */
+    ucs2: {
       decode: ucs2decode,
       encode: ucs2encode
-  };
+    },
-  var punycode$1 = {
+    decode: decode,
-    version: version,
-    ucs2: ucs2,
-    toASCII: toASCII,
-    toUnicode: toUnicode,
     encode: encode,
-    decode: decode
+    toASCII: toASCII,
+    toUnicode: toUnicode
   };
-  var punycode$2 =  Object.freeze({
+  var punycode_es6 =  Object.freeze({
     __proto__: null,
+    ucs2decode: ucs2decode,
+    ucs2encode: ucs2encode,
     decode: decode,
     encode: encode,
-    toUnicode: toUnicode,
     toASCII: toASCII,
-    version: version,
+    toUnicode: toUnicode,
-    ucs2: ucs2,
     default: punycode$1
   });
   // markdown-it default options
@@ -7951,7 +7949,7 @@
       }
     }
   };
-  var punycode =  getAugmentedNamespace(punycode$2);
+  var punycode =  getAugmentedNamespace(punycode_es6);
   var config = {
     default: _default,
     zero: zero,

lib/index.js

@@ -11,7 +11,7 @@ var ParserBlock  = require('./parser_block');
 var ParserInline = require('./parser_inline');
 var LinkifyIt    = require('linkify-it');
 var mdurl        = require('mdurl');
-var punycode     = require('punycode');
+var punycode     = require('punycode/');
 
 
 var config = {

package.json

@@ -41,6 +41,7 @@
     "entities": "~3.0.1",
     "linkify-it": "^4.0.1",
     "mdurl": "^1.0.1",
+    "punycode": "^2.3.1",
     "uc.micro": "^1.0.5"
   },
   "devDependencies": {