whatwg-url 16.0.0 → 17.0.0

package/README.md

@@ -4,7 +4,7 @@ whatwg-url is a full implementation of the WHATWG [URL Standard](https://url.spe
 
 ## Specification conformance
 
-whatwg-url is currently up to date with the URL spec up to commit [b6b3251](https://github.com/whatwg/url/commit/b6b3251fe911ab33d68fb051efe0e4d39ae4145e).
+whatwg-url is currently up to date with the URL spec up to commit [3c83874](https://github.com/whatwg/url/commit/3c83874ae1eac84ceb71d8c4344673251c982bbe) and the web platform tests up to commit [2a91c2e](https://github.com/web-platform-tests/wpt/commit/2a91c2e71952bdceef8b2825ce3a0a0dc73aa588).
 
 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"`).
 

package/lib/URL-impl.js

@@ -2,6 +2,7 @@
 const usm = require("./url-state-machine");
 const urlencoded = require("./urlencoded");
 const URLSearchParams = require("./URLSearchParams");
+const URL = require("./URL");
 
 exports.implementation = class URLImpl {
   // Unlike the spec, we duplicate some code between the constructor and canParse, because we want to give useful error
@@ -32,7 +33,7 @@ exports.implementation = class URLImpl {
 
   static parse(globalObject, input, base) {
     try {
-      return new URLImpl(globalObject, [input, base]);
+      return URL.createImpl(globalObject, [input, base]);
     } catch {
       return null;
     }

package/lib/URLSearchParams.js

@@ -106,7 +106,10 @@ exports.install = (globalObject, globalNames) => {
         let curArg = arguments[0];
         if (curArg !== undefined) {
           if (utils.isObject(curArg)) {
-            if (curArg[Symbol.iterator] !== undefined) {
+            if (
+              utils.getMethod(curArg, Symbol.iterator, "Failed to construct 'URLSearchParams': parameter 1") !==
+              undefined
+            ) {
               if (!utils.isObject(curArg)) {
                 throw new globalObject.TypeError(
                   "Failed to construct 'URLSearchParams': parameter 1" + " sequence" + " is not an iterable object."

package/lib/url-state-machine.js

@@ -63,6 +63,10 @@ function containsForbiddenDomainCodePoint(string) {
   return containsForbiddenHostCodePoint(string) || string.search(/[\u0000-\u001F]|%|\u007F/u) !== -1;
 }
 
+function isASCIIString(string) {
+  return !/[^\u0000-\u007F]/u.test(string);
+}
+
 function isSpecialScheme(scheme) {
   return specialSchemes[scheme] !== undefined;
 }
@@ -241,7 +245,7 @@ function parseIPv6(input) {
         }
 
         while (infra.isASCIIDigit(input[pointer])) {
-          const number = parseInt(at(input, pointer));
+          const number = parseInt(at(input, pointer), 10);
           if (ipv4Piece === null) {
             ipv4Piece = number;
           } else if (ipv4Piece === 0) {
@@ -342,7 +346,7 @@ function parseHost(input, isOpaque = false) {
   }
 
   const domain = utf8DecodeWithoutBOM(percentDecodeString(input));
-  const asciiDomain = domainToASCII(domain);
+  const asciiDomain = domainParser(domain);
   if (asciiDomain === failure) {
     return failure;
   }
@@ -426,28 +430,65 @@ function serializeHost(host) {
   return host;
 }
 
-function domainToASCII(domain, beStrict = false) {
-  const result = tr46.toASCII(domain, {
-    checkHyphens: beStrict,
-    checkBidi: true,
-    checkJoiners: true,
-    useSTD3ASCIIRules: beStrict,
-    transitionalProcessing: false,
-    verifyDNSLength: beStrict,
-    ignoreInvalidPunycode: false
-  });
-  if (result === null) {
-    return failure;
-  }
-
-  if (!beStrict) {
-    if (result === "") {
+function domainParser(domain, beStrict = false) {
+  if (beStrict) {
+    const result = tr46.toASCII(domain, {
+      checkHyphens: true,
+      checkBidi: true,
+      checkJoiners: true,
+      useSTD3ASCIIRules: true,
+      transitionalProcessing: false,
+      verifyDNSLength: true,
+      ignoreInvalidPunycode: false
+    });
+    if (result === null) {
       return failure;
     }
-    if (containsForbiddenDomainCodePoint(result)) {
+
+    return result;
+  }
+
+  let result;
+  if (isASCIIString(domain)) {
+    // The `domain parser` algorithm runs Unicode ToASCII here only to generate a `domain-to-ASCII` validation error,
+    // and we do not surface validation errors yet. If we ever support them
+    // (https://github.com/jsdom/whatwg-url/issues/156), we will need code like the following:
+    //
+    // if (tr46.toASCII(domain, {
+    //   checkHyphens: false,
+    //   checkBidi: true,
+    //   checkJoiners: true,
+    //   useSTD3ASCIIRules: false,
+    //   transitionalProcessing: false,
+    //   verifyDNSLength: false,
+    //   ignoreInvalidPunycode: false
+    // }) === null) {
+    //   validationError("domain-to-ASCII");
+    // }
+
+    result = domain.toLowerCase();
+  } else {
+    result = tr46.toASCII(domain, {
+      checkHyphens: false,
+      checkBidi: true,
+      checkJoiners: true,
+      useSTD3ASCIIRules: false,
+      transitionalProcessing: false,
+      verifyDNSLength: false,
+      ignoreInvalidPunycode: false
+    });
+    if (result === null) {
       return failure;
     }
   }
+
+  if (result === "") {
+    return failure;
+  }
+  if (containsForbiddenDomainCodePoint(result)) {
+    return failure;
+  }
+
   return result;
 }
 
@@ -857,7 +898,7 @@ URLStateMachine.prototype["parse port"] = function parsePort(c, cStr) {
              (isSpecial(this.url) && c === p("\\")) ||
              this.stateOverride) {
     if (this.buffer !== "") {
-      const port = parseInt(this.buffer);
+      const port = parseInt(this.buffer, 10);
       if (port > 2 ** 16 - 1) {
         this.parseError = true;
         return failure;

package/lib/utils.js

@@ -111,7 +111,7 @@ function isArrayIndexPropName(P) {
 }
 
 const arrayBufferByteLengthGetter =
-    Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
+  Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
 function isArrayBuffer(value) {
   try {
     arrayBufferByteLengthGetter.call(value);
@@ -198,6 +198,103 @@ function isAccessorDescriptor(desc) {
   return Object.hasOwn(desc, "get") || Object.hasOwn(desc, "set");
 }
 
+function getMethod(value, property, errPrefix = "The provided value") {
+  const func = value[property];
+  if (func === undefined || func === null) {
+    return undefined;
+  }
+  if (typeof func !== "function") {
+    throw new TypeError(`${errPrefix}'s ${property} property is not a function.`);
+  }
+  return func;
+}
+
+function createAsyncFromSyncIterator(syncIterator) {
+  // Instead of re-implementing CreateAsyncFromSyncIterator and %AsyncFromSyncIteratorPrototype%,
+  // we use yield* inside an async generator function to achieve the same result.
+
+  // Wrap the sync iterator inside a sync iterable, so we can use it with yield*.
+  const syncIterable = {
+    [Symbol.iterator]: () => syncIterator
+  };
+  // Create an async generator function and immediately invoke it.
+  const asyncIterator = (async function* () {
+    return yield* syncIterable;
+  })();
+  // Return as an async iterator record.
+  return asyncIterator;
+}
+
+function convertAsyncSequence(object, itemConverter, errPrefix = "The provided value") {
+  if (!isObject(object)) {
+    throw new TypeError(`${errPrefix} is not an object.`);
+  }
+  let method = getMethod(object, Symbol.asyncIterator, errPrefix);
+  let type = "async";
+  if (method === undefined) {
+    method = getMethod(object, Symbol.iterator, errPrefix);
+    if (method === undefined) {
+      throw new TypeError(`${errPrefix} is not an async iterable object.`);
+    }
+    type = "sync";
+  }
+
+  return {
+    object,
+    method,
+    type,
+    // The wrapperSymbol ensures that if the async sequence is used as a return value,
+    // that it exposes the original JavaScript value.
+    // https://webidl.spec.whatwg.org/#js-async-iterable
+    [wrapperSymbol]: object,
+    // Implement the async iterator protocol, so users can iterate
+    // the async sequence directly (e.g. with for await...of)
+    // instead of needing to call a separate helper function to open the async sequence.
+    // https://webidl.spec.whatwg.org/#async-sequence-open
+    [Symbol.asyncIterator]() {
+      return openAsyncSequence(object, method, type, itemConverter, `${errPrefix}'s iterator`);
+    }
+  };
+}
+
+function openAsyncSequence(object, method, type, itemConverter, errPrefix = "The provided value") {
+  let iterator = call(method, object);
+  if (!isObject(iterator)) {
+    throw new TypeError(`${errPrefix}'s method must return an object`);
+  }
+  if (type === "sync") {
+    iterator = createAsyncFromSyncIterator(iterator);
+  }
+  const nextMethod = iterator.next;
+  return {
+    async next() {
+      const nextResult = await call(nextMethod, iterator);
+      if (!isObject(nextResult)) {
+        throw new TypeError(`${errPrefix}'s next method must return an object`);
+      }
+      const { done, value } = nextResult;
+      if (done) {
+        return { done: true, value: undefined };
+      }
+      return { done: false, value: itemConverter(value) };
+    },
+    async return(reason) {
+      const returnMethod = getMethod(iterator, "return", errPrefix);
+      if (returnMethod === undefined) {
+        return { done: true, value: undefined };
+      }
+      const returnResult = await call(returnMethod, iterator, reason);
+      if (!isObject(returnResult)) {
+        throw new TypeError(`${errPrefix}'s return method must return an object`);
+      }
+      return { done: true, value: undefined };
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+}
+
 const supportsPropertyIndex = Symbol("supports property index");
 const supportedPropertyIndices = Symbol("supported property indices");
 const supportsPropertyName = Symbol("supports property name");
@@ -232,6 +329,8 @@ module.exports = exports = {
   isArrayBuffer,
   isSharedArrayBuffer,
   isArrayIndexPropName,
+  getMethod,
+  convertAsyncSequence,
   supportsPropertyIndex,
   supportedPropertyIndices,
   supportsPropertyName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whatwg-url",
-  "version": "16.0.0",
+  "version": "17.0.0",
   "description": "An implementation of the WHATWG URL Standard's URL API and parsing machinery",
   "main": "index.js",
   "files": [
@@ -15,21 +15,21 @@
     "url": "git+https://github.com/jsdom/whatwg-url.git"
   },
   "dependencies": {
-    "@exodus/bytes": "^1.11.0",
+    "@exodus/bytes": "^1.15.1",
     "tr46": "^6.0.0",
     "webidl-conversions": "^8.0.1"
   },
   "devDependencies": {
-    "@domenic/eslint-config": "^4.1.0",
-    "tinybench": "^6.0.0",
-    "c8": "^10.1.3",
-    "esbuild": "^0.27.2",
-    "eslint": "^9.39.2",
-    "globals": "^17.3.0",
-    "webidl2js": "^19.1.0"
+    "@domenic/eslint-config": "^5.1.0",
+    "tinybench": "^6.0.2",
+    "c8": "^11.0.0",
+    "esbuild": "^0.28.1",
+    "eslint": "^10.6.0",
+    "globals": "^17.7.0",
+    "webidl2js": "^20.1.0"
   },
   "engines": {
-    "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+    "node": "^22.14.0 || >=24.0.0"
   },
   "scripts": {
     "coverage": "c8 node --test --experimental-test-coverage test/*.js",