whatwg-url 6.4.0 → 6.4.1

package/README.md

@@ -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) [serializer](https://html.spec.whatwg.org/multipage/browsers.html#serialization-of-an-origin): `serializeURLOrigin(urlRecord)`
+- [Origin](https://url.spec.whatwg.org/#concept-url-origin) [serializer](https://html.spec.whatwg.org/multipage/origin.html#ascii-serialisation-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

@@ -42,6 +42,12 @@ exports.implementation = class URLImpl {
     }
 
     this._url = parsedURL;
+
+    this._query._list.splice(0);
+    const { query } = parsedURL;
+    if (query !== null) {
+      this._query._list = urlencoded.parseUrlencoded(query);
+    }
   }
 
   get origin() {

package/lib/URL.js

@@ -2,23 +2,28 @@
 
 const conversions = require("webidl-conversions");
 const utils = require("./utils.js");
+
 const impl = utils.implSymbol;
 
 function URL(url) {
   if (!new.target) {
     throw new TypeError(
-      "Failed to construct 'URL'. Please use the 'new' operator; this constructor cannot be called as a function."
+      "Failed to construct 'URL'. Please use the 'new' operator; this constructor " + "cannot be called as a function."
     );
   }
   if (arguments.length < 1) {
-    throw new TypeError("Failed to construct 'URL': 1 argument required, but only " + arguments.length + " present.");
+    throw new TypeError(
+      "Failed to construct 'URL': 1 " + "argument required, but only " + arguments.length + " present."
+    );
   }
 
   const args = [];
   for (let i = 0; i < arguments.length && i < 2; ++i) {
     args[i] = arguments[i];
   }
+
   args[0] = conversions["USVString"](args[0], { context: "Failed to construct 'URL': parameter 1" });
+
   if (args[1] !== undefined) {
     args[1] = conversions["USVString"](args[1], { context: "Failed to construct 'URL': parameter 2" });
   }
@@ -26,20 +31,40 @@ function URL(url) {
   iface.setup(this, args);
 }
 
+Object.defineProperty(URL, "prototype", {
+  value: URL.prototype,
+  writable: false,
+  enumerable: false,
+  configurable: false
+});
+
 URL.prototype.toJSON = function toJSON() {
   if (!this || !module.exports.is(this)) {
     throw new TypeError("Illegal invocation");
   }
+
   return this[impl].toJSON();
 };
+
 Object.defineProperty(URL.prototype, "href", {
   get() {
-    return this[impl].href;
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["href"];
   },
+
   set(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
     V = conversions["USVString"](V, { context: "Failed to set the 'href' property on 'URL': The provided value" });
-    this[impl].href = V;
+
+    this[impl]["href"] = V;
   },
+
   enumerable: true,
   configurable: true
 });
@@ -48,131 +73,240 @@ URL.prototype.toString = function toString() {
   if (!this || !module.exports.is(this)) {
     throw new TypeError("Illegal invocation");
   }
-  return this[impl].href;
+  return this[impl]["href"];
 };
 
 Object.defineProperty(URL.prototype, "origin", {
   get() {
-    return this[impl].origin;
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["origin"];
   },
+
   enumerable: true,
   configurable: true
 });
 
 Object.defineProperty(URL.prototype, "protocol", {
   get() {
-    return this[impl].protocol;
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["protocol"];
   },
+
   set(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
     V = conversions["USVString"](V, { context: "Failed to set the 'protocol' property on 'URL': The provided value" });
-    this[impl].protocol = V;
+
+    this[impl]["protocol"] = V;
   },
+
   enumerable: true,
   configurable: true
 });
 
 Object.defineProperty(URL.prototype, "username", {
   get() {
-    return this[impl].username;
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["username"];
   },
+
   set(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
     V = conversions["USVString"](V, { context: "Failed to set the 'username' property on 'URL': The provided value" });
-    this[impl].username = V;
+
+    this[impl]["username"] = V;
   },
+
   enumerable: true,
   configurable: true
 });
 
 Object.defineProperty(URL.prototype, "password", {
   get() {
-    return this[impl].password;
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["password"];
   },
+
   set(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
     V = conversions["USVString"](V, { context: "Failed to set the 'password' property on 'URL': The provided value" });
-    this[impl].password = V;
+
+    this[impl]["password"] = V;
   },
+
   enumerable: true,
   configurable: true
 });
 
 Object.defineProperty(URL.prototype, "host", {
   get() {
-    return this[impl].host;
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["host"];
   },
+
   set(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
     V = conversions["USVString"](V, { context: "Failed to set the 'host' property on 'URL': The provided value" });
-    this[impl].host = V;
+
+    this[impl]["host"] = V;
   },
+
   enumerable: true,
   configurable: true
 });
 
 Object.defineProperty(URL.prototype, "hostname", {
   get() {
-    return this[impl].hostname;
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["hostname"];
   },
+
   set(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
     V = conversions["USVString"](V, { context: "Failed to set the 'hostname' property on 'URL': The provided value" });
-    this[impl].hostname = V;
+
+    this[impl]["hostname"] = V;
   },
+
   enumerable: true,
   configurable: true
 });
 
 Object.defineProperty(URL.prototype, "port", {
   get() {
-    return this[impl].port;
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["port"];
   },
+
   set(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
     V = conversions["USVString"](V, { context: "Failed to set the 'port' property on 'URL': The provided value" });
-    this[impl].port = V;
+
+    this[impl]["port"] = V;
   },
+
   enumerable: true,
   configurable: true
 });
 
 Object.defineProperty(URL.prototype, "pathname", {
   get() {
-    return this[impl].pathname;
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["pathname"];
   },
+
   set(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
     V = conversions["USVString"](V, { context: "Failed to set the 'pathname' property on 'URL': The provided value" });
-    this[impl].pathname = V;
+
+    this[impl]["pathname"] = V;
   },
+
   enumerable: true,
   configurable: true
 });
 
 Object.defineProperty(URL.prototype, "search", {
   get() {
-    return this[impl].search;
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["search"];
   },
+
   set(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
     V = conversions["USVString"](V, { context: "Failed to set the 'search' property on 'URL': The provided value" });
-    this[impl].search = V;
+
+    this[impl]["search"] = V;
   },
+
   enumerable: true,
   configurable: true
 });
 
 Object.defineProperty(URL.prototype, "searchParams", {
   get() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
     return utils.getSameObject(this, "searchParams", () => {
-      return utils.tryWrapperForImpl(this[impl].searchParams);
+      return utils.tryWrapperForImpl(this[impl]["searchParams"]);
     });
   },
+
   enumerable: true,
   configurable: true
 });
 
 Object.defineProperty(URL.prototype, "hash", {
   get() {
-    return this[impl].hash;
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
+    return this[impl]["hash"];
   },
+
   set(V) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+
     V = conversions["USVString"](V, { context: "Failed to set the 'hash' property on 'URL': The provided value" });
-    this[impl].hash = V;
+
+    this[impl]["hash"] = V;
   },
+
   enumerable: true,
   configurable: true
 });
@@ -220,37 +354,43 @@ const iface = {
     }
     throw new TypeError(`${context} is not of type 'URL'.`);
   },
