whatwg-url 6.5.0 → 7.0.0

package/README.md

@@ -2,10 +2,12 @@
 
 whatwg-url is a full implementation of the WHATWG [URL Standard](https://url.spec.whatwg.org/). It can be used standalone, but it also exposes a lot of the internal algorithms that are useful for integrating a URL parser into a project like [jsdom](https://github.com/tmpvar/jsdom).
 
-## Current status
+## Specification conformance
 
 whatwg-url is currently up to date with the URL spec up to commit [6ef17eb](https://github.com/whatwg/url/commit/6ef17ebe1220a7e7c0cfff0785017502ee18808b).
 
+For `file:` URLs, whose [origin is left unspecified](https://url.spec.whatwg.org/#concept-url-origin), whatwg-url chooses to use a new opaque origin (which serializes to `"null"`).
+
 ## API
 
 ### The `URL` and `URLSearchParams` classes
@@ -66,3 +68,24 @@ The URL record type has the following API:
 These properties should be treated with care, as in general changing them will cause the URL record to be in an inconsistent state until the appropriate invocation of `basicURLParse` is used to fix it up. You can see examples of this in the URL Standard, where there are many step sequences like "4. Set context object’s url’s fragment to the empty string. 5. Basic URL parse _input_ with context object’s url as _url_ and fragment state as _state override_." In between those two steps, a URL record is in an unusable state.
 
 The return value of "failure" in the spec is represented by `null`. That is, functions like `parseURL` and `basicURLParse` can return _either_ a URL record _or_ `null`.
+
+## Development instructions
+
+First, install [Node.js](https://nodejs.org/). Then, fetch the dependencies of whatwg-url, by running from this directory:
+
+    npm install
+
+To run tests:
+
+    npm test
+
+To generate a coverage report:
+
+    npm run coverage
+
+To build and run the live viewer:
+
+    npm run build
+    npm run build-live-viewer
+
+Serve the contents of the `live-viewer` directory using any web server.

package/lib/URL-impl.js

@@ -12,13 +12,13 @@ exports.implementation = class URLImpl {
     if (base !== undefined) {
       parsedBase = usm.basicURLParse(base);
       if (parsedBase === null) {
-        throw new TypeError("Invalid base URL");
+        throw new TypeError(`Invalid base URL: ${base}`);
       }
     }
 
     const parsedURL = usm.basicURLParse(url, { baseURL: parsedBase });
     if (parsedURL === null) {
-      throw new TypeError("Invalid URL");
+      throw new TypeError(`Invalid URL: ${url}`);
     }
 
     const query = parsedURL.query !== null ? parsedURL.query : "";
@@ -38,7 +38,7 @@ exports.implementation = class URLImpl {
   set href(v) {
     const parsedURL = usm.basicURLParse(v);
     if (parsedURL === null) {
-      throw new TypeError("Invalid URL");
+      throw new TypeError(`Invalid URL: ${v}`);
     }
 
     this._url = parsedURL;

package/lib/URL.js

@@ -5,57 +5,44 @@ 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."
-    );
-  }
-  if (arguments.length < 1) {
-    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" });
+class URL {
+  constructor(url) {
+    if (arguments.length < 1) {
+      throw new TypeError("Failed to construct 'URL': 1 argument required, but only " + arguments.length + " present.");
+    }
+    const args = [];
+    {
+      let curArg = arguments[0];
+      curArg = conversions["USVString"](curArg, { context: "Failed to construct 'URL': parameter 1" });
+      args.push(curArg);
+    }
+    {
+      let curArg = arguments[1];
+      if (curArg !== undefined) {
+        curArg = conversions["USVString"](curArg, { context: "Failed to construct 'URL': parameter 2" });
+      }
+      args.push(curArg);
+    }
+    return iface.setup(Object.create(new.target.prototype), args);
   }
 
-  iface.setup(this, args);
-}
-
-Object.defineProperty(URL, "prototype", {
-  value: URL.prototype,
-  writable: false,
-  enumerable: false,
-  configurable: false
-});
+  toJSON() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
 
-URL.prototype.toJSON = function toJSON() {
-  if (!this || !module.exports.is(this)) {
-    throw new TypeError("Illegal invocation");
+    return this[impl].toJSON();
   }
 
-  return this[impl].toJSON();
-};
-
-Object.defineProperty(URL.prototype, "href", {
-  get() {
+  get href() {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
 
     return this[impl]["href"];
-  },
+  }
 
-  set(V) {
+  set href(V) {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
@@ -63,42 +50,32 @@ Object.defineProperty(URL.prototype, "href", {
     V = conversions["USVString"](V, { context: "Failed to set the 'href' property on 'URL': The provided value" });
 
     this[impl]["href"] = V;
-  },
-
-  enumerable: true,
-  configurable: true
-});
+  }
 
-URL.prototype.toString = function toString() {
-  if (!this || !module.exports.is(this)) {
-    throw new TypeError("Illegal invocation");
+  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() {
+  get 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() {
+  get protocol() {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
 
     return this[impl]["protocol"];
-  },
+  }
 
-  set(V) {
+  set protocol(V) {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
@@ -106,22 +83,17 @@ Object.defineProperty(URL.prototype, "protocol", {
     V = conversions["USVString"](V, { context: "Failed to set the 'protocol' property on 'URL': The provided value" });
 
     this[impl]["protocol"] = V;
-  },
-
-  enumerable: true,
-  configurable: true
-});
+  }
 
-Object.defineProperty(URL.prototype, "username", {
-  get() {
+  get username() {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
 
     return this[impl]["username"];
-  },
+  }
 
-  set(V) {
+  set username(V) {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
@@ -129,22 +101,17 @@ Object.defineProperty(URL.prototype, "username", {
     V = conversions["USVString"](V, { context: "Failed to set the 'username' property on 'URL': The provided value" });
 
     this[impl]["username"] = V;
-  },
-
-  enumerable: true,
-  configurable: true
-});
+  }
 
-Object.defineProperty(URL.prototype, "password", {
-  get() {
+  get password() {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
 
     return this[impl]["password"];
-  },
+  }
 
-  set(V) {
+  set password(V) {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
@@ -152,22 +119,17 @@ Object.defineProperty(URL.prototype, "password", {
     V = conversions["USVString"](V, { context: "Failed to set the 'password' property on 'URL': The provided value" });
 
     this[impl]["password"] = V;
-  },
-
-  enumerable: true,
-  configurable: true
-});
+  }
 
-Object.defineProperty(URL.prototype, "host", {
-  get() {
+  get host() {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
 
     return this[impl]["host"];
-  },
+  }
 
-  set(V) {
+  set host(V) {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
@@ -175,22 +137,17 @@ Object.defineProperty(URL.prototype, "host", {
     V = conversions["USVString"](V, { context: "Failed to set the 'host' property on 'URL': The provided value" });
 
     this[impl]["host"] = V;
-  },
-
-  enumerable: true,
-  configurable: true
-});
+  }
 
-Object.defineProperty(URL.prototype, "hostname", {
-  get() {
+  get hostname() {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
 
     return this[impl]["hostname"];
-  },
+  }
 
-  set(V) {
+  set hostname(V) {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
@@ -198,22 +155,17 @@ Object.defineProperty(URL.prototype, "hostname", {
     V = conversions["USVString"](V, { context: "Failed to set the 'hostname' property on 'URL': The provided value" });
 
     this[impl]["hostname"] = V;
-  },
-
-  enumerable: true,
-  configurable: true
-});
+  }
 
-Object.defineProperty(URL.prototype, "port", {
-  get() {
+  get port() {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
 
     return this[impl]["port"];
-  },
+  }
 
-  set(V) {
+  set port(V) {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
@@ -221,22 +173,17 @@ Object.defineProperty(URL.prototype, "port", {
     V = conversions["USVString"](V, { context: "Failed to set the 'port' property on 'URL': The provided value" });
 
     this[impl]["port"] = V;
-  },
-
-  enumerable: true,
-  configurable: true
-});
+  }
 
-Object.defineProperty(URL.prototype, "pathname", {
-  get() {
+  get pathname() {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
 
     return this[impl]["pathname"];
-  },
+  }
 
-  set(V) {
+  set pathname(V) {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
@@ -244,22 +191,17 @@ Object.defineProperty(URL.prototype, "pathname", {
     V = conversions["USVString"](V, { context: "Failed to set the 'pathname' property on 'URL': The provided value" });
 
     this[impl]["pathname"] = V;
-  },
-
-  enumerable: true,
-  configurable: true
-});
+  }
 
-Object.defineProperty(URL.prototype, "search", {
-  get() {
+  get search() {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
 
     return this[impl]["search"];
-  },
+  }
 
-  set(V) {
+  set search(V) {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
@@ -267,14 +209,9 @@ Object.defineProperty(URL.prototype, "search", {
     V = conversions["USVString"](V, { context: "Failed to set the 'search' property on 'URL': The provided value" });
 
     this[impl]["search"] = V;
-  },
-
-  enumerable: true,
-  configurable: true
-});
+  }
 
-Object.defineProperty(URL.prototype, "searchParams", {
-  get() {
+  get searchParams() {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
@@ -282,22 +219,17 @@ Object.defineProperty(URL.prototype, "searchParams", {
     return utils.getSameObject(this, "searchParams", () => {
       return utils.tryWrapperForImpl(this[impl]["searchParams"]);
     });
-  },
-
-  enumerable: true,
-  configurable: true
-});
+  }
 
-Object.defineProperty(URL.prototype, "hash", {
-  get() {
+  get hash() {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
 
     return this[impl]["hash"];
-  },
+  }
 
-  set(V) {
+  set hash(V) {
     if (!this || !module.exports.is(this)) {
       throw new TypeError("Illegal invocation");
     }
@@ -305,28 +237,37 @@ Object.defineProperty(URL.prototype, "hash", {
     V = conversions["USVString"](V, { context: "Failed to set the 'hash' property on 'URL': The provided value" });
 
     this[impl]["hash"] = V;
-  },
-
-  enumerable: true,
-  configurable: true
-});
-
-Object.defineProperty(URL.prototype, Symbol.toStringTag, {
-  value: "URL",
-  writable: false,
-  enumerable: false,
-  configurable: true
+  }
+}
+Object.defineProperties(URL.prototype, {
+  toJSON: { enumerable: true },
+  href: { enumerable: true },
+  toString: { enumerable: true },
+  origin: { enumerable: true },
+  protocol: { enumerable: true },
+  username: { enumerable: true },
+  password: { enumerable: true },
+  host: { enumerable: true },
+  hostname: { enumerable: true },
+  port: { enumerable: true },
+  pathname: { enumerable: true },
+  search: { enumerable: true },
+  searchParams: { enumerable: true },
+  hash: { enumerable: true },
+  [Symbol.toStringTag]: { value: "URL", configurable: true }
 });
-
 const iface = {
-  mixedInto: [],
+  // When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+  // method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+  // implementing this mixin interface.
+  _mixedIntoPredicates: [],
   is(obj) {
     if (obj) {
-      if (obj[impl] instanceof Impl.implementation) {
+      if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
         return true;
       }
-      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
-        if (obj instanceof module.exports.mixedInto[i]) {
+      for (const isMixedInto of module.exports._mixedIntoPredicates) {
+        if (isMixedInto(obj)) {
           return true;
         }
       }
@@ -340,8 +281,8 @@ const iface = {
       }
 
       const wrapper = utils.wrapperForImpl(obj);
-      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
-        if (wrapper instanceof module.exports.mixedInto[i]) {
+      for (const isMixedInto of module.exports._mixedIntoPredicates) {
+        if (isMixedInto(wrapper)) {
           return true;
         }
       }
@@ -374,8 +315,6 @@ const iface = {
     this._internalSetup(obj);
     Object.defineProperty(obj, impl, {
       value: new Impl.implementation(constructorArgs, privateData),
-      writable: false,
-      enumerable: false,
       configurable: true
     });
 
@@ -393,4 +332,4 @@ const iface = {
 }; // iface
 module.exports = iface;
 
-const Impl = require(".//URL-impl.js");
+const Impl = require("./URL-impl.js");

package/lib/URLSearchParams.js

@@ -39,336 +39,323 @@ const IteratorPrototype = Object.create(utils.IteratorPrototype, {
     configurable: true
   },
   [Symbol.toStringTag]: {
-    value: "URLSearchParamsIterator",
-    writable: false,
-    enumerable: false,
+    value: "URLSearchParams Iterator",
     configurable: true
   }
 });
-
-function URLSearchParams() {
-  const args = [];
-  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) {
-        if (!utils.isObject(args[0])) {
-          throw new TypeError(
-            "Failed to construct 'URLSearchParams': parameter 1" + " sequence" + " is not an iterable object."
-          );
-        } else {
-          const V = [];
-          const tmp = args[0];
-          for (let nextItem of tmp) {
-            if (!utils.isObject(nextItem)) {
+class URLSearchParams {
+  constructor() {
+    const args = [];
+    {
+      let curArg = arguments[0];
+      if (curArg !== undefined) {
+        if (utils.isObject(curArg)) {
+          if (curArg[Symbol.iterator] !== undefined) {
+            if (!utils.isObject(curArg)) {
               throw new TypeError(
-                "Failed to construct 'URLSearchParams': parameter 1" +
-                  " sequence" +
-                  "'s element" +
-                  " is not an iterable object."
+                "Failed to construct 'URLSearchParams': parameter 1" + " sequence" + " is not an iterable object."
               );
             } else {
               const V = [];
-              const tmp = nextItem;
+              const tmp = curArg;
               for (let nextItem of tmp) {
-                nextItem = conversions["USVString"](nextItem, {
-                  context:
-                    "Failed to construct 'URLSearchParams': parameter 1" + " sequence" + "'s element" + "'s element"
-                });
+                if (!utils.isObject(nextItem)) {
+                  throw new TypeError(
+                    "Failed to construct 'URLSearchParams': parameter 1" +
+                      " sequence" +
+                      "'s element" +
+                      " is not an iterable object."
+                  );
+                } else {
+                  const V = [];
+                  const tmp = nextItem;
+                  for (let nextItem of tmp) {
+                    nextItem = conversions["USVString"](nextItem, {
+                      context:
+                        "Failed to construct 'URLSearchParams': parameter 1" + " sequence" + "'s element" + "'s element"
+                    });
+
+                    V.push(nextItem);
+                  }
+                  nextItem = V;
+                }
 
                 V.push(nextItem);
               }
-              nextItem = V;
+              curArg = V;
             }
-
-            V.push(nextItem);
-          }
-          args[0] = V;
-        }
-      } else {
-        if (!utils.isObject(args[0])) {
-          throw new TypeError("Failed to construct 'URLSearchParams': parameter 1" + " record" + " is not an object.");
-        } else {
-          const result = Object.create(null);
-          for (const key of Reflect.ownKeys(args[0])) {
-            const desc = Object.getOwnPropertyDescriptor(args[0], key);
-            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;
+          } else {
+            if (!utils.isObject(curArg)) {
+              throw new TypeError(
+                "Failed to construct 'URLSearchParams': parameter 1" + " record" + " is not an object."
+              );
+            } else {
+              const result = Object.create(null);
+              for (const key of Reflect.ownKeys(curArg)) {
+                const desc = Object.getOwnPropertyDescriptor(curArg, key);
+                if (desc && desc.enumerable) {
+                  let typedKey = key;
+                  let typedValue = curArg[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;
+                }
+              }
+              curArg = result;
             }
           }
-          args[0] = result;
+        } else {
+          curArg = conversions["USVString"](curArg, { context: "Failed to construct 'URLSearchParams': parameter 1" });
         }
+      } else {
+        curArg = "";
       }
-    } else {
-      args[0] = conversions["USVString"](args[0], { context: "Failed to construct 'URLSearchParams': parameter 1" });
+      args.push(curArg);
     }
-  } else {
-    args[0] = "";
+    return iface.setup(Object.create(new.target.prototype), args);
   }
 
-  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() {
+  append(name, value) {
     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 " +
-        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 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);
-};
-
-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."
-    );
-  }
-
-  const args = [];
-  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);
-};
-
-URLSearchParams.prototype.get = function get(name) {
-  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 " +
+          arguments.length +
+          " present."
+      );
+    }
+    const args = [];
+    {
+      let curArg = arguments[0];
+      curArg = conversions["USVString"](curArg, {
+        context: "Failed to execute 'append' on 'URLSearchParams': parameter 1"
+      });
+      args.push(curArg);
+    }
+    {
+      let curArg = arguments[1];
+      curArg = conversions["USVString"](curArg, {
+        context: "Failed to execute 'append' on 'URLSearchParams': parameter 2"
+      });
+      args.push(curArg);
+    }
+    return this[impl].append(...args);
   }
 
-  if (arguments.length < 1) {
-    throw new TypeError(
-      "Failed to execute 'get' on 'URLSearchParams': 1 " +
-        "argument required, but only " +
-        arguments.length +
-        " present."
-    );
-  }
+  delete(name) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
 
-  const args = [];
-  for (let i = 0; i < arguments.length && i < 1; ++i) {
-    args[i] = arguments[i];
+    if (arguments.length < 1) {
+      throw new TypeError(
+        "Failed to execute 'delete' on 'URLSearchParams': 1 argument required, but only " +
+          arguments.length +
+          " present."
+      );
+    }
+    const args = [];
+    {
+      let curArg = arguments[0];
+      curArg = conversions["USVString"](curArg, {
+        context: "Failed to execute 'delete' on 'URLSearchParams': parameter 1"
+      });
+      args.push(curArg);
+    }
+    return this[impl].delete(...args);
   }
 
-  args[0] = conversions["USVString"](args[0], { context: "Failed to execute 'get' on 'URLSearchParams': parameter 1" });
-
-  return this[impl].get(...args);
-};
+  get(name) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
 
-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 'get' on 'URLSearchParams': 1 argument required, but only " + arguments.length + " present."
+      );
+    }
+    const args = [];
+    {
+      let curArg = arguments[0];
+      curArg = conversions["USVString"](curArg, {
+        context: "Failed to execute 'get' on 'URLSearchParams': parameter 1"
+      });
+      args.push(curArg);
+    }
+    return this[impl].get(...args);
   }
 
-  if (arguments.length < 1) {
-    throw new TypeError(
-      "Failed to execute 'getAll' on 'URLSearchParams': 1 " +
-        "argument required, but only " +
-        arguments.length +
-        " present."
-    );
-  }
+  getAll(name) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
 
-  const args = [];
-  for (let i = 0; i < arguments.length && i < 1; ++i) {
-    args[i] = arguments[i];
+    if (arguments.length < 1) {
+      throw new TypeError(
+        "Failed to execute 'getAll' on 'URLSearchParams': 1 argument required, but only " +
+          arguments.length +
+          " present."
+      );
+    }
+    const args = [];
+    {
+      let curArg = arguments[0];
+      curArg = conversions["USVString"](curArg, {
+        context: "Failed to execute 'getAll' on 'URLSearchParams': parameter 1"
+      });
+      args.push(curArg);
+    }
+    return utils.tryWrapperForImpl(this[impl].getAll(...args));
   }
 
-  args[0] = conversions["USVString"](args[0], {
-    context: "Failed to execute 'getAll' on 'URLSearchParams': parameter 1"
-  });
-
-  return utils.tryWrapperForImpl(this[impl].getAll(...args));
-};
+  has(name) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
 
-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."
+      );
+    }
+    const args = [];
+    {
+      let curArg = arguments[0];
+      curArg = conversions["USVString"](curArg, {
+        context: "Failed to execute 'has' on 'URLSearchParams': parameter 1"
+      });
+      args.push(curArg);
+    }
+    return this[impl].has(...args);
   }
 
-  if (arguments.length < 1) {
-    throw new TypeError(
-      "Failed to execute 'has' on 'URLSearchParams': 1 " +
-        "argument required, but only " +
-        arguments.length +
-        " present."
-    );
-  }
+  set(name, value) {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
 
-  const args = [];
-  for (let i = 0; i < arguments.length && i < 1; ++i) {
-    args[i] = arguments[i];
+    if (arguments.length < 2) {
+      throw new TypeError(
+        "Failed to execute 'set' on 'URLSearchParams': 2 arguments required, but only " + arguments.length + " present."
+      );
+    }
+    const args = [];
+    {
+      let curArg = arguments[0];
+      curArg = conversions["USVString"](curArg, {
+        context: "Failed to execute 'set' on 'URLSearchParams': parameter 1"
+      });
+      args.push(curArg);
+    }
+    {
+      let curArg = arguments[1];
+      curArg = conversions["USVString"](curArg, {
+        context: "Failed to execute 'set' on 'URLSearchParams': parameter 2"
+      });
+      args.push(curArg);
+    }
+    return this[impl].set(...args);
   }
 
-  args[0] = conversions["USVString"](args[0], { context: "Failed to execute 'has' on 'URLSearchParams': parameter 1" });
-
-  return this[impl].has(...args);
-};
+  sort() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
 
-URLSearchParams.prototype.set = function set(name, value) {
-  if (!this || !module.exports.is(this)) {
-    throw new TypeError("Illegal invocation");
+    return this[impl].sort();
   }
 
-  if (arguments.length < 2) {
-    throw new TypeError(
-      "Failed to execute 'set' on 'URLSearchParams': 2 " +
-        "arguments required, but only " +
-        arguments.length +
-        " present."
-    );
-  }
+  toString() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
 
-  const args = [];
-  for (let i = 0; i < arguments.length && i < 2; ++i) {
-    args[i] = arguments[i];
+    return this[impl].toString();
   }
 
-  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);
-};
-
-URLSearchParams.prototype.sort = function sort() {
-  if (!this || !module.exports.is(this)) {
-    throw new TypeError("Illegal invocation");
+  keys() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+    return module.exports.createDefaultIterator(this, "key");
   }
 
-  return this[impl].sort();
-};
-
-URLSearchParams.prototype.toString = function toString() {
-  if (!this || !module.exports.is(this)) {
-    throw new TypeError("Illegal invocation");
+  values() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+    return module.exports.createDefaultIterator(this, "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");
+  entries() {
+    if (!this || !module.exports.is(this)) {
+      throw new TypeError("Illegal invocation");
+    }
+    return module.exports.createDefaultIterator(this, "key+value");
   }
-  return module.exports.createDefaultIterator(this, "key");
-};
 
-URLSearchParams.prototype.values = function values() {
-  if (!this || !module.exports.is(this)) {
-    throw new TypeError("Illegal invocation");
+  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 'iterable': 1 argument required, " + "but only 0 present.");
+    }
+    if (typeof callback !== "function") {
+      throw new TypeError(
+        "Failed to execute 'forEach' on 'iterable': 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++;
+    }
   }
-  return module.exports.createDefaultIterator(this, "value");
-};
-
-Object.defineProperty(URLSearchParams.prototype, Symbol.toStringTag, {
-  value: "URLSearchParams",
-  writable: false,
-  enumerable: false,
-  configurable: true
+}
+Object.defineProperties(URLSearchParams.prototype, {
+  append: { enumerable: true },
+  delete: { enumerable: true },
+  get: { enumerable: true },
+  getAll: { enumerable: true },
+  has: { enumerable: true },
+  set: { enumerable: true },
+  sort: { enumerable: true },
+  toString: { enumerable: true },
+  keys: { enumerable: true },
+  values: { enumerable: true },
+  entries: { enumerable: true },
+  forEach: { enumerable: true },
+  [Symbol.toStringTag]: { value: "URLSearchParams", configurable: true },
+  [Symbol.iterator]: { value: URLSearchParams.prototype.entries, configurable: true, writable: true }
 });
-
 const iface = {
-  mixedInto: [],
+  // When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+  // method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+  // implementing this mixin interface.
+  _mixedIntoPredicates: [],
   is(obj) {
     if (obj) {
-      if (obj[impl] instanceof Impl.implementation) {
+      if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
         return true;
       }
-      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
-        if (obj instanceof module.exports.mixedInto[i]) {
+      for (const isMixedInto of module.exports._mixedIntoPredicates) {
+        if (isMixedInto(obj)) {
           return true;
         }
       }
@@ -382,8 +369,8 @@ const iface = {
       }
 
       const wrapper = utils.wrapperForImpl(obj);
-      for (let i = 0; i < module.exports.mixedInto.length; ++i) {
-        if (wrapper instanceof module.exports.mixedInto[i]) {
+      for (const isMixedInto of module.exports._mixedIntoPredicates) {
+        if (isMixedInto(wrapper)) {
           return true;
         }
       }
@@ -401,8 +388,6 @@ const iface = {
     const iterator = Object.create(IteratorPrototype);
     Object.defineProperty(iterator, utils.iterInternalSymbol, {
       value: { target, kind, index: 0 },
-      writable: false,
-      enumerable: false,
       configurable: true
     });
     return iterator;
@@ -427,8 +412,6 @@ const iface = {
     this._internalSetup(obj);
     Object.defineProperty(obj, impl, {
       value: new Impl.implementation(constructorArgs, privateData),
-      writable: false,
-      enumerable: false,
       configurable: true
     });
 
@@ -446,4 +429,4 @@ const iface = {
 }; // iface
 module.exports = iface;
 
-const Impl = require(".//URLSearchParams-impl.js");
+const Impl = require("./URLSearchParams-impl.js");

package/lib/url-state-machine.js

@@ -1244,8 +1244,14 @@ module.exports.serializeURLOrigin = function (url) {
         port: url.port
       });
     case "file":
-      // spec says "exercise to the reader", chrome says "file://"
-      return "file://";
+      // The spec says:
+      // > Unfortunate as it is, this is left as an exercise to the reader. When in doubt, return a new opaque origin.
+      // Browsers tested so far:
+      // - Chrome says "file://", but treats file: URLs as cross-origin for most (all?) purposes; see e.g.
+      //   https://bugs.chromium.org/p/chromium/issues/detail?id=37586
+      // - Firefox says "null", but treats file: URLs as same-origin sometimes based on directory stuff; see
+      //   https://developer.mozilla.org/en-US/docs/Archive/Misc_top_level/Same-origin_policy_for_file:_URIs
+      return "null";
     default:
       // serializing an opaque origin returns "null"
       return "null";

package/lib/utils.js

@@ -5,31 +5,34 @@ function isObject(value) {
   return typeof value === "object" && value !== null || typeof value === "function";
 }
 
-function getReferenceToBytes(bufferSource) {
-  // Node.js' Buffer does not allow subclassing for now, so we can get away with a prototype object check for perf.
-  if (Object.getPrototypeOf(bufferSource) === Buffer.prototype) {
-    return bufferSource;
-  }
-  if (bufferSource instanceof ArrayBuffer) {
-    return Buffer.from(bufferSource);
-  }
-  return Buffer.from(bufferSource.buffer, bufferSource.byteOffset, bufferSource.byteLength);
-}
-
-function getCopyToBytes(bufferSource) {
-  return Buffer.from(getReferenceToBytes(bufferSource));
+function hasOwn(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
 }
 
-function mixin(target, source) {
-  const keys = Object.getOwnPropertyNames(source);
-  for (let i = 0; i < keys.length; ++i) {
-    if (keys[i] in target) {
-      continue;
+const getOwnPropertyDescriptors = typeof Object.getOwnPropertyDescriptors === "function" ?
+  Object.getOwnPropertyDescriptors :
+  // Polyfill exists until we require Node.js v8.x
+  // https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptors
+  obj => {
+    if (obj === undefined || obj === null) {
+      throw new TypeError("Cannot convert undefined or null to object");
     }
-
-    Object.defineProperty(target, keys[i], Object.getOwnPropertyDescriptor(source, keys[i]));
-  }
-}
+    obj = Object(obj);
+    const ownKeys = Reflect.ownKeys(obj);
+    const descriptors = {};
+    for (const key of ownKeys) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(obj, key);
+      if (descriptor !== undefined) {
+        Reflect.defineProperty(descriptors, key, {
+          value: descriptor,
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      }
+    }
+    return descriptors;
+  };
 
 const wrapperSymbol = Symbol("wrapper");
 const implSymbol = Symbol("impl");
@@ -98,9 +101,8 @@ const namedDelete = Symbol("named property delete");
 
 module.exports = exports = {
   isObject,
-  getReferenceToBytes,
-  getCopyToBytes,
-  mixin,
+  hasOwn,
+  getOwnPropertyDescriptors,
   wrapperSymbol,
   implSymbol,
   getSameObject,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whatwg-url",
-  "version": "6.5.0",
+  "version": "7.0.0",
   "description": "An implementation of the WHATWG URL Standard's URL API and parsing machinery",
   "main": "lib/public-api.js",
   "files": [
@@ -17,13 +17,12 @@
   "devDependencies": {
     "browserify": "^16.2.2",
     "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"
+    "eslint": "^5.4.0",
+    "jest": "^23.5.0",
+    "jsdom": "^11.12.0",
+    "recast": "^0.15.3",
+    "request": "^2.88.0",
+    "webidl2js": "^9.0.1"
   },
   "scripts": {
     "build": "node scripts/transform.js && node scripts/convert-idl.js",