lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

punycode: update to v2.0.0 

Punycode v2.0.0 drops support for old and non-Node environments.

PR-URL: https://github.com/nodejs/node/pull/7267
Fixes: https://github.com/nodejs/node/issues/7224
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Roman Reiss <me@silverwind.io>
v7.x
Mathias Bynens 9 years ago
committed by silverwind
parent
336b027411
commit
b77eb8c66c
No known key found for this signature in database GPG Key ID: 2E62B41C93869443
2 changed files with 389 additions and 479 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 860
      lib/punycode.js
  2. 8
      test/message/core_line_numbers.out

860
lib/punycode.js
View File

@ -1,530 +1,440 @@
/*! https://mths.be/punycode v1.3.2 by @mathias */ 'use strict';
;(function(root) {
/** Highest positive signed 32-bit float value */
/** Detect free variables */ const maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1
var freeExports = typeof exports == 'object' && exports &&
!exports.nodeType && exports; /** Bootstring parameters */
var freeModule = typeof module == 'object' && module && const base = 36;
!module.nodeType && module; const tMin = 1;
var freeGlobal = typeof global == 'object' && global; const tMax = 26;
if ( const skew = 38;
freeGlobal.global === freeGlobal || const damp = 700;
freeGlobal.window === freeGlobal || const initialBias = 72;
freeGlobal.self === freeGlobal const initialN = 128; // 0x80
) { const delimiter = '-'; // '\x2D'
root = freeGlobal;
/** Regular expressions */
const regexPunycode = /^xn--/;
const regexNonASCII = /[^\x20-\x7E]/; // unprintable ASCII chars + non-ASCII chars
const regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g; // RFC 3490 separators
/** 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 */
const baseMinusTMin = base - tMin;
const floor = Math.floor;
const stringFromCharCode = String.fromCharCode;
/*--------------------------------------------------------------------------*/
/**
* A generic error utility function.
* @private
* @param {String} type The error type.
* @returns {Error} Throws a `RangeError` with the applicable error message.
*/
function error(type) {
throw new RangeError(errors[type]);
}
/**
* A generic `Array#map` utility function.
* @private
* @param {Array} array The array to iterate over.
* @param {Function} callback The function that gets called for every array
* item.
* @returns {Array} A new array of values returned by the callback function.
*/
function map(array, fn) {
const result = [];
let length = array.length;
while (length--) {
result[length] = fn(array[length]);
} }
return result;
/** }
* The `punycode` object.
* @name punycode /**
* @type Object * A simple `Array#map`-like wrapper to work with domain name strings or email
*/ * addresses.
var punycode, * @private
* @param {String} domain The domain name or email address.
/** Highest positive signed 32-bit float value */ * @param {Function} callback The function that gets called for every
maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1 * character.
* @returns {Array} A new string of characters returned by the callback
/** Bootstring parameters */ * function.
base = 36, */
tMin = 1, function mapDomain(string, fn) {
tMax = 26, const parts = string.split('@');
skew = 38, let result = '';
damp = 700, if (parts.length > 1) {
initialBias = 72, // In email addresses, only the domain name should be punycoded. Leave
initialN = 128, // 0x80 // the local part (i.e. everything up to `@`) intact.
delimiter = '-', // '\x2D' result = parts[0] + '@';
string = parts[1];
/** Regular expressions */
regexPunycode = /^xn--/,
regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators
/** Error messages */
errors = {
'overflow': 'Overflow: input needs wider integers to process',
'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
'invalid-input': 'Invalid input'
},
/** Convenience shortcuts */
baseMinusTMin = base - tMin,
floor = Math.floor,
stringFromCharCode = String.fromCharCode,
/** Temporary variable */
key;
/*--------------------------------------------------------------------------*/
/**
* A generic error utility function.
* @private
* @param {String} type The error type.
* @returns {Error} Throws a `RangeError` with the applicable error message.
*/
function error(type) {
throw new RangeError(errors[type]);
} }
// Avoid `split(regex)` for IE8 compatibility. See #17.
/** string = string.replace(regexSeparators, '\x2E');
* A generic `Array#map` utility function. const labels = string.split('.');
* @private const encoded = map(labels, fn).join('.');
* @param {Array} array The array to iterate over. return result + encoded;
* @param {Function} callback The function that gets called for every array }
* item.
* @returns {Array} A new array of values returned by the callback function. /**
*/ * Creates an array containing the numeric code points of each Unicode
function map(array, fn) { * character in the string. While JavaScript uses UCS-2 internally,
var length = array.length; * this function will convert a pair of surrogate halves (each of which
var result = []; * UCS-2 exposes as separate characters) into a single code point,
while (length--) { * matching UTF-16.
result[length] = fn(array[length]); * @see `punycode.ucs2.encode`
} * @see <https://mathiasbynens.be/notes/javascript-encoding>
return result; * @memberOf punycode.ucs2
} * @name decode
* @param {String} string The Unicode input string (UCS-2).
/** * @returns {Array} The new array of code points.
* A simple `Array#map`-like wrapper to work with domain name strings or email */
* addresses. function ucs2decode(string) {
* @private const output = [];
* @param {String} domain The domain name or email address. let counter = 0;
* @param {Function} callback The function that gets called for every const length = string.length;
* character. while (counter < length) {
* @returns {Array} A new string of characters returned by the callback const value = string.charCodeAt(counter++);
* function. if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
*/ // It's a high surrogate, and there is a next character.
function mapDomain(string, fn) { const extra = string.charCodeAt(counter++);
var parts = string.split('@'); if ((extra & 0xFC00) == 0xDC00) { // Low surrogate.
var result = ''; output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
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 { } else {
// It's an unmatched surrogate; only append this code unit, in case the
// next code unit is the high surrogate of a surrogate pair.
output.push(value); output.push(value);
counter--;
} }
} else {
output.push(value);
} }
return output;
} }
return output;
/** }
* Creates a string based on an array of numeric code points.
* @see `punycode.ucs2.decode` /**
* @memberOf punycode.ucs2 * Creates a string based on an array of numeric code points.
* @name encode * @see `punycode.ucs2.decode`
* @param {Array} codePoints The array of numeric code points. * @memberOf punycode.ucs2
* @returns {String} The new Unicode string (UCS-2). * @name encode
*/ * @param {Array} codePoints The array of numeric code points.
function ucs2encode(array) { * @returns {String} The new Unicode string (UCS-2).
return map(array, function(value) { */
var output = ''; const ucs2encode = array => String.fromCodePoint(...array);
if (value > 0xFFFF) {
value -= 0x10000; /**
output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800); * Converts a basic code point into a digit/integer.
value = 0xDC00 | value & 0x3FF; * @see `digitToBasic()`
} * @private
output += stringFromCharCode(value); * @param {Number} codePoint The basic numeric code point value.
return output; * @returns {Number} The numeric value of a basic code point (for use in
}).join(''); * representing integers) in the range `0` to `base - 1`, or `base` if
* the code point does not represent a value.
*/
const basicToDigit = function(codePoint) {
if (codePoint - 0x30 < 0x0A) {
return codePoint - 0x16;
} }
if (codePoint - 0x41 < 0x1A) {
/** return codePoint - 0x41;
* 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;
} }
if (codePoint - 0x61 < 0x1A) {
/** return codePoint - 0x61;
* 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);
} }
return base;
/** };
* Bias adaptation function as per section 3.4 of RFC 3492.
* https://tools.ietf.org/html/rfc3492#section-3.4 /**
* @private * Converts a digit/integer into a basic code point.
*/ * @see `basicToDigit()`
function adapt(delta, numPoints, firstTime) { * @private
var k = 0; * @param {Number} digit The numeric value of a basic code point.
delta = firstTime ? floor(delta / damp) : delta >> 1; * @returns {Number} The basic code point whose value (when used for
delta += floor(delta / numPoints); * representing integers) is `digit`, which needs to be in the range
for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) { * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
delta = floor(delta / baseMinusTMin); * used; else, the lowercase form is used. The behavior is undefined
} * if `flag` is non-zero and `digit` has no uppercase form.
return floor(k + (baseMinusTMin + 1) * delta / (delta + skew)); */
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
*/
const adapt = function(delta, numPoints, firstTime) {
let 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.
*/
const decode = function(input) {
// Don't use UCS-2.
const output = [];
const inputLength = input.length;
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.
let basic = input.lastIndexOf(delimiter);
if (basic < 0) {
basic = 0;
} }
/** for (let j = 0; j < basic; ++j) {
* Converts a Punycode string of ASCII-only symbols to a string of Unicode // if it's not a basic code point
* symbols. if (input.charCodeAt(j) >= 0x80) {
* @memberOf punycode error('not-basic');
* @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));
} }
output.push(input.charCodeAt(j));
}
// Main decoding loop: start just after the last delimiter if any basic code // Main decoding loop: start just after the last delimiter if any basic code
// points were copied; start at the beginning otherwise. // 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++)); for (let index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
if (digit >= base || digit > floor((maxInt - i) / w)) { // `index` is the index of the next character to be consumed.
error('overflow'); // 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`.
let oldi = i;
for (let w = 1, k = base; /* no condition */; k += base) {
i += digit * w; if (index >= inputLength) {
t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias); error('invalid-input');
}
if (digit < t) { const digit = basicToDigit(input.charCodeAt(index++));
break;
}
baseMinusT = base - t; if (digit >= base || digit > floor((maxInt - i) / w)) {
if (w > floor(maxInt / baseMinusT)) { error('overflow');
error('overflow'); }
}
w *= baseMinusT; i += digit * w;
const t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
if (digit < t) {
break;
} }
out = output.length + 1; const baseMinusT = base - t;
bias = adapt(i - oldi, out, oldi == 0); if (w > floor(maxInt / baseMinusT)) {
// `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'); error('overflow');
} }
n += floor(i / out); w *= baseMinusT;
i %= out;
// Insert `n` at position `i` of the output
output.splice(i++, 0, n);
} }
return ucs2encode(output); const out = output.length + 1;
} bias = adapt(i - oldi, out, oldi == 0);
/** // `i` was supposed to wrap around from `out` to `0`,
* Converts a string of Unicode symbols (e.g. a domain name label) to a // incrementing `n` each time, so we'll fix that now:
* Punycode string of ASCII-only symbols. if (floor(i / out) > maxInt - n) {
* @memberOf punycode error('overflow');
* @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; n += floor(i / out);
i %= out;
// `handledCPCount` is the number of code points that have been handled; // Insert `n` at position `i` of the output.
// `basicLength` is the number of basic code points. output.splice(i++, 0, n);
// Finish the basic string - if it is not empty - with a delimiter }
if (basicLength) {
output.push(delimiter); 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.
*/
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) {
if (currentValue < 0x80) {
output.push(stringFromCharCode(currentValue));
} }
}
// Main encoding loop: let basicLength = output.length;
while (handledCPCount < inputLength) { let handledCPCount = basicLength;
// All non-basic code points < n have been handled already. Find the next // `handledCPCount` is the number of code points that have been handled;
// larger one: // `basicLength` is the number of basic code points.
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>, // Finish the basic string with a delimiter unless it's empty.
// but guard against overflow if (basicLength) {
handledCPCountPlusOne = handledCPCount + 1; output.push(delimiter);
if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) { }
error('overflow');
}
delta += (m - n) * handledCPCountPlusOne; // Main encoding loop:
n = m; while (handledCPCount < inputLength) {
for (j = 0; j < inputLength; ++j) { // All non-basic code points < n have been handled already. Find the next
currentValue = input[j]; // larger one:
let m = maxInt;
for (const currentValue of input) {
if (currentValue >= n && currentValue < m) {
m = currentValue;
}
}
if (currentValue < n && ++delta > maxInt) { // Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
error('overflow'); // but guard against overflow.
} const handledCPCountPlusOne = handledCPCount + 1;
if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
error('overflow');
}
if (currentValue == n) { delta += (m - n) * handledCPCountPlusOne;
// Represent delta as a generalized variable-length integer n = m;
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))); for (const currentValue of input) {
bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength); if (currentValue < n && ++delta > maxInt) {
delta = 0; error('overflow');
++handledCPCount; }
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;
}
const qMinusT = q - 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);
delta = 0;
++handledCPCount;
} }
}
++delta; ++delta;
++n; ++n;
}
return output.join('');
} }
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.
*/
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,
* 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.
*/
const toASCII = function(input) {
return mapDomain(input, function(string) {
return regexNonASCII.test(string)
? 'xn--' + encode(string)
: string;
});
};
/*--------------------------------------------------------------------------*/
/** Define the public API */
const punycode = {
/** /**
* Converts a Punycode string representing a domain name or an email address * A string representing the current Punycode.js version number.
* 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 * @memberOf punycode
* @param {String} input The Punycoded domain name or email address to * @type String
* convert to Unicode.
* @returns {String} The Unicode representation of the given Punycode
* string.
*/ */
function toUnicode(input) { 'version': '2.0.0',
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 * An object of methods to convert from JavaScript's internal character
* Punycode. Only the non-ASCII parts of the domain name will be converted, * representation (UCS-2) to Unicode code points, and back.
* i.e. it doesn't matter if you call it with a domain that's already in * @see <https://mathiasbynens.be/notes/javascript-encoding>
* ASCII.
* @memberOf punycode * @memberOf punycode
* @param {String} input The domain name or email address to convert, as a * @type Object
* Unicode string.
* @returns {String} The Punycode representation of the given domain name or
* email address.
*/ */
function toASCII(input) { 'ucs2': {
return mapDomain(input, function(string) { 'decode': ucs2decode,
return regexNonASCII.test(string) 'encode': ucs2encode
? 'xn--' + encode(string) },
: string; 'decode': decode,
}); 'encode': encode,
} 'toASCII': toASCII,
'toUnicode': toUnicode
/*--------------------------------------------------------------------------*/ };
/** 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)); module.exports = punycode;

8
test/message/core_line_numbers.out
View File

@ -1,9 +1,9 @@
punycode.js:67 punycode.js:42
throw new RangeError(errors[type]); throw new RangeError(errors[type]);
^ ^
RangeError: Invalid input RangeError: Invalid input
at error (punycode.js:67:*) at error (punycode.js:42:*)
at Object.decode (punycode.js:*:*) at Object.decode (punycode.js:*:*)
at Object.<anonymous> (*test*message*core_line_numbers.js:*:*) at Object.<anonymous> (*test*message*core_line_numbers.js:*:*)
at Module._compile (module.js:*:*) at Module._compile (module.js:*:*)

Write Preview
Loading…
Cancel
Save