+
   create(constructorArgs, privateData) {
     let obj = Object.create(URL.prototype);
-    this.setup(obj, constructorArgs, privateData);
+    obj = this.setup(obj, constructorArgs, privateData);
     return obj;
   },
   createImpl(constructorArgs, privateData) {
     let obj = Object.create(URL.prototype);
-    this.setup(obj, constructorArgs, privateData);
+    obj = this.setup(obj, constructorArgs, privateData);
     return utils.implForWrapper(obj);
   },
   _internalSetup(obj) {},
   setup(obj, constructorArgs, privateData) {
     if (!privateData) privateData = {};
+
     privateData.wrapper = obj;
 
     this._internalSetup(obj);
-
     Object.defineProperty(obj, impl, {
       value: new Impl.implementation(constructorArgs, privateData),
       writable: false,
       enumerable: false,
       configurable: true
     });
+
     obj[impl][utils.wrapperSymbol] = obj;
+    if (Impl.init) {
+      Impl.init(obj[impl], privateData);
+    }
+    return obj;
   },
   interface: URL,
   expose: {
-    Window: { URL: URL },
-    Worker: { URL: URL }
+    Window: { URL },
+    Worker: { URL }
   }
-};
+}; // iface
 module.exports = iface;
 
 const Impl = require(".//URL-impl.js");

