whatwg-url 4.8.0 → 5.0.0

package/README.md

@@ -4,7 +4,7 @@ whatwg-url is a full implementation of the WHATWG [URL Standard](https://url.spe
 
 ## Current Status
 
-whatwg-url is currently up to date with the URL spec up to commit [fe6b25](https://github.com/whatwg/url/commit/fe6b251739e225555f04319f19c70c031a5d99eb).
+whatwg-url is currently up to date with the URL spec up to commit [a62223](https://github.com/whatwg/url/commit/a622235308342c9adc7fc2fd1659ff059f7d5e2a).
 
 ## API
 
@@ -21,7 +21,7 @@ The following methods are exported for use by places like jsdom that need to imp
 - [URL serializer](https://url.spec.whatwg.org/#concept-url-serializer): `serializeURL(urlRecord, excludeFragment)`
 - [Host serializer](https://url.spec.whatwg.org/#concept-host-serializer): `serializeHost(hostFromURLRecord)`
 - [Serialize an integer](https://url.spec.whatwg.org/#serialize-an-integer): `serializeInteger(number)`
-- [Origin](https://url.spec.whatwg.org/#concept-url-origin) [Unicode serializer](https://html.spec.whatwg.org/multipage/browsers.html#unicode-serialisation-of-an-origin): `serializeURLToUnicodeOrigin(urlRecord)`
+- [Origin](https://url.spec.whatwg.org/#concept-url-origin) [serializer](https://html.spec.whatwg.org/multipage/browsers.html#serialization-of-an-origin): `serializeURLOrigin(urlRecord)`
 - [Set the username](https://url.spec.whatwg.org/#set-the-username): `setTheUsername(urlRecord, usernameString)`
 - [Set the password](https://url.spec.whatwg.org/#set-the-password): `setThePassword(urlRecord, passwordString)`
 - [Cannot have a username/password/port](https://url.spec.whatwg.org/#cannot-have-a-username-password-port): `cannotHaveAUsernamePasswordPort(urlRecord)`

package/lib/URL-impl.js

@@ -38,7 +38,7 @@ exports.implementation = class URLImpl {
   }
 
   get origin() {
-    return usm.serializeURLToUnicodeOrigin(this._url);
+    return usm.serializeURLOrigin(this._url);
   }
 
   get protocol() {

package/lib/public-api.js

@@ -2,7 +2,7 @@
 
 exports.URL = require("./URL").interface;
 exports.serializeURL = require("./url-state-machine").serializeURL;
-exports.serializeURLToUnicodeOrigin = require("./url-state-machine").serializeURLToUnicodeOrigin;
+exports.serializeURLOrigin = require("./url-state-machine").serializeURLOrigin;
 exports.basicURLParse = require("./url-state-machine").basicURLParse;
 exports.setTheUsername = require("./url-state-machine").setTheUsername;
 exports.setThePassword = require("./url-state-machine").setThePassword;

package/lib/url-state-machine.js

@@ -214,9 +214,9 @@ function serializeIPv4(address) {
   let output = "";
   let n = address;
 
-  for (let i = 0; i < 4; ++i) {
+  for (let i = 1; i <= 4; ++i) {
     output = String(n % 256) + output;
-    if (i !== 3) {
+    if (i !== 4) {
       output = "." + output;
     }
     n = Math.floor(n / 256);
@@ -226,9 +226,9 @@ function serializeIPv4(address) {
 }
 
 function parseIPv6(input) {
-  const ip = [0, 0, 0, 0, 0, 0, 0, 0];
-  let piecePtr = 0;
-  let compressPtr = null;
+  const address = [0, 0, 0, 0, 0, 0, 0, 0];
+  let pieceIndex = 0;
+  let compress = null;
   let pointer = 0;
 
   input = punycode.ucs2.decode(input);
@@ -239,22 +239,22 @@ function parseIPv6(input) {
     }
 
     pointer += 2;
-    ++piecePtr;
-    compressPtr = piecePtr;
+    ++pieceIndex;
+    compress = pieceIndex;
   }
 
   while (pointer < input.length) {
-    if (piecePtr === 8) {
+    if (pieceIndex === 8) {
       return failure;
     }
 
     if (input[pointer] === 58) {
-      if (compressPtr !== null) {
+      if (compress !== null) {
         return failure;
       }
       ++pointer;
-      ++piecePtr;
-      compressPtr = piecePtr;
+      ++pieceIndex;
+      compress = pieceIndex;
       continue;
     }
 
@@ -274,7 +274,7 @@ function parseIPv6(input) {
 
       pointer -= length;
 
-      if (piecePtr > 6) {
+      if (pieceIndex > 6) {
         return failure;
       }
 
@@ -310,12 +310,12 @@ function parseIPv6(input) {
           ++pointer;
         }
 
-        ip[piecePtr] = ip[piecePtr] * 0x100 + ipv4Piece;
+        address[pieceIndex] = address[pieceIndex] * 0x100 + ipv4Piece;
 
         ++numbersSeen;
 
         if (numbersSeen === 2 || numbersSeen === 4) {
-          ++piecePtr;
+          ++pieceIndex;
         }
       }
 
@@ -333,52 +333,50 @@ function parseIPv6(input) {
       return failure;
     }
 
-    ip[piecePtr] = value;
-    ++piecePtr;
+    address[pieceIndex] = value;
+    ++pieceIndex;
   }
 
-  if (compressPtr !== null) {
-    let swaps = piecePtr - compressPtr;
-    piecePtr = 7;
-    while (piecePtr !== 0 && swaps > 0) {
-      const temp = ip[compressPtr + swaps - 1]; // piece
-      ip[compressPtr + swaps - 1] = ip[piecePtr];
-      ip[piecePtr] = temp;
-      --piecePtr;
+  if (compress !== null) {
+    let swaps = pieceIndex - compress;
+    pieceIndex = 7;
+    while (pieceIndex !== 0 && swaps > 0) {
+      const temp = address[compress + swaps - 1];
+      address[compress + swaps - 1] = address[pieceIndex];
+      address[pieceIndex] = temp;
+      --pieceIndex;
       --swaps;
     }
-  } else if (compressPtr === null && piecePtr !== 8) {
+  } else if (compress === null && pieceIndex !== 8) {
     return failure;
   }
 
-  return ip;
+  return address;
 }
 
 function serializeIPv6(address) {
   let output = "";
   const seqResult = findLongestZeroSequence(address);
-  const compressPtr = seqResult.idx;
+  const compress = seqResult.idx;
   let ignore0 = false;
 
-  for (let i = 0; i < address.length; ++i) {
-    const piece = address[i];
-
-    if (ignore0 && piece === 0) {
+  for (let pieceIndex = 0; pieceIndex <= 7; ++pieceIndex) {
+    if (ignore0 && address[pieceIndex] === 0) {
       continue;
     } else if (ignore0) {
       ignore0 = false;
     }
 
-    if (compressPtr === i) {
-      const separator = i === 0 ? "::" : ":";
+    if (compress === pieceIndex) {
+      const separator = pieceIndex === 0 ? "::" : ":";
       output += separator;
       ignore0 = true;
       continue;
     }
 
-    output += piece.toString(16);
+    output += address[pieceIndex].toString(16);
 
-    if (i !== address.length - 1) {
+    if (pieceIndex !== 7) {
       output += ":";
     }
   }
@@ -1210,12 +1208,8 @@ function serializeURL(url, excludeFragment) {
 }
 
 function serializeOrigin(tuple) {
-  if (tuple.scheme === undefined || tuple.host === undefined || tuple.port === undefined) {
-    return "null";
-  }
-
   let result = tuple.scheme + "://";
-  result += tr46.toUnicode(tuple.host, false).domain;
+  result += serializeHost(tuple.host);
 
   if (tuple.port !== null) {
     result += ":" + tuple.port;
@@ -1226,13 +1220,14 @@ function serializeOrigin(tuple) {
 
 module.exports.serializeURL = serializeURL;
 
-module.exports.serializeURLToUnicodeOrigin = function (url) {
+module.exports.serializeURLOrigin = function (url) {
+  // https://url.spec.whatwg.org/#concept-url-origin
   switch (url.scheme) {
     case "blob":
       try {
-        return module.exports.serializeURLToUnicodeOrigin(module.exports.parseURL(url.path[0]));
+        return module.exports.serializeURLOrigin(module.exports.parseURL(url.path[0]));
       } catch (e) {
-        // serializing an opaque identifier returns "null"
+        // serializing an opaque origin returns "null"
         return "null";
       }
     case "ftp":
@@ -1243,14 +1238,14 @@ module.exports.serializeURLToUnicodeOrigin = function (url) {
     case "wss":
       return serializeOrigin({
         scheme: url.scheme,
-        host: serializeHost(url.host),
+        host: url.host,
         port: url.port
       });
     case "file":
       // spec says "exercise to the reader", chrome says "file://"
       return "file://";
     default:
-      // serializing an opaque identifier returns "null"
+      // serializing an opaque origin returns "null"
       return "null";
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whatwg-url",
-  "version": "4.8.0",
+  "version": "5.0.0",
   "description": "An implementation of the WHATWG URL Standard's URL API and parsing machinery",
   "main": "lib/public-api.js",
   "files": [