punycode-esm 1.0.6 → 1.0.8

package/dist/punycode.js

@@ -1,200 +1,112 @@
-import { checkOverflow, rangeError } from './lib/errors.js';
-/** Highest positive signed 32-bit float value */
-const maxInt = 0x7FFFFFFF;
-/** Bootstring parameters */
+import { checkOverflow, rangeError } from '#errors';
+const maxInt = 0x7fffffff;
 const base = 36;
 const tMin = 1;
 const tMax = 26;
 const skew = 38;
 const damp = 700;
 const initialBias = 72;
-const initialN = 128; // 0x80
-const delimiter = '-'; // '\x2D'
+const initialN = 128;
+const delimiter = '-';
 const baseMinusTMin = base - tMin;
-/** Regular expressions */
-const regexNonASCII = /[^\0-\u007E]/u; // Non-ASCII chars
-const regexSeparators = /[\u002E\u3002\uFF0E\uFF61]/gu; // RFC 3490 separators
-/**
- * A simple `Array#map`-like wrapper to work with domain name strings or email addresses.
- *
- * @param {string} domain - The domain name or email address.
- * @param {Function} callback - The function that gets called for every character.
- * @returns {string} A new string of characters returned by the callback function.
- */
-const mapDomain = (domain, callback) => {
+const regexNonASCII = /[^\0-\u007E]/u;
+const regexSeparators = /[\u002E\u3002\uFF0E\uFF61]/gu;
+const mapDomain = (domain, callback)=>{
     const [first, ...rest] = domain.split('@');
     let result;
     let toEncode;
     if (rest.length > 0) {
-        // In email addresses, only the domain name should be punycoded. Leave
-        // the local part (i.e. everything up to `@`) intact.
         result = `${first}@`;
         toEncode = rest.join('@');
-    }
-    else {
+    } else {
         result = '';
         toEncode = first;
     }
     const labels = toEncode.split(regexSeparators);
-    const encoded = labels.map(x => callback(x)).join('.');
+    const encoded = labels.map((x)=>callback(x)).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 {@link https://mathiasbynens.be/notes/javascript-encoding}
- *
- * @param {string} string - The Unicode input string (UCS-2).
- * @returns {number[]} The new array of code points.
- */
-export const ucs2Decode = (string) => {
+export const ucs2Decode = (string)=>{
     const output = [];
     let counter = 0;
-    while (counter < string.length) {
-        // eslint-disable-next-line unicorn/prefer-code-point
+    while(counter < string.length){
         const value = string.charCodeAt(counter++);
-        if (value >= 0xD800 && value <= 0xDBFF && counter < string.length) {
-            // It's a high surrogate, and there is a next character.
-            // eslint-disable-next-line unicorn/prefer-code-point
+        if (value >= 0xd800 && value <= 0xdbff && counter < string.length) {
             const extra = string.charCodeAt(counter++);
-            // eslint-disable-next-line no-bitwise
-            if ((extra & 0xFC00) === 0xDC00) { // Low surrogate.
-                // eslint-disable-next-line no-bitwise
-                output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
-            }
-            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.
+            if ((extra & 0xfc00) === 0xdc00) {
+                output.push(((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000);
+            } else {
                 output.push(value);
                 counter--;
             }
-        }
-        else {
+        } else {
             output.push(value);
         }
     }
     return output;
 };
-/**
- * Creates a string based on an array of numeric code points.
- *
- * @param {number[]} codePoints - The array of numeric code points.
- * @returns {string} The new Unicode string (UCS-2).
- */
-export const ucs2Encode = (codePoints) => String.fromCodePoint(...codePoints);
-/**
- * Converts a basic code point into a digit/integer.
- *
- * @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.
- */
-const basicToDigit = (codePoint) => {
-    if (codePoint - 0x30 < 0x0A) {
+export const ucs2Encode = (codePoints)=>String.fromCodePoint(...codePoints);
+const basicToDigit = (codePoint)=>{
+    if (codePoint - 0x30 < 0x0a) {
         return codePoint - 0x16;
     }
-    if (codePoint - 0x41 < 0x1A) {
+    if (codePoint - 0x41 < 0x1a) {
         return codePoint - 0x41;
     }
-    if (codePoint - 0x61 < 0x1A) {
+    if (codePoint - 0x61 < 0x1a) {
         return codePoint - 0x61;
     }
     return base;
 };
-/**
- * Converts a digit/integer into a basic code point.
- *
- * @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.
- */
-const digitToBasic = (digit) => {
+const digitToBasic = (digit)=>{
     const plus22 = digit + 22;
-    //  0..25 map to ASCII a..z or A..Z
-    // 26..35 map to ASCII 0..9
     return digit < 26 ? plus22 + 75 : plus22;
 };
-/**
- * Bias adaptation function as per section 3.4 of RFC 3492.
- *
- * @see {@link https://tools.ietf.org/html/rfc3492#section-3.4}
- *
- * @param {number} delta - delta
- * @param {number} numPoints - num points
- * @param {boolean} firstTime - first time
- * @returns {number} bias adaptation
- */
-const adapt = (delta, numPoints, firstTime) => {
+const adapt = (delta, numPoints, firstTime)=>{
     let k = 0;
-    // eslint-disable-next-line no-bitwise
     let newDelta = firstTime ? Math.floor(delta / damp) : delta >> 1;
     newDelta += Math.floor(newDelta / numPoints);
-    // eslint-disable-next-line no-bitwise
     const minCheck = baseMinusTMin * tMax >> 1;
-    while (newDelta > minCheck) {
+    while(newDelta > minCheck){
         newDelta = Math.floor(newDelta / baseMinusTMin);
         k += base;
     }
     return Math.floor(k + (baseMinusTMin + 1) * newDelta / (newDelta + skew));
 };
-/**
- * Converts a Punycode string of ASCII-only symbols to a string of Unicode symbols.
- *
- * @param {string} input - The Punycode string of ASCII-only symbols.
- * @returns {string} The resulting string of Unicode symbols.
- */
-export const decode = (input) => {
-    // Don't use UCS-2.
+export const decode = (input)=>{
     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) {
+    for(let j = 0; j < basic; ++j){
         const codePoint = input.codePointAt(j);
-        // If it's not a basic code point
         if (codePoint >= 0x80) {
             rangeError('not-basic');
         }
         output.push(codePoint);
     }
-    // Main decoding loop: start just after the last delimiter if any basic code
-    // points were copied; start at the beginning otherwise.
     let index = basic > 0 ? basic + 1 : 0;
-    while (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`.
+    while(index < inputLength){
         const oldi = i;
         let w = 1;
         let k = base;
-        while (true) {
-            checkOverflow(index, inputLength, { gte: true, error: 'invalid-input' });
+        while(true){
+            checkOverflow(index, inputLength, {
+                gte: true,
+                error: 'invalid-input'
+            });
             const digit = basicToDigit(input.codePointAt(index++));
-            checkOverflow(digit, base, { gte: true });
+            checkOverflow(digit, base, {
+                gte: true
+            });
             checkOverflow(digit, Math.floor((maxInt - i) / w));
             i += digit * w;
-            const t = k <= bias ?
-                tMin :
-                // eslint-disable-next-line @typescript-eslint/no-extra-parens
-                (k >= bias + tMax ? tMax : k - bias);
+            const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
             if (digit < t) {
                 break;
             }
@@ -205,76 +117,50 @@ export const decode = (input) => {
         }
         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:
         checkOverflow(Math.floor(i / out), maxInt - n);
         n += Math.floor(i / out);
         i %= out;
-        // Insert `n` at position `i` of the output.
         output.splice(i++, 0, n);
     }
     return String.fromCodePoint(...output);
 };
-/**
- * Converts a string of Unicode symbols (e.g. a domain name label) to a
- * Punycode string of ASCII-only symbols.
- *
- * @param {string} input - The string of Unicode symbols.
- * @returns {string} The resulting Punycode string of ASCII-only symbols.
- */
-export const encode = (input) => {
+export const encode = (input)=>{
     const output = [];
-    // Convert the input in UCS-2 to an array of Unicode code points.
     const decodedInput = ucs2Decode(input);
-    // Cache the length.
     const inputLength = decodedInput.length;
-    // Initialize the state.
     let n = initialN;
     let delta = 0;
     let bias = initialBias;
-    // Handle the basic code points.
-    for (const currentValue of decodedInput) {
+    for (const currentValue of decodedInput){
         if (currentValue < 0x80) {
             output.push(String.fromCodePoint(currentValue));
         }
     }
     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 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:
+    while(handledCPCount < inputLength){
         let m = maxInt;
-        for (const currentValue of decodedInput) {
+        for (const currentValue of decodedInput){
             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;
         checkOverflow(m - n, Math.floor((maxInt - delta) / handledCPCountPlusOne));
         delta += (m - n) * handledCPCountPlusOne;
         n = m;
-        for (const currentValue of decodedInput) {
+        for (const currentValue of decodedInput){
             if (currentValue < n) {
                 checkOverflow(++delta, maxInt);
             }
             if (currentValue === n) {
-                // Represent delta as a generalized variable-length integer.
                 let q = delta;
                 let k = base;
-                while (true) {
-                    const t = k <= bias ?
-                        tMin :
-                        // eslint-disable-next-line @typescript-eslint/no-extra-parens
-                        (k >= bias + tMax ? tMax : k - bias);
+                while(true){
+                    const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
                     if (q < t) {
                         break;
                     }
@@ -295,31 +181,6 @@ export const encode = (input) => {
     }
     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.
- *
- * @param {string} input - The Punycoded domain name or email address to
- * convert to Unicode.
- * @returns {string} The Unicode representation of the given Punycode
- * string.
- */
-export const toUnicode = (input) => mapDomain(input, (str) => (str.startsWith('xn--') ?
-    decode(str.slice(4).toLowerCase()) :
-    str));
-/**
- * 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.
- *
- * @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.
- */
-export const toASCII = (input) => mapDomain(input, (string) => (regexNonASCII.test(string) ?
-    `xn--${encode(string)}` :
-    string));
+export const toUnicode = (input)=>mapDomain(input, (str)=>str.startsWith('xn--') ? decode(str.slice(4).toLowerCase()) : str);
+export const toASCII = (input)=>mapDomain(input, (string)=>regexNonASCII.test(string) ? `xn--${encode(string)}` : string);
+//# sourceMappingURL=punycode.js.map

package/dist/punycode.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/punycode.ts"],"sourceRoot":"","names":["checkOverflow","rangeError","maxInt","base","tMin","tMax","skew","damp","initialBias","initialN","delimiter","baseMinusTMin","regexNonASCII","regexSeparators","mapDomain","domain","callback","first","rest","split","result","toEncode","length","join","labels","encoded","map","x","ucs2Decode","string","output","counter","value","charCodeAt","extra","push","ucs2Encode","codePoints","String","fromCodePoint","basicToDigit","codePoint","digitToBasic","digit","plus22","adapt","delta","numPoints","firstTime","k","newDelta","Math","floor","minCheck","decode","input","inputLength","i","n","bias","basic","lastIndexOf","j","codePointAt","index","oldi","w","gte","error","t","baseMinusT","out","splice","encode","decodedInput","currentValue","basicLength","handledCPCount","m","handledCPCountPlusOne","q","qMinusT","toUnicode","str","startsWith","slice","toLowerCase","toASCII","test"],"mappings":"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","file":"punycode.js"}

package/dist/tests/unit/lib/errors.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=errors.spec.d.ts.map

package/dist/tests/unit/lib/errors.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.spec.d.ts","sourceRoot":"","sources":["../../../../src/tests/unit/lib/errors.spec.ts"],"names":[],"mappings":""}

package/dist/tests/unit/lib/errors.spec.js

@@ -0,0 +1,43 @@
+import { expect } from 'chai';
+import { suite, test } from 'mocha-chain';
+import * as Errors from '#errors';
+suite('errors', ()=>{
+    suite('checkOverflow', ()=>{
+        suite('success', ()=>{
+            test('Less than', ()=>{
+                Errors.checkOverflow(1, 2);
+            });
+            test('Less than (gte)', ()=>{
+                Errors.checkOverflow(1, 2, {
+                    gte: true
+                });
+            });
+            test('Equal to', ()=>{
+                Errors.checkOverflow(1, 1);
+            });
+        });
+        suite('failure', ()=>{
+            test('Greater than', ()=>{
+                expect(()=>{
+                    Errors.checkOverflow(2, 1);
+                }).to.throw(RangeError);
+            });
+            test('Greater than (gte)', ()=>{
+                expect(()=>{
+                    Errors.checkOverflow(2, 1, {
+                        gte: true
+                    });
+                }).to.throw('Overflow: input needs wider integers to process');
+            });
+            test('Equal to', ()=>{
+                expect(()=>{
+                    Errors.checkOverflow(1, 1, {
+                        gte: true,
+                        error: 'invalid-input'
+                    });
+                }).to.throw('Invalid input');
+            });
+        });
+    });
+});
+//# sourceMappingURL=errors.spec.js.map

package/dist/tests/unit/lib/errors.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/tests/unit/lib/errors.spec.ts"],"sourceRoot":"","names":["expect","suite","test","Errors","checkOverflow","gte","to","throw","RangeError","error"],"mappings":"AAAA,SAASA,MAAM,QAAQ,OAAO;AAC9B,SAASC,KAAK,EAAEC,IAAI,QAAQ,cAAc;AAC1C,YAAYC,YAAY,UAAU;AAElCF,MAAM,UAAU;IACZA,MAAM,iBAAiB;QACnBA,MAAM,WAAW;YACbC,KAAK,aAAa;gBACdC,OAAOC,aAAa,CAAC,GAAG;YAC5B;YAEAF,KAAK,mBAAmB;gBACpBC,OAAOC,aAAa,CAAC,GAAG,GAAG;oBAAEC,KAAK;gBAAK;YAC3C;YAEAH,KAAK,YAAY;gBACbC,OAAOC,aAAa,CAAC,GAAG;YAC5B;QACJ;QAEAH,MAAM,WAAW;YACbC,KAAK,gBAAgB;gBACjBF,OAAO;oBACHG,OAAOC,aAAa,CAAC,GAAG;gBAC5B,GAAGE,EAAE,CAACC,KAAK,CAACC;YAChB;YAEAN,KAAK,sBAAsB;gBACvBF,OAAO;oBACHG,OAAOC,aAAa,CAAC,GAAG,GAAG;wBAAEC,KAAK;oBAAK;gBAC3C,GAAGC,EAAE,CAACC,KAAK,CAAC;YAChB;YAEAL,KAAK,YAAY;gBACbF,OAAO;oBACHG,OAAOC,aAAa,CAAC,GAAG,GAAG;wBACvBC,KAAK;wBACLI,OAAO;oBACX;gBACJ,GAAGH,EAAE,CAACC,KAAK,CAAC;YAChB;QACJ;IACJ;AACJ","file":"errors.spec.js"}

package/dist/tests/unit/punycode.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=punycode.spec.d.ts.map

package/dist/tests/unit/punycode.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"punycode.spec.d.ts","sourceRoot":"","sources":["../../../src/tests/unit/punycode.spec.ts"],"names":[],"mappings":""}