package/lib/URLSearchParams.js

@@ -2,6 +2,7 @@
 
 const conversions = require("webidl-conversions");
 const utils = require("./utils.js");
+
 const impl = utils.implSymbol;
 
 const IteratorPrototype = Object.create(utils.IteratorPrototype, {
@@ -50,6 +51,7 @@ function URLSearchParams() {
   for (let i = 0; i < arguments.length && i < 1; ++i) {
     args[i] = arguments[i];
   }
+
   if (args[0] !== undefined) {
     if (utils.isObject(args[0])) {
       if (args[0][Symbol.iterator] !== undefined) {
@@ -76,10 +78,12 @@ function URLSearchParams() {
                   context:
                     "Failed to construct 'URLSearchParams': parameter 1" + " sequence" + "'s element" + "'s element"
                 });
+
                 V.push(nextItem);
               }
               nextItem = V;
             }
+
             V.push(nextItem);
           }
           args[0] = V;
@@ -94,12 +98,15 @@ function URLSearchParams() {
             if (desc && desc.enumerable) {
               let typedKey = key;
               let typedValue = args[0][key];
+
               typedKey = conversions["USVString"](typedKey, {
                 context: "Failed to construct 'URLSearchParams': parameter 1" + " record" + "'s key"
               });
+
               typedValue = conversions["USVString"](typedValue, {
                 context: "Failed to construct 'URLSearchParams': parameter 1" + " record" + "'s value"
               });
+
               result[typedKey] = typedValue;
             }
           }
@@ -116,13 +123,57 @@ function URLSearchParams() {
   iface.setup(this, args);
 }
 
+Object.defineProperty(URLSearchParams, "prototype", {
+  value: URLSearchParams.prototype,
+  writable: false,
+  enumerable: false,
+  configurable: false
+});
+
+Object.defineProperty(URLSearchParams.prototype, Symbol.iterator, {
+  writable: true,
+  enumerable: false,
+  configurable: true,
+  value: function entries() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+    return module.exports.createDefaultIterator(this, "key+value");
+  }
+});
+URLSearchParams.prototype.forEach = function forEach(callback) {
+  if (!this || !module.exports.is(this)) {
+    throw new TypeError("Illegal invocation");
+  }
+  if (arguments.length < 1) {
+    throw new TypeError(
+      "Failed to execute 'forEach' on 'URLSearchParams': 1 argument required, " + "but only 0 present."
+    );
+  }
+  if (typeof callback !== "function") {
+    throw new TypeError(
+      "Failed to execute 'forEach' on 'URLSearchParams': The callback provided " + "as parameter 1 is not a function."
+    );
+  }
+  const thisArg = arguments[1];
+  let pairs = Array.from(this[impl]);
+  let i = 0;
+  while (i < pairs.length) {
+    const [key, value] = pairs[i].map(utils.tryWrapperForImpl);
+    callback.call(thisArg, value, key, this);
+    pairs = Array.from(this[impl]);
+    i++;
+  }
+};
 URLSearchParams.prototype.append = function append(name, value) {
   if (!this || !module.exports.is(this)) {
     throw new TypeError("Illegal invocation");
   }
+
   if (arguments.length < 2) {
     throw new TypeError(
-      "Failed to execute 'append' on 'URLSearchParams': 2 arguments required, but only " +
+      "Failed to execute 'append' on 'URLSearchParams': 2 " +
+        "arguments required, but only " +
         arguments.length +
         " present."
     );
@@ -132,12 +183,15 @@ URLSearchParams.prototype.append = function append(name, value) {
   for (let i = 0; i < arguments.length && i < 2; ++i) {
     args[i] = arguments[i];
   }
+
   args[0] = conversions["USVString"](args[0], {
     context: "Failed to execute 'append' on 'URLSearchParams': parameter 1"
   });
+
   args[1] = conversions["USVString"](args[1], {
     context: "Failed to execute 'append' on 'URLSearchParams': parameter 2"
   });
+
   return this[impl].append(...args);
 };
 
@@ -145,9 +199,13 @@ URLSearchParams.prototype.delete = function _(name) {
   if (!this || !module.exports.is(this)) {
     throw new TypeError("Illegal invocation");
   }
+
   if (arguments.length < 1) {
     throw new TypeError(
-      "Failed to execute 'delete' on 'URLSearchParams': 1 argument required, but only " + arguments.length + " present."
+      "Failed to execute 'delete' on 'URLSearchParams': 1 " +
+        "argument required, but only " +
+        arguments.length +
+        " present."
     );
   }
 
@@ -155,9 +213,11 @@ URLSearchParams.prototype.delete = function _(name) {
   for (let i = 0; i < arguments.length && i < 1; ++i) {
     args[i] = arguments[i];
   }
+
   args[0] = conversions["USVString"](args[0], {
     context: "Failed to execute 'delete' on 'URLSearchParams': parameter 1"
   });
+
   return this[impl].delete(...args);
 };
 
@@ -165,9 +225,13 @@ URLSearchParams.prototype.get = function get(name) {
   if (!this || !module.exports.is(this)) {
     throw new TypeError("Illegal invocation");
   }
+
   if (arguments.length < 1) {
     throw new TypeError(
-      "Failed to execute 'get' on 'URLSearchParams': 1 argument required, but only " + arguments.length + " present."
+      "Failed to execute 'get' on 'URLSearchParams': 1 " +
+        "argument required, but only " +
+        arguments.length +
+        " present."
     );
   }
 
@@ -175,7 +239,9 @@ URLSearchParams.prototype.get = function get(name) {
   for (let i = 0; i < arguments.length && i < 1; ++i) {
     args[i] = arguments[i];
   }
+
   args[0] = conversions["USVString"](args[0], { context: "Failed to execute 'get' on 'URLSearchParams': parameter 1" });
+
   return this[impl].get(...args);
 };
 
@@ -183,9 +249,13 @@ URLSearchParams.prototype.getAll = function getAll(name) {
   if (!this || !module.exports.is(this)) {
     throw new TypeError("Illegal invocation");
   }
+
   if (arguments.length < 1) {
     throw new TypeError(
-      "Failed to execute 'getAll' on 'URLSearchParams': 1 argument required, but only " + arguments.length + " present."
+      "Failed to execute 'getAll' on 'URLSearchParams': 1 " +
+        "argument required, but only " +
+        arguments.length +
+        " present."
     );
   }
 
@@ -193,9 +263,11 @@ URLSearchParams.prototype.getAll = function getAll(name) {
   for (let i = 0; i < arguments.length && i < 1; ++i) {
     args[i] = arguments[i];
   }
+
   args[0] = conversions["USVString"](args[0], {
     context: "Failed to execute 'getAll' on 'URLSearchParams': parameter 1"
   });
+
   return utils.tryWrapperForImpl(this[impl].getAll(...args));
 };
 
@@ -203,9 +275,13 @@ URLSearchParams.prototype.has = function has(name) {
   if (!this || !module.exports.is(this)) {
     throw new TypeError("Illegal invocation");
   }
+
   if (arguments.length < 1) {
     throw new TypeError(
-      "Failed to execute 'has' on 'URLSearchParams': 1 argument required, but only " + arguments.length + " present."
+      "Failed to execute 'has' on 'URLSearchParams': 1 " +
+        "argument required, but only " +
+        arguments.length +
+        " present."
     );
   }
 
@@ -213,7 +289,9 @@ URLSearchParams.prototype.has = function has(name) {
   for (let i = 0; i < arguments.length && i < 1; ++i) {
     args[i] = arguments[i];
   }
+
   args[0] = conversions["USVString"](args[0], { context: "Failed to execute 'has' on 'URLSearchParams': parameter 1" });
+
   return this[impl].has(...args);
 };
 
@@ -221,9 +299,13 @@ URLSearchParams.prototype.set = function set(name, value) {
   if (!this || !module.exports.is(this)) {
     throw new TypeError("Illegal invocation");
   }
+
   if (arguments.length < 2) {
     throw new TypeError(
-      "Failed to execute 'set' on 'URLSearchParams': 2 arguments required, but only " + arguments.length + " present."
+      "Failed to execute 'set' on 'URLSearchParams': 2 " +
+        "arguments required, but only " +
+        arguments.length +
+        " present."
     );
   }
 
@@ -231,8 +313,11 @@ URLSearchParams.prototype.set = function set(name, value) {
   for (let i = 0; i < arguments.length && i < 2; ++i) {
     args[i] = arguments[i];
   }
+
   args[0] = conversions["USVString"](args[0], { context: "Failed to execute 'set' on 'URLSearchParams': parameter 1" });
+
   args[1] = conversions["USVString"](args[1], { context: "Failed to execute 'set' on 'URLSearchParams': parameter 2" });
+
   return this[impl].set(...args);
 };
 
@@ -240,56 +325,33 @@ URLSearchParams.prototype.sort = function sort() {
   if (!this || !module.exports.is(this)) {
     throw new TypeError("Illegal invocation");
   }
+
   return this[impl].sort();
 };
 
-URLSearchParams.prototype[Symbol.iterator] = function entries() {
+URLSearchParams.prototype.toString = function toString() {
   if (!this || !module.exports.is(this)) {
     throw new TypeError("Illegal invocation");
   }
-  return module.exports.createDefaultIterator(this, "key+value");
+
+  return this[impl].toString();
 };
+
 URLSearchParams.prototype.entries = URLSearchParams.prototype[Symbol.iterator];
+
 URLSearchParams.prototype.keys = function keys() {
   if (!this || !module.exports.is(this)) {
     throw new TypeError("Illegal invocation");
   }
   return module.exports.createDefaultIterator(this, "key");
 };
+
 URLSearchParams.prototype.values = function values() {
   if (!this || !module.exports.is(this)) {
     throw new TypeError("Illegal invocation");
   }
   return module.exports.createDefaultIterator(this, "value");
 };
-URLSearchParams.prototype.forEach = function forEach(callback) {
-  if (!this || !module.exports.is(this)) {
-    throw new TypeError("Illegal invocation");
-  }
-  if (arguments.length < 1) {
-    throw new TypeError("Failed to execute 'forEach' on 'URLSearchParams': 1 argument required, but only 0 present.");
-  }
-  if (typeof callback !== "function") {
-    throw new TypeError(
-      "Failed to execute 'forEach' on 'URLSearchParams': The callback provided as parameter 1 is not a function."
-    );
-  }
-  const thisArg = arguments[1];
-  let pairs = Array.from(this[impl]);
-  let i = 0;
-  while (i < pairs.length) {
-    const [key, value] = pairs[i].map(utils.tryWrapperForImpl);
-    callback.call(thisArg, value, key, this);
-    pairs = Array.from(this[impl]);
-    i++;
-  }
-};
-URLSearchParams.prototype.toString = function toString() {
-  if (!this || !module.exports.is(this)) {
-    throw new TypeError("Illegal invocation");
-  }
-  return utils.tryWrapperForImpl(this[impl].toString());
-};
 
 Object.defineProperty(URLSearchParams.prototype, Symbol.toStringTag, {
   value: "URLSearchParams",
@@ -334,6 +396,7 @@ const iface = {
     }
     throw new TypeError(`${context} is not of type 'URLSearchParams'.`);
   },
+
   createDefaultIterator(target, kind) {
     const iterator = Object.create(IteratorPrototype);
     Object.defineProperty(iterator, utils.iterInternalSymbol, {
@@ -344,37 +407,43 @@ const iface = {
     });
     return iterator;
   },
+
   create(constructorArgs, privateData) {
     let obj = Object.create(URLSearchParams.prototype);
-    this.setup(obj, constructorArgs, privateData);
+    obj = this.setup(obj, constructorArgs, privateData);
     return obj;
   },
   createImpl(constructorArgs, privateData) {
     let obj = Object.create(URLSearchParams.prototype);
-    this.setup(obj, constructorArgs, privateData);
+    obj = this.setup(obj, constructorArgs, privateData);
     return utils.implForWrapper(obj);
   },
   _internalSetup(obj) {},
   setup(obj, constructorArgs, privateData) {
     if (!privateData) privateData = {};
+
     privateData.wrapper = obj;
 
     this._internalSetup(obj);
-
     Object.defineProperty(obj, impl, {
       value: new Impl.implementation(constructorArgs, privateData),
       writable: false,
       enumerable: false,
       configurable: true
     });
+
     obj[impl][utils.wrapperSymbol] = obj;
+    if (Impl.init) {
+      Impl.init(obj[impl], privateData);
+    }
+    return obj;
   },
   interface: URLSearchParams,
   expose: {
-    Window: { URLSearchParams: URLSearchParams },
-    Worker: { URLSearchParams: URLSearchParams }
+    Window: { URLSearchParams },
+    Worker: { URLSearchParams }
   }
-};
+}; // iface
 module.exports = iface;
 
 const Impl = require(".//URLSearchParams-impl.js");

package/lib/url-state-machine.js

@@ -124,7 +124,14 @@ function parseIPv4Number(input) {
     return 0;
   }
 
-  const regex = R === 10 ? /[^0-9]/ : (R === 16 ? /[^0-9A-Fa-f]/ : /[^0-7]/);
+  let regex = /[^0-7]/;
+  if (R === 10) {
+    regex = /[^0-9]/;
+  }
+  if (R === 16) {
+    regex = /[^0-9A-Fa-f]/;
+  }
+
   if (regex.test(input)) {
     return failure;
   }
@@ -466,7 +473,7 @@ function trimTabAndNewline(url) {
 }
 
 function shortenPath(url) {
-  const path = url.path;
+  const { path } = url;
   if (path.length === 0) {
     return;
   }

package/lib/urlencoded.js

@@ -84,10 +84,10 @@ function serializeUrlencodedByte(input) {
     } else if (byte === 42 ||
                byte === 45 ||
                byte === 46 ||
-               byte >= 48 && byte <= 57 ||
-               byte >= 65 && byte <= 90 ||
+               (byte >= 48 && byte <= 57) ||
+               (byte >= 65 && byte <= 90) ||
                byte === 95 ||
-               byte >= 97 && byte <= 122) {
+               (byte >= 97 && byte <= 122)) {
       output += String.fromCodePoint(byte);
     } else {
       output += percentEncode(byte);

package/lib/utils.js

@@ -13,7 +13,7 @@ function getReferenceToBytes(bufferSource) {
   if (bufferSource instanceof ArrayBuffer) {
     return Buffer.from(bufferSource);
   }
-  return Buffer.from(bufferSource.buffer, bufferSource.byteOffset, bufferSource.byteLength)
+  return Buffer.from(bufferSource.buffer, bufferSource.byteOffset, bufferSource.byteLength);
 }
 
 function getCopyToBytes(bufferSource) {
@@ -44,30 +44,58 @@ function getSameObject(wrapper, prop, creator) {
     return wrapper[sameObjectCaches][prop];
   }
 
-  return wrapper[sameObjectCaches][prop] = creator();
+  wrapper[sameObjectCaches][prop] = creator();
+  return wrapper[sameObjectCaches][prop];
 }
 
 function wrapperForImpl(impl) {
   return impl ? impl[wrapperSymbol] : null;
-};
+}
 
 function implForWrapper(wrapper) {
   return wrapper ? wrapper[implSymbol] : null;
-};
+}
 
 function tryWrapperForImpl(impl) {
   const wrapper = wrapperForImpl(impl);
   return wrapper ? wrapper : impl;
-};
+}
 
 function tryImplForWrapper(wrapper) {
   const impl = implForWrapper(wrapper);
   return impl ? impl : wrapper;
-};
+}
 
 const iterInternalSymbol = Symbol("internal");
 const IteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
 
+function isArrayIndexPropName(P) {
+  if (typeof P !== "string") {
+    return false;
+  }
+  const i = P >>> 0;
+  if (i === Math.pow(2, 32) - 1) {
+    return false;
+  }
+  const s = `${i}`;
+  if (P !== s) {
+    return false;
+  }
+  return true;
+}
+
+const supportsPropertyIndex = Symbol("supports property index");
+const supportedPropertyIndices = Symbol("supported property indices");
+const supportsPropertyName = Symbol("supports property name");
+const supportedPropertyNames = Symbol("supported property names");
+const indexedGet = Symbol("indexed property get");
+const indexedSetNew = Symbol("indexed property set new");
+const indexedSetExisting = Symbol("indexed property set existing");
+const namedGet = Symbol("named property get");
+const namedSetNew = Symbol("named property set new");
+const namedSetExisting = Symbol("named property set existing");
+const namedDelete = Symbol("named property delete");
+
 module.exports = exports = {
   isObject,
   getReferenceToBytes,
@@ -81,5 +109,17 @@ module.exports = exports = {
   tryWrapperForImpl,
   tryImplForWrapper,
   iterInternalSymbol,
-  IteratorPrototype
+  IteratorPrototype,
+  isArrayIndexPropName,
+  supportsPropertyIndex,
+  supportedPropertyIndices,
+  supportsPropertyName,
+  supportedPropertyNames,
+  indexedGet,
+  indexedSetNew,
+  indexedSetExisting,
+  namedGet,
+  namedSetNew,
+  namedSetExisting,
+  namedDelete
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whatwg-url",
-  "version": "6.4.0",
+  "version": "6.4.1",
   "description": "An implementation of the WHATWG URL Standard's URL API and parsing machinery",
   "main": "lib/public-api.js",
   "files": [
@@ -11,18 +11,18 @@
   "repository": "jsdom/whatwg-url",
   "dependencies": {
     "lodash.sortby": "^4.7.0",
-    "tr46": "^1.0.0",
-    "webidl-conversions": "^4.0.1"
+    "tr46": "^1.0.1",
+    "webidl-conversions": "^4.0.2"
   },
   "devDependencies": {
-    "domexception": "^1.0.0",
-    "eslint": "^4.1.1",
-    "istanbul": "~0.4.3",
-    "jest": "^21.0.2",
-    "jsdom": "^11.0.0",
-    "recast": "~0.12.6",
-    "request": "^2.55.0",
-    "webidl2js": "^7.1.0"
+    "domexception": "^1.0.1",
+    "eslint": "^4.19.1",
+    "istanbul": "~0.4.5",
+    "jest": "^22.4.3",
+    "jsdom": "^11.8.0",
+    "recast": "~0.14.7",
+    "request": "^2.85.0",
+    "webidl2js": "^7.4.0"
   },
   "scripts": {
     "build": "node scripts/transform.js && node scripts/convert-idl.js",