{“ast”:null,“code”:“function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }nn/*! mths.be/punycode v1.4.1 by @mathias */n;nn(function (root) {n /** Detect free variables */n var freeExports = (typeof exports === "undefined" ? "undefined" : _typeof(exports)) == 'object' && exports && !exports.nodeType && exports;n var freeModule = (typeof module === "undefined" ? "undefined" : _typeof(module)) == 'object' && module && !module.nodeType && module;n var freeGlobal = (typeof global === "undefined" ? "undefined" : _typeof(global)) == 'object' && global;nn if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal) {n root = freeGlobal;n }n /**n * The `punycode` object.n * @name punycoden * @type Objectn */nnn var punycode,nn /** Highest positive signed 32-bit float value */n maxInt = 2147483647,n // aka. 0x7FFFFFFF or 2^31-1nn /** Bootstring parameters */n base = 36,n tMin = 1,n tMax = 26,n skew = 38,n damp = 700,n initialBias = 72,n initialN = 128,n // 0x80n delimiter = '-',n // '\x2D'nn /** Regular expressions */n regexPunycode = /^xn–/,n regexNonASCII = /[^\x20-\x7E]/,n // unprintable ASCII chars + non-ASCII charsn regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g,n // RFC 3490 separatorsnn /** Error messages */n errors = {n 'overflow': 'Overflow: input needs wider integers to process',n 'not-basic': 'Illegal input >= 0x80 (not a basic code point)',n 'invalid-input': 'Invalid input'n },nn /** Convenience shortcuts */n baseMinusTMin = base - tMin,n floor = Math.floor,n stringFromCharCode = String.fromCharCode,nn /** Temporary variable */n key;n /————————————————————————–/nn /**n * A generic error utility function.n * @privaten * @param {String} type The error type.n * @returns {Error} Throws a `RangeError` with the applicable error message.n */nn function error(type) {n throw new RangeError(errors);n }n /**n * A generic `Array#map` utility function.n * @privaten * @param {Array} array The array to iterate over.n * @param {Function} callback The function that gets called for every arrayn * item.n * @returns {Array} A new array of values returned by the callback function.n */nnn function map(array, fn) {n var length = array.length;n var result = [];nn while (length–) {n result = fn(array);n }nn return result;n }n /**n * A simple `Array#map`-like wrapper to work with domain name strings or emailn * addresses.n * @privaten * @param {String} domain The domain name or email address.n * @param {Function} callback The function that gets called for everyn * character.n * @returns {Array} A new string of characters returned by the callbackn * function.n */nnn function mapDomain(string, fn) {n var parts = string.split('@');n var result = '';nn if (parts.length > 1) {n // In email addresses, only the domain name should be punycoded. Leaven // the local part (i.e. everything up to `@`) intact.n result = parts + '@';n string = parts;n } // Avoid `split(regex)` for IE8 compatibility. See #17.nnn string = string.replace(regexSeparators, '\x2E');n var labels = string.split('.');n var encoded = map(labels, fn).join('.');n return result + encoded;n }n /**n * Creates an array containing the numeric code points of each Unicoden * character in the string. While JavaScript uses UCS-2 internally,n * this function will convert a pair of surrogate halves (each of whichn * UCS-2 exposes as separate characters) into a single code point,n * matching UTF-16.n * @see `punycode.ucs2.encode`n * @see <tools.ietf.org/html/rfc3492#section-3.4n * @privaten */nnn function adapt(delta, numPoints, firstTime) {n var k = 0;n delta = firstTime ? floor(delta / damp) : delta >> 1;n delta += floor(delta / numPoints);nn for (;n /* no initialization */n delta > baseMinusTMin * tMax >> 1; k += base) {n delta = floor(delta / baseMinusTMin);n }nn return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));n }n /**n * Converts a Punycode string of ASCII-only symbols to a string of Unicoden * symbols.n * @memberOf punycoden * @param {String} input The Punycode string of ASCII-only symbols.n * @returns {String} The resulting string of Unicode symbols.n */nnn function decode(input) {n // Don't use UCS-2n var output = [],n inputLength = input.length,n out,n i = 0,n n = initialN,n bias = initialBias,n basic,n j,n index,n oldi,n w,n k,n digit,n t,nn /** Cached calculation results */n baseMinusT; // Handle the basic code points: let `basic` be the number of input coden // points before the last delimiter, or `0` if there is none, then copyn // the first basic code points to the output.nn basic = input.lastIndexOf(delimiter);nn if (basic < 0) {n basic = 0;n }nn for (j = 0; j < basic; ++j) {n // if it's not a basic code pointn if (input.charCodeAt(j) >= 0x80) {n error('not-basic');n }nn output.push(input.charCodeAt(j));n } // Main decoding loop: start just after the last delimiter if any basic coden // points were copied; start at the beginning otherwise.nnn for (index = basic > 0 ? basic + 1 : 0; index < inputLength;)n /* no final expression */n {n // `index` is the index of the next character to be consumed.n // Decode a generalized variable-length integer into `delta`,n // which gets added to `i`. The overflow checking is easiern // if we increase `i` as we go, then subtract off its startingn // value at the end to obtain `delta`.n for (oldi = i, w = 1, k = base;;n /* no condition */n k += base) {n if (index >= inputLength) {n error('invalid-input');n }nn digit = basicToDigit(input.charCodeAt(index++));nn if (digit >= base || digit > floor((maxInt - i) / w)) {n error('overflow');n }nn i += digit * w;n t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;nn if (digit < t) {n break;n }nn baseMinusT = base - t;nn if (w > floor(maxInt / baseMinusT)) {n error('overflow');n }nn w *= baseMinusT;n }nn out = output.length + 1;n bias = adapt(i - oldi, out, oldi == 0); // `i` was supposed to wrap around from `out` to `0`,n // incrementing `n` each time, so we'll fix that now:nn if (floor(i / out) > maxInt - n) {n error('overflow');n }nn n += floor(i / out);n i %= out; // Insert `n` at position `i` of the outputnn output.splice(i++, 0, n);n }nn return ucs2encode(output);n }n /**n * Converts a string of Unicode symbols (e.g. a domain name label) to an * Punycode string of ASCII-only symbols.n * @memberOf punycoden * @param {String} input The string of Unicode symbols.n * @returns {String} The resulting Punycode string of ASCII-only symbols.n */nnn function encode(input) {n var n,n delta,n handledCPCount,n basicLength,n bias,n j,n m,n q,n k,n t,n currentValue,n output = [],nn /** `inputLength` will hold the number of code points in `input`. */n inputLength,nn /** Cached calculation results */n handledCPCountPlusOne,n baseMinusT,n qMinusT; // Convert the input in UCS-2 to Unicodenn input = ucs2decode(input); // Cache the lengthnn inputLength = input.length; // Initialize the statenn n = initialN;n delta = 0;n bias = initialBias; // Handle the basic code pointsnn for (j = 0; j < inputLength; ++j) {n currentValue = input;nn if (currentValue < 0x80) {n output.push(stringFromCharCode(currentValue));n }n }nn handledCPCount = basicLength = output.length; // `handledCPCount` is the number of code points that have been handled;n // `basicLength` is the number of basic code points.n // Finish the basic string - if it is not empty - with a delimiternn if (basicLength) {n output.push(delimiter);n } // Main encoding loop:nnn while (handledCPCount < inputLength) {n // All non-basic code points < n have been handled already. Find the nextn // larger one:n for (m = maxInt, j = 0; j < inputLength; ++j) {n currentValue = input;nn if (currentValue >= n && currentValue < m) {n m = currentValue;n }n } // Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,n // but guard against overflownnn handledCPCountPlusOne = handledCPCount + 1;nn if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {n error('overflow');n }nn delta += (m - n) * handledCPCountPlusOne;n n = m;nn for (j = 0; j < inputLength; ++j) {n currentValue = input;nn if (currentValue < n && ++delta > maxInt) {n error('overflow');n }nn if (currentValue == n) {n // Represent delta as a generalized variable-length integern for (q = delta, k = base;;n /* no condition */n k += base) {n t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;nn if (q < t) {n break;n }nn qMinusT = q - t;n baseMinusT = base - t;n output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)));n q = floor(qMinusT / baseMinusT);n }nn output.push(stringFromCharCode(digitToBasic(q, 0)));n bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);n delta = 0;n ++handledCPCount;n }n }nn ++delta;n ++n;n }nn return output.join('');n }n /**n * Converts a Punycode string representing a domain name or an email addressn * to Unicode. Only the Punycoded parts of the input will be converted, i.e.n * it doesn't matter if you call it on a string that has already beenn * converted to Unicode.n * @memberOf punycoden * @param {String} input The Punycoded domain name or email address ton * convert to Unicode.n * @returns {String} The Unicode representation of the given Punycoden * string.n */nnn function toUnicode(input) {n return mapDomain(input, function (string) {n return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;n });n }n /**n * Converts a Unicode string representing a domain name or an email address ton * Punycode. Only the non-ASCII parts of the domain name will be converted,n * i.e. it doesn't matter if you call it with a domain that's already inn * ASCII.n * @memberOf punycoden * @param {String} input The domain name or email address to convert, as an * Unicode string.n * @returns {String} The Punycode representation of the given domain name orn * email address.n */nnn function toASCII(input) {n return mapDomain(input, function (string) {n return regexNonASCII.test(string) ? 'xn–' + encode(string) : string;n });n }n /————————————————————————–/nn /** Define the public API */nnn punycode = {n /**n * A string representing the current Punycode.js version number.n * @memberOf punycoden * @type Stringn */n 'version': '1.4.1',nn /**n * An object of methods to convert from JavaScript's internal charactern * representation (UCS-2) to Unicode code points, and back.n * @see <freeExports = punycode);n }n }n } else {n // in Rhino or a web browsern root.punycode = punycode;n }n})(this);”,“map”:null,“metadata”:{},“sourceType”:“module”}