whatwg-url 4.5.1 → 4.8.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 [4bf85a](https://github.com/whatwg/url/commit/4bf85a08da18ef367e093426abef776d59e8fb7b).
+whatwg-url is currently up to date with the URL spec up to commit [fe6b25](https://github.com/whatwg/url/commit/fe6b251739e225555f04319f19c70c031a5d99eb).
 
 ## API
 

package/lib/url-state-machine.js

@@ -179,6 +179,9 @@ function parseIPv4(input) {
 
   const numbers = [];
   for (const part of parts) {
+    if (part === "") {
+      return input;
+    }
     const n = parseIPv4Number(part);
     if (n === failure) {
       return input;
@@ -240,8 +243,6 @@ function parseIPv6(input) {
     compressPtr = piecePtr;
   }
 
-  let ipv4 = false;
-  Main:
   while (pointer < input.length) {
     if (piecePtr === 8) {
       return failure;
@@ -266,77 +267,74 @@ function parseIPv6(input) {
       ++length;
     }
 
-    switch (at(input, pointer)) {
-      case ".":
-        if (length === 0) {
-          return failure;
-        }
-        pointer -= length;
-        ipv4 = true;
-        break Main;
-      case ":":
-        ++pointer;
-        if (input[pointer] === undefined) {
-          return failure;
-        }
-        break;
-      case undefined:
-        break;
-      default:
+    if (input[pointer] === 46) {
+      if (length === 0) {
         return failure;
-    }
+      }
 
-    ip[piecePtr] = value;
-    ++piecePtr;
-  }
+      pointer -= length;
 
-  if (ipv4 && piecePtr > 6) {
-    return failure;
-  } else if (input[pointer] !== undefined) {
-    let numbersSeen = 0;
+      if (piecePtr > 6) {
+        return failure;
+      }
 
-    while (input[pointer] !== undefined) {
-      let value = null;
+      let numbersSeen = 0;
 
-      if (numbersSeen > 0) {
-        if (input[pointer] === 46 && numbersSeen < 4) {
-          ++pointer;
-        } else {
-          return failure;
-        }
-      }
+      while (input[pointer] !== undefined) {
+        let ipv4Piece = null;
 
-      if (!isASCIIDigit(input[pointer])) {
-        return failure;
-      }
+        if (numbersSeen > 0) {
+          if (input[pointer] === 46 && numbersSeen < 4) {
+            ++pointer;
+          } else {
+            return failure;
+          }
+        }
 
-      while (isASCIIDigit(input[pointer])) {
-        const number = parseInt(at(input, pointer));
-        if (value === null) {
-          value = number;
-        } else if (value === 0) {
+        if (!isASCIIDigit(input[pointer])) {
           return failure;
-        } else {
-          value = value * 10 + number;
         }
-        ++pointer;
-        if (value > 255) {
-          return failure;
+
+        while (isASCIIDigit(input[pointer])) {
+          const number = parseInt(at(input, pointer));
+          if (ipv4Piece === null) {
+            ipv4Piece = number;
+          } else if (ipv4Piece === 0) {
+            return failure;
+          } else {
+            ipv4Piece = ipv4Piece * 10 + number;
+          }
+          if (ipv4Piece > 255) {
+            return failure;
+          }
+          ++pointer;
         }
-      }
 
-      ip[piecePtr] = ip[piecePtr] * 0x100 + value;
+        ip[piecePtr] = ip[piecePtr] * 0x100 + ipv4Piece;
+
+        ++numbersSeen;
 
-      ++numbersSeen;
+        if (numbersSeen === 2 || numbersSeen === 4) {
+          ++piecePtr;
+        }
+      }
 
-      if (numbersSeen === 2 || numbersSeen === 4) {
-        ++piecePtr;
+      if (numbersSeen !== 4) {
+        return failure;
       }
 
-      if (input[pointer] === undefined && numbersSeen !== 4) {
+      break;
+    } else if (input[pointer] === 58) {
+      ++pointer;
+      if (input[pointer] === undefined) {
         return failure;
       }
+    } else if (input[pointer] !== undefined) {
+      return failure;
     }
+
+    ip[piecePtr] = value;
+    ++piecePtr;
   }
 
   if (compressPtr !== null) {
@@ -349,7 +347,7 @@ function parseIPv6(input) {
       --piecePtr;
       --swaps;
     }
-  } else if (piecePtr !== 8) {
+  } else if (compressPtr === null && piecePtr !== 8) {
     return failure;
   }
 
@@ -360,20 +358,26 @@ function serializeIPv6(address) {
   let output = "";
   const seqResult = findLongestZeroSequence(address);
   const compressPtr = seqResult.idx;
+  let ignore0 = false;
 
   for (let i = 0; i < address.length; ++i) {
-    if (compressPtr === i) {
-      if (i === 0) {
-        output += "::";
-      } else {
-        output += ":";
-      }
+    const piece = address[i];
 
-      i += seqResult.len - 1;
+    if (ignore0 && piece === 0) {
       continue;
+    } else if (ignore0) {
+      ignore0 = false;
     }
 
-    output += address[i].toString(16);
+    if (compressPtr === i) {
+      const separator = i === 0 ? "::" : ":";
+      output += separator;
+      ignore0 = true;
+      continue;
+    }
+
+    output += piece.toString(16);
+
     if (i !== address.length - 1) {
       output += ":";
     }
@@ -594,6 +598,14 @@ URLStateMachine.prototype["parse scheme"] = function parseScheme(c, cStr) {
       if (!isSpecial(this.url) && isSpecialScheme(this.buffer)) {
         return false;
       }
+
+      if ((includesCredentials(this.url) || this.url.port !== null) && this.buffer === "file") {
+        return false;
+      }
+
+      if (this.url.scheme === "file" && (this.url.host === "" || this.url.host === null)) {
+        return false;
+      }
     }
     this.url.scheme = this.buffer;
     this.buffer = "";
@@ -916,9 +928,10 @@ URLStateMachine.prototype["parse file"] = function parseFile(c) {
       this.url.fragment = "";
       this.state = "fragment";
     } else {
-      if (!isWindowsDriveLetterCodePoints(c, this.input[this.pointer + 1]) ||
-          this.input.length - this.pointer - 1 === 1 || // remaining consists of 1 code point
-          !fileOtherwiseCodePoints.has(this.input[this.pointer + 2])) {
+      if (this.input.length - this.pointer - 1 === 0 || // remaining consists of 0 code points
+          !isWindowsDriveLetterCodePoints(c, this.input[this.pointer + 1]) ||
+          (this.input.length - this.pointer - 1 >= 2 && // remaining has at least 2 code points
+           !fileOtherwiseCodePoints.has(this.input[this.pointer + 2]))) {
         this.url.host = this.base.host;
         this.url.path = this.base.path.slice();
         shortenPath(this.url);
@@ -945,8 +958,10 @@ URLStateMachine.prototype["parse file slash"] = function parseFileSlash(c) {
     this.state = "file host";
   } else {
     if (this.base !== null && this.base.scheme === "file") {
-      if (this.base.path.length > 0 && isNormalizedWindowsDriveLetterString(this.base.path[0])) {
+      if (isNormalizedWindowsDriveLetterString(this.base.path[0])) {
         this.url.path.push(this.base.path[0]);
+      } else {
+        this.url.host = this.base.host;
       }
     }
     this.state = "path";
@@ -1035,15 +1050,21 @@ URLStateMachine.prototype["parse path"] = function parsePath(c) {
       this.url.path.push("");
     } else if (!isSingleDot(this.buffer)) {
       if (this.url.scheme === "file" && this.url.path.length === 0 && isWindowsDriveLetterString(this.buffer)) {
-        if (this.url.host !== null) {
+        if (this.url.host !== "" && this.url.host !== null) {
           this.parseError = true;
+          this.url.host = "";
         }
-        this.url.host = null;
         this.buffer = this.buffer[0] + ":";
       }
       this.url.path.push(this.buffer);
     }
     this.buffer = "";
+    if (this.url.scheme === "file" && (c === undefined || c === 63 || c === 35)) {
+      while (this.url.path.length > 1 && this.url.path[0] === "") {
+        this.parseError = true;
+        this.url.path.shift();
+      }
+    }
     if (c === 63) {
       this.url.query = "";
       this.state = "query";

package/package.json

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