diff --git a/doc/api/url.md b/doc/api/url.md
index 3fa589397f77d6..60764106ef21fd 100644
--- a/doc/api/url.md
+++ b/doc/api/url.md
@@ -1277,6 +1277,180 @@ console.log(urlToHttpOptions(myUrl));
 */
 ```
 
+## URLPattern
+
+The `URLPattern` is a Web Platform API for matching URLs against a pattern
+syntax.
+
+### Class: `URLPattern`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+#### `new URLPattern([input[, baseURL]])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `input` {string|URLPatternInit}
+* `baseURL` {string}
+
+Create a new `URLPattern`.
+
+#### `urlPattern.exec([input[, baseURL]])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `input` {string|URLPatternInit}
+* `baseURL` {string}
+* Returns: {URLPatternResult|null}
+
+Executes this `URLPattern` against the given `input`, returning an
+{URLPatternResult} that contains each of the matching components if
+the pattern matches the input, or `null` if the pattern does not match.
+
+#### `urlPattern.hash`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {string} The pattern string the pattern will use to match a URLs
+  hash fragment component.
+
+#### `urlPattern.hostname`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {string} The pattern string the pattern will use to match a URLs
+  hostname component.
+
+#### `urlPattern.password`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {string} The pattern string the pattern will use to match a URLs
+  password component.
+
+#### `urlPattern.pathname`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {string} The pattern string the pattern will use to match a URLs
+  pathname component.
+
+#### `urlPattern.port`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {string} The pattern string the pattern will use to match a URLs
+  port component.
+
+#### `urlPattern.protocol`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {string} The pattern string the pattern will use to match a URLs
+  protocol scheme component.
+
+#### `urlPattern.search`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {string} The pattern string the pattern will use to match a URLs
+  querystring component.
+
+#### `urlPattern.test([input[, baseURL]])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `input` {string|URLPatternInit}
+* `baseURL` {string}
+* Returns: {boolean}
+
+Returns `true` if the `input` matches this `URLPattern`.
+
+#### `urlPattern.username`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {string} The pattern string the pattern will use to match a URLs
+  username component.
+
+### Object: `URLPatternInit`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+A `URLPatternInit` is a regular JavaScript object with zero or more of the
+following property attributes that provide patterns for each of the individual
+URL components:
+
+* `protocol` {string}
+* `username` {string}
+* `password` {string}
+* `hostname` {string}
+* `port` {string}
+* `pathname` {string}
+* `search` {string}
+* `hash` {string}
+* `baseURL` {string}
+
+### Object: `URLPatternResult`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+A `URLPatternResult` object is returned by the `urlPattern.exec()` method and
+provides details on the matching components of the `input`.
+
+* `inputs` {string[]|URLPatternInit[]}
+* `protocol` {URLPatternComponentResult}
+* `username` {URLPatternComponentResult}
+* `password` {URLPatternComponentResult}
+* `hostname` {URLPatternComponentResult}
+* `port` {URLPatternComponentResult}
+* `pathname` {URLPatternComponentResult}
+* `search` {URLPatternComponentResult}
+* `hash` {URLPatternComponentResult}
+
+### Object: `URLPatternComponentResult`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+A `URLPatternComponentResult` is a regular JavaScript object that contains
+matching information for an individual URL component.
+
+* `input` {string} The input string that was matched against.
+* `groups` {Object} A JavaScript object containing one or more
+  key and value pairs detailing the relevant matches for the component.
+  The specific keys will depend on the structure the `URLPattern` and
+  the matching input. Keys and values will always be strings.
+
 ## Legacy URL API
 
 <!-- YAML
diff --git a/lib/internal/urlpattern.js b/lib/internal/urlpattern.js
new file mode 100644
index 00000000000000..2f3ebcb1e8b29a
--- /dev/null
+++ b/lib/internal/urlpattern.js
@@ -0,0 +1,1290 @@
+'use strict';
+
+const {
+  ArrayPrototypePush,
+  ObjectDefineProperties,
+  ObjectKeys,
+  RegExp,
+  RegExpPrototypeExec,
+  RegExpPrototypeTest,
+  Symbol,
+  StringPrototypeReplaceAll,
+} = primordials;
+
+const {
+  validateObject,
+} = require('internal/validators');
+
+const {
+  isIdentifierStart,
+  isIdentifierChar,
+} = require('internal/deps/acorn/acorn/dist/acorn');
+
+const {
+  codes: {
+    ERR_INVALID_ARG_VALUE,
+    ERR_INVALID_THIS,
+  },
+} = require('internal/errors');
+
+const {
+  isIPv6,
+} = require('internal/net');
+
+const {
+  customInspectSymbol: kInspect,
+  toUSVString,
+} = require('internal/util');
+
+const { inspect } = require('internal/util/inspect');
+
+const kState = Symbol('kState');
+
+const kSpecialSchemes = {
+  ftp: 21,
+  file: null,
+  http: 80,
+  https: 443,
+  ws: 80,
+  wss: 443,
+};
+
+const kModifiers = {
+  'zero-or-more': '*',
+  'optional': '?',
+  'one-or-more': '+',
+};
+
+const kEscapeRegexp = /([\.\+\*\?\^\$\{\}\(\)\[\]\|\/\\])/g;
+const kASCII = /^[\x00-\x7F]*$/;
+
+/**
+ * @typedef {{
+ *   protocol?: string;
+ *   username?: string;
+ *   password?: string;
+ *   hostname?: string;
+ *   por?t: string;
+ *   pathname?: string;
+ *   search?: string;
+ *   hash?: string;
+ *   baseURL?: string;
+ * }} URLPatternInit
+ *
+ * @typedef {string | URLPatternInit} URLPatternInput
+ *
+ * @typedef {{
+ *   input?: string,
+ *   groups?: Record<string, string>
+ * }} URLPatternComponentResult
+ *
+ * @typedef {{
+ *   inputs?: URLPatternInput[];
+ *   protocol?: URLPatternComponentResult
+ *   username?: URLPatternComponentResult
+ *   password?: URLPatternComponentResult
+ *   hostname?: URLPatternComponentResult
+ *   port?: URLPatternComponentResult
+ *   pathname?: URLPatternComponentResult
+ *   search?: URLPatternComponentResult
+ *   hash?: URLPatternComponentResult
+ * }} URLPatternResult
+ *
+ */
+
+function parseConstructorString(input, baseUrl) {
+  const parser = {
+    input,
+    tokenList: tokenize(input, 'lenient'),
+    result: {},
+    componentStart: 0,
+    tokenIndex: 0,
+    tokenIncrement: 1,
+    groupDepth: 0,
+    hostnameIpv6BracketDepth: 0,
+    protocolMatchesSpecialScheme: false,
+    state: 'init',
+  };
+
+  function changeState(state, skip) {
+    if (parser.state !== 'init' && parser.state !== 'authority' && parser.state !== 'done')
+      parser.result[parser.state] = makeComponentString();
+    parser.state = state;
+    parser.tokenIndex += skip;
+    parser.componentStart = parser.tokenIndex;
+    parser.tokenIncrement = 0;
+  }
+
+  function rewind() {
+    parser.tokenIndex = parser.componentStart;
+    parser.tokenIncrement = 0;
+  }
+
+  function rewindAndSetState(state) {
+    rewind();
+    parser.state = state;
+  }
+
+  function getSafeToken(index) {
+    if (index < parser.tokenList.length)
+      return parser.tokenList[index];
+    // TODO(@jasnell): assert parser.tokenList.length >= 1
+    const lastndex = parser.tokenList.length - 1;
+    const token = parser.tokenList[lastIndex];
+    // TODO(@jasnell): assert token type is 'end'
+    return token;
+  }
+
+  function isNonSpecialPatternChar(index, value) {
+    const token = getSafeToken(index);
+    if (token.value !== value) return false;
+    return token.type === 'char' || token.type === 'escaped-char' || token.type === 'invalid-char';
+  }
+
+  function isProtocolSuffix() {
+    return isNonSpecialPatternChar(parser.tokenIndex, ':');
+  }
+
+  function nextIsAuthoritySlashes() {
+    if (!isNonSpecialPatternChar(parser.tokenIndex + 1, '/')) return false;
+    if (!isNonSpecialPatternChar(parser.tokenIndex + 2, '/')) return false;
+    return true;
+  }
+
+  function isIdentityTerminator() {
+    return isNonSpecialPatternChar(parser.tokenIndex, '@');
+  }
+
+  function isPasswordPrefix() {
+    return isNonSpecialPatternChar(parser.tokenIndex, ':');
+  }
+
+  function isPortPrefix() {
+    return isNonSpecialPatternChar(parser.tokenIndex, ':');
+  }
+
+  function isPathnameStart() {
+    return isNonSpecialPatternChar(parser.tokenIndex, '/');
+  }
+
+  function isSearchPrefix() {
+    if (isNonSpecialPatternChar(parser.tokenIndex, '?')) return true;
+    const token = parser.tokenList[parser.tokenIndex];
+    if (token.value !== '?') return false;
+    const previousIndex = parser.tokenIndex - 1;
+    if (previousIndex < 0) return true;
+    const previousToken = getSafeToken(previousIndex);
+    return previousToken.type !== 'name' &&
+           previousToken.type !== 'regexp' &&
+           previousToken.type !== 'close' &&
+           previousToken.type !== 'asterisk';
+  }
+
+  function isHashPrefix() {
+    return isNonSpecialPatternChar(parser.tokenIndex, '#');
+  }
+
+  function isGroupOpen() {
+    return parser.tokenList[parser.tokenIndex].type === 'open';
+  }
+
+  function isGroupClose() {
+    return parser.tokenList[parser.tokenIndex].type === 'close';
+  }
+
+  function isIPv6Open() {
+    return isNonSpecialPatternChar(parser.tokenIndex, '[');
+  }
+
+  function isIPv6Close() {
+    return isNonSpecialPatternChar(parser.tokenIndex, ']');
+  }
+
+  function makeComponentString() {
+    // TODO(@jasnell): assert parser tokenIndex < parser tokenList size
+    const token = parser.tokenList[parser.tokenIndex];
+    const componentStartToken = getSafeToken(parser.componentStart);
+    const componentStartInputIndex = componentStartToken.index;
+    const endIndex = token.index;
+    return parser.input.slice(componentStartInputIndex, endIndex);
+  }
+
+  function computeProtocolMatchesSpecialSchemeFlag() {
+    parser.protocolMatchesSpecialScheme =
+        protocolMatchesSpecialScheme(compileAndCanonicalize(makeComponentString(), 'protocol'));
+  }
+
+  while (parser.tokenIndex < parser.tokenList.length) {
+    parser.tokenIncrement = 1;
+    const token = parser.tokenList[parser.tokenIndex];
+    if (token.type === 'end') {
+      if (parser.state === 'init') {
+        rewind();
+        if (isHashPrefix()) {
+          changeState('hash', 1);
+        } else if (isSearchPrefix()) {
+          changeState('search', 1);
+          parser.result.hash = '';
+        } else {
+          changeState('pathname', 0);
+          parser.result.search = '';
+          parser.result.hash = '';
+        }
+        parser.tokenIndex += parser.tokenIncrement;
+        continue;
+      }
+      if (parser.state === 'authority') {
+        rewindAndSetState('hostname');
+        parser.tokenIndex += parser.tokenIncrement;
+        continue;
+      }
+      changeState('done', 0);
+      break;
+    }
+    if (isGroupOpen()) {
+      parser.groupDepth++;
+      parser.tokenIndex += parser.tokenIncrement;
+      continue;
+    }
+    if (parser.groupDepth > 0) {
+      if (isGroupClose()) {
+        parser.groupDepth--;
+      } else {
+        parser.tokenIndex += parser.tokenIncrement;
+        continue;
+      }
+    }
+    switch (parser.state) {
+      case 'init': {
+        if (isProtocolSuffix()) {
+          parser.result.username = '';
+          parser.result.password = '';
+          parser.result.hostname = '';
+          parser.result.port = '';
+          parser.result.pathname = '';
+          parser.result.search = '';
+          parser.result.hash = '';
+          rewindAndSetState('protocol');
+        }
+        break;
+      }
+      case 'protocol': {
+        if (isProtocolSuffix()) {
+          computeProtocolMatchesSpecialSchemeFlag();
+          if (parser.protocolMatchesSpecialScheme)
+            parser.result.pathname = '/';
+          let nextState = 'pathname';
+          let skip = 1;
+          if (nextIsAuthoritySlashes()) {
+            nextState = 'authority';
+            skip = 3;
+          } else if (parser.protocolMatchesSpecialScheme) {
+            nextStep = 'authority';
+          }
+          changeState(nextState, skip);
+        }
+        break;
+      }
+      case 'authority': {
+        if (isIdentityTerminator()) {
+          rewindAndSetState('username');
+        } else if (isPathnameStart() || isSearchPrefix || isHashPrefix) {
+          rewindAndSetState('hostname');
+        }
+        break;
+      }
+      case 'username': {
+        if (isPasswordPrefix()) {
+          changeState('password', 1);
+        } else if (isIdentityTerminator()) {
+          changeState('hostname', 1);
+        }
+        break;
+      }
+      case 'password': {
+        if (isIdentityTerminator()) {
+          changeState('hostname', 1);
+        }
+        break;
+      }
+      case 'hostname': {
+        if (isIPv6Open()) {
+          parser.hostnameIpv6BracketDepth++;
+        } else if (isIPv6Close()) {
+          parser.hostnameIpv6BracketDepth--;
+        } else if (isPortPrefix() && parser.hostnameIpv6BracketDepth === 0) {
+          changeState('port', 1);
+        } else if (isPathnameStart()) {
+          changeState('pathname', 0);
+        } else if (isSearchPrefix()) {
+          changeState('search', 1);
+        } else if (isHashPrefix()) {
+          changeState('hash', 1);
+        }
+        break;
+      }
+      case 'port': {
+        if (isPathnameStart()) {
+          changeState('pathname', 0);
+        } else if (isSearchPrefix()) {
+          changeState('search', 1);
+        } else if (isHashPrefix()) {
+          changeState('hash', 1);
+        }
+        break;
+      }
+      case 'pathname': {
+        if (isSearchPrefix()) {
+          changeState('search', 1);
+        } else if (isHashPrefix()) {
+          changeState('hash', 1);
+        }
+        break;
+      }
+      case 'search': {
+        if (isHashPrefix()) {
+          changeState('hash', 1);
+        }
+        break;
+      }
+      case 'hash': {
+        break;
+      }
+      case 'done':
+        // TODO(@jasnell): assert that this is not reached
+    }
+    parser.tokenIndex += parser.tokenIncrement;
+  }
+  return parser.result;
+}
+
+function processURLPatternInit(
+  init,
+  type,
+  protocol = null,
+  username = null,
+  password = null,
+  hostname = null,
+  port = null,
+  pathname = null,
+  search = null,
+  hash = null) {
+  const result = {
+    protocol,
+    username,
+    password,
+    hostname,
+    port,
+    pathname,
+    search,
+    hash,
+  };
+  let baseURL = null;
+  if (init.baseURL != null) {
+    baseURL = new URL(init.baseURL);
+    result.protocol = baseURL.protocol;
+    result.username = baseURL.username;
+    result.password = baseURL.password;
+    result.hostname = baseURL.host;
+    result.port = baseURL.port;
+    result.pathname = baseURL.pathname;
+    result.search = baseURL.search;
+    result.hash = baseURL.hash;
+  }
+  if (init.protocol != null) {
+    const index = init.prototype.lastIndexOf(':');
+    const strippedValue =
+      init.protocol.slice(0, index > -1 ? index : init.protocol.length);
+    if (type === 'pattern')
+      result.protocol = strippedValue;
+    else {
+      result.protocol = runEncoding({ type: 'protocol' }, strippedValue);
+    }
+  }
+  if (init.username != null) {
+    result.username =
+      type === 'pattern' ?
+        init.username :
+        runEncoding({
+          type: 'username',
+          protocol: result.protocol,
+        }, init.username);
+  }
+  if (init.password != null) {
+    result.password =
+      type === 'pattern' ?
+        init.password :
+        runEncoding({
+          type: 'password',
+          protocol: result.protocol,
+        }, init.password);
+  }
+  if (init.hostname != null) {
+    result.hostname =
+      type === 'pattern' ?
+        init.hostname :
+        runEncoding({
+          type: 'hostname',
+          protocol: result.protocol,
+        }, init.hostname);
+  }
+  if (init.port != null) {
+    result.port =
+      type === 'pattern' ?
+        init.port :
+        runEncoding({
+          type: 'port',
+          protocol: result.protocol,
+        }, init.port);
+  }
+  if (init.pathname != null) {
+    result.pathname =
+      type === 'pattern' ?
+        init.pathname :
+        runEncoding({
+          type: 'pathname',
+          protocol: result.protocol,
+        }, init.pathname);
+  }
+  if (init.search != null) {
+    result.search =
+      type === 'pattern' ?
+        init.search :
+        runEncoding({
+          type: 'search',
+          protocol: result.protocol,
+        }, init.search);
+  }
+  if (init.hash != null) {
+    result.hash =
+      type === 'pattern' ?
+        init.hash :
+        runEncoding({
+          type: 'hash',
+          protocol: result.protocol,
+        }, init.hash);
+  }
+  return result;
+}
+
+function tokenize(input = '', policy = 'strict') {
+  const tokenizer = {
+    input,
+    policy,
+    tokenList: [],
+    index: 0,
+    nextIndex: 0,
+    codePoint: null,
+  };
+
+  function addToken(type, nextPosition, valuePosition, valueLength) {
+    const index = tokenizer.index;
+    const value = tokenizer.input.slice(valuePosition, valuePosition + valueLength);
+    ArrayPrototypePush(tokenizer.tokenList, {
+      type,
+      index,
+      value,
+    });
+    tokenizer.index = nextPosition;
+  }
+
+  function addTokenWithDefaultLength(type, nextPosition, valuePosition) {
+    addToken(type, nextPosition, valuePosition, nextPosition - valuePosition);
+  }
+
+  function addTokenWithDefaultPositionAndLength(type) {
+    addTokenWithDefaultLength(type, tokenizer.nextIndex, tokenizer.index);
+  }
+
+  function getNextCodepoint() {
+    tokenizer.codePoint = tokenizer.input[tokenizer.nextIndex++];
+  }
+
+  function seekAndGetNextCodepoint(index) {
+    tokenizer.nextIndex = index;
+    getNextCodepoint();
+  }
+
+  function isValidNameCodepoint(firstCodepoint) {
+    return firstCodepoint ?
+      isIdentifierStart(tokenizer.codePoint) :
+      isIdentifierChar(tokenizer.codePoint);
+  }
+
+  function tokenizerError(nextPosition, valuePosition) {
+    if (policy === 'strict') {
+      // TODO(@jasnell): Throw a proper error
+      throw new TypeError('tokenizer error');
+    }
+    addTokenWithDefaultLength('invalid-char', nextPosition, valuePosition);
+  }
+
+  while (tokenizer.index < tokenizer.input.length) {
+    seekAndGetNextCodepoint(tokenizer.index);
+    switch (tokenizer.codePoint) {
+      case '*': {
+        addTokenWithDefaultPositionAndLength('asterisk');
+        continue;
+      }
+      case '+':
+        // Fall-through
+      case '?': {
+        addTokenWithDefaultPositionAndLength('other-modifier');
+        continue;
+      }
+      case '\\': {
+        if (tokenizer.index === tokenizer.input.length - 1) {
+          tokenizerError(tokenizer.nextIndex, tokenizer.index);
+          continue;
+        }
+        const escapedIndex = tokenizer.nextIndex;
+        getNextCodepoint();
+        addTokenWithDefaultLength('escaped-char', tokenizer.nextIndex, escapedIndex);
+        continue;
+      }
+      case '{': {
+        addTokenWithDefaultPositionAndLength('open');
+        continue;
+      }
+      case '}': {
+        addTokenWithDefaultPositionAndLength('close');
+        continue;
+      }
+      case ':': {
+        let namePosition = tokenizer.nextIndex;
+        const nameStart = namePosition;
+        while (namePosition < tokenizer.input.length) {
+          seekAndGetNextCodepoint(namePosition);
+          const firstCodepoint = namePosition === nameStart;
+          if (!isValidNameCodepoint(firstCodepoint))
+            break;
+          namePosition = tokenizer.nextIndex;
+        }
+        if (namePosition <= nameStart) {
+          tokenizerError(nameStart, tokenizer.index);
+          continue;
+        }
+        addTokenWithDefaultLength('name', namePosition, nameStart);
+        continue;
+      }
+      case '(': {
+        let depth = 1;
+        let regexPosition = tokenizer.nextIndex;
+        const regexStart = regexPosition;
+        let error = false;
+        while (regexPosition < tokenizer.input.length) {
+          seekAndGetNextCodepoint(regexPosition);
+          if (!RegExpPrototypeTest(kASCII, tokenizer.codePoint)) {
+            tokenizerError(regexStart, tokenizer.index);
+            error = true;
+            break;
+          }
+          if (regexPosition === regexStart && tokenizer.codePoint === '?') {
+            tokenizerError(regexStart, tokenizer.index);
+            error = true;
+            break;
+          }
+          if (tokenizer.codePoint === '\\') {
+            if (regexPosition === tokenizer.input.length - 1) {
+              tokenizerError(regexStart, tokenizer.index);
+              error = true;
+              break;
+            }
+            getNextCodepoint();
+            if (!RegExpPrototypeTest(kASCII, tokenizer.codePoint)) {
+              tokenizerError(regexStart, tokenizer.index);
+              error = true;
+              break;
+            }
+            regexPosition = tokenizer.nextIndex;
+            continue;
+          }
+          if (tokenizer.codePoint === ')') {
+            if (--depth === 0) {
+              regexPosition = tokenizer.nextIndex;
+              break;
+            }
+          }
+          if (tokenizer.codePoint === '(') {
+            depth++;
+            if (regexPosition === tokenizer.input.length - 1) {
+              tokenizerError(regexStart, tokenizer.index);
+              error = true;
+              break;
+            }
+            const temporaryPosition = tokenizer.nextIndex;
+            getNextCodepoint();
+            if (tokenizer.codePoint !== '?') {
+              tokenizerError(regexStart, tokenizer.index);
+              error = true;
+              break;
+            }
+            tokenizer.nextIndex = temporaryPosition;
+          }
+          regexPosition = tokenizer.nextIndex;
+        }
+        if (error) continue;
+        if (depth > 0) {
+          tokenizerError(regexStart, tokenizer.index);
+          continue;
+        }
+        const regexLength = regexPosition - regexStart - 1;
+        if (regexLength === 0) {
+          tokenizerError(regexStart, tokenizer.index);
+          continue;
+        }
+        addToken('regex', regexPosition, regexStart, regexLength);
+        continue;
+      }
+    }
+    addTokenWithDefaultPositionAndLength('char');
+  }
+  addTokenWithDefaultLength('end', tokenizer.index, tokenizer.index);
+  return tokenizer.tokenList;
+}
+
+function tryConsumeToken(parser, type) {
+  const nextToken = parser.tokenList[parser.index];
+  if (nextToken.type !== type)
+    return undefined;
+  parser.index++;
+  return nextToken;
+}
+
+function tryConsumeRegExpOrWildcardToken(nameToken, parser) {
+  const token = tryConsumeToken(parser, 'regexp');
+  return nameToken == null && token == null ?
+    tryConsumeToken(parser, 'asterisk') : token;
+}
+
+function tryConsumeModifierToken(parser) {
+  const token = tryConsumeToken(parser, 'other-modifier');
+  if (token != null) return token;
+  return tryConsumeToken(parser, 'asterisk');
+}
+
+function runEncoding(parser, value) {
+  if (value === '') return value;
+  try {
+    let parseResult = new URL(`${parser.protocol||value}://dummy.test`);
+
+    switch (parser.type) {
+      case 'protocol':
+        return parseResult.scheme;
+      case 'username': {
+        parseResult.username = value;
+        return parseResult.username;
+      }
+      case 'password': {
+        parseResult.password = value;
+        return parseResult.password;
+      }
+      case 'hostname': {
+        parseResult.hostname = value;
+        return parseResult.hostname;
+      }
+      case 'hostname-ipv6': {
+        return value.toLowerCase();
+      }
+      case 'port': {
+        parseResult.port = value;
+        return parseResult.port;
+      }
+      case 'pathname': {
+        // TODO(@jasnell): Implement properly?
+        parseResult.pathname = value;
+        return parseResult.pathname;
+      }
+      case 'opaque-pathname': {
+        parseResult.pathname = value;
+        return parseResult.pathname;
+      }
+      case 'search': {
+        parseResult.search = value;
+        return parseResult.search;
+      }
+      case 'hash': {
+        parseResult.hash = value;
+        return parseResult.hash;
+      }
+    }
+    // TODO(@jasnell): Throw proper error. Should be an assert
+    throw new TypeError('Unknown type');
+  } catch (err) {
+    // TODO(@jasnell): Throw proper error
+    throw new TypeError(`Invalid ${parser.type}`);
+  }
+}
+
+function maybeAddPartFromPendingFixedValue(parser) {
+  if (parser.pendingFixedValue === '') return;
+  const encodedValue = runEncoding(parser, parser.pendingFixedValue);
+  parser.pendingFixedValue = '';
+  ArrayPrototypePush(
+    parser.partList, {
+    type: 'fixed-text',
+    value: encodedValue,
+    modifier: 'none',
+  });
+}
+
+function isDuplicateName(parser, name) {
+  for (const part of parser.partList) {
+    if (part.name === name) return true;
+  }
+  return false;
+}
+
+function addPart(
+  parser,
+  prefix,
+  nameToken,
+  regexpOrWildcardToken,
+  suffix,
+  modifierToken) {
+  let modifier = 'none';
+  if (modifierToken !== undefined) {
+    switch (modifierToken.value) {
+      case '?': modifier = 'optional';
+      case '*': modifier = 'zero-or-more';
+      case '+': modifier = 'one-or-more';
+    }
+  }
+  if (nameToken === undefined && regexpOrWildcardToken === undefined && modifier === 'none') {
+    parser.pendingFixedValue += prefix;
+    return;
+  }
+  maybeAddPartFromPendingFixedValue(parser);
+  if (nameToken === undefined && regexpOrWildcardToken === undefined) {
+    if (prefix === '') return;
+    const encodedValue = runEncoding(parser, prefix);
+    ArrayPrototypePush(
+      parser.partList, {
+      type: 'fixed-text',
+      value: encodedValue,
+      modifier,
+    });
+    return;
+  }
+  let regexpValue = '';
+  if (regexpOrWildcardToken === undefined) {
+    regexpValue = parser.segmentWildcard;
+  } else if (regexpOrWildcardToken.type === 'asterisk') {
+    regexpValue = '.*';
+  } else {
+    regexpValue = regexpOrWildcardToken.value;
+  }
+  let type = 'regexp';
+  if (regexpValue === parser.segmentWildcard) {
+    type = 'segment-wildcard';
+    regexpValue = '';
+  } else if (regexpValue === '.*') {
+    type = 'full-wildcard';
+    regexpValue = '';
+  }
+  let name = '';
+  if (nameToken !== undefined) {
+    name = nameToken.value;
+  } else if (regexpOrWildcardToken !== undefined) {
+    name = parser.nextNumericName++;
+  }
+  if (isDuplicateName(parser, name)) {
+    // TODO(@jasnell): Proper error
+    throw new ERR_INVALID_ARG_VALUE('input', name);
+  }
+  const encodedValue = runEncoding(parser, prefix);
+  const encodedSuffix = runEncoding(parser, suffix);
+  ArrayPrototypePush(
+    parser.partList, {
+    type,
+    value: regexpValue,
+    modifier,
+    name,
+    prefix: encodedValue,
+    suffix: encodedSuffix,
+  });
+}
+
+function consumeText(parser) {
+  let result = '';
+  while (true) {
+    let token = tryConsumeToken(parser, 'char');
+    if (token === undefined)
+      token = tryConsumeToken(parser, 'escaped-char');
+    if (token === undefined) break;
+    result += token.value;
+  }
+  return result;
+}
+
+function consumeRequiredToken(parser, type) {
+  let result = tryConsumeToken(parser, type);
+  if (result === undefined) {
+    // TODO(@jasnell): Throw a proper error
+    throw new TypeError('Missing a required token');
+  }
+  return result;
+}
+
+function parsePatternString(input, type, options) {
+  const {
+    delimiterCodePoint = '',
+    prefixCodePoint = '',
+  } = options;
+  const parser = {
+    index: 0,
+    type,
+    segmentWildcard: `[^${StringPrototypeReplaceAll(delimiterCodePoint, kEscapeRegexp, '$1')}]+?`,
+    tokenList: tokenize(input, 'strict'),
+    partList: [],
+    pendingFixedValue: '',
+    nextNumericName: 0,
+  };
+
+  while(parser.index < parser.tokenList.length) {
+    const charToken = tryConsumeToken(parser, 'char');
+    let nameToken = tryConsumeToken(parser, 'name');
+    let regexpOrWildcardToken = tryConsumeRegExpOrWildcardToken(nameToken, parser);
+    if (nameToken != null || regexpOrWildcardToken != null) {
+      let prefix = '';
+      if (charToken != null)
+        prefix = charToken.value;
+      if (prefix !== '' && prefix !== prefixCodePoint) {
+        parser.pendingFixedValue += prefix;
+        prefix = '';
+      }
+      maybeAddPartFromPendingFixedValue(parser);
+      const modifierToken = tryConsumeModifierToken(parser);
+      addPart(parser, prefix, nameToken, regexpOrWildcardToken, '', modifierToken);
+      continue;
+    }
+
+    const fixedToken = charToken != null ? charToken : tryConsumeToken(parser, 'escaped-char');
+
+    if (fixedToken != null) {
+      parser.pendingFixedValue += fixedToken.value;
+      continue;
+    }
+
+    const openToken = tryConsumeToken(parser, 'open');
+    if (openToken != null) {
+      prefix = consumeText(parser);
+      nameToken = tryConsumeToken(parser, 'name');
+      regexpOrWildcardToken = tryConsumeRegExpOrWildcardToken(nameToken, parser);
+      let suffix = consumeText(parser);
+      consumeRequiredToken(parser, 'close');
+      const modifierToken = tryConsumeModifierToken(parser);
+      addPart(parser, prefix, nameToken, regexpOrWildcardToken, suffix, modifierToken);
+      continue;
+    }
+
+    maybeAddPartFromPendingFixedValue(parser);
+    consumeRequiredToken(parser, 'end');
+  }
+
+  return parser.partList;
+}
+
+function generateRegexAndNameList(partList, options) {
+  const {
+    delimiterCodePoint,
+  } = options;
+  let regexString = '^';
+  let nameList = [];
+  for (let n = 0; n < partList.length; n++) {
+    const part = partList[n];
+    if (part.type === 'fixed-text') {
+      const escapedValue = StringPrototypeReplaceAll(part.value, kEscapeRegexp, '$1');
+      regexString += part.modifier === 'none' ?
+        escapedValue :
+        `(?:${escapedValue})${kModifiers[part.modifier] || ''}`;
+      continue;
+    }
+    // TODO(@jasnell): assert part name is not empty string
+    ArrayPrototypePush(nameList, part.name);
+    let regexValue = part.value;
+    if (part.type === 'segment-wildcard') {
+      regexValue = `([^${StringPrototypeReplaceAll(delimiterCodePoint, kEscapeRegexp, '$1')}]+?)`
+    } else if (part.type === 'full-wildcard') {
+      regexValue = '.*';
+    }
+    if (part.prefix === '' && part.suffix === '') {
+      regexString += part.modifier === 'none' || part.modifier === 'optional' ?
+        `(${regexValue})${kModifiers[part.modifier] || ''}` :
+        `((?:${regexValue})${kModifiers[part.modifier] || ''})`;
+      continue;
+    }
+    const pfx = StringPrototypeReplaceAll(part.prefix, kEscapeRegexp, '$1');
+    const sfx = StringPrototypeReplaceAll(part.suffix, kEscapeRegexp, '$1');
+    if (part.modifier === 'none' || part.modifier === 'optional') {
+      regexString += `(?:${pfx}(${regexValue})${sfx})${kModifiers[part.modifier] || ''}`;
+      continue;
+    }
+    // TODO(@jasnell): assert part.modifier is 'zero-or-more' or 'one-or-more'
+    //                 assert part.prefix and part.suffix are not empty string
+    regexString += `(?:${pfx}((?:${regexValue})(?:${sfx}${pfx}(?:{regexValue}))*)${sfx})`;
+    if (part.modifier === 'zero-or-more') regexString += '?';
+  }
+  regexString += '$';
+  return { regexString, nameList };
+}
+
+function generatePatternString(partList, options) {
+  let result = '';
+  const {
+    delimiterCodePoint,
+    prefixCodePoint,
+  } = options;
+
+  function escapePatternString(value) {
+    // TODO(@jasnell): assert value is an ascii string
+    let result = '';
+    let index = 0;
+    while (index < value.length) {
+      const c = value[index++];
+      switch (c) {
+        case '+':
+        case '*':
+        case '?':
+        case ':':
+        case '{':
+        case '}':
+        case '(':
+        case ')':
+        case '\\':
+          result += '\\';
+      }
+      result += c;
+    }
+    return result;
+  }
+
+  for (let n = 0; n < partList.length; n++) {
+    const part = partList[n];
+    if (part.type === 'fixed-text') {
+      if (part.modifier === 'none') {
+        result += escapePatternString(part.value);
+        continue;
+      }
+      result += `{${escapePatternString(part.value)}}${kModifiers[part.modifier] || ''}`;
+      continue;
+    }
+    const needsGrouping =
+      part.suffix !== '' ||
+      (part.prefix !== '' && part.prefix !== prefixCodePoint);
+    // TODO(@jasnell): assert part.name !== '' and part.name !== null
+    const customName = RegExpPrototypeTest(/^[^\d]/, part.name);
+    if (needsGrouping) result += '{';
+    result += escapePatternString(part.prefix);
+    if (customName) result += `:${part.name}`;
+    if (part.type === 'regexp')
+      result += `(${part.value})`;
+    else if (part.type === 'segment-wildcard' && !customName)
+      result += `([^${StringPrototypeReplaceAll(delimiterCodePoint, kEscapeRegexp, '$1')}]+?)`
+    else if (part.type === 'full-wildcard')
+      result += customName ? '(.*)' : '*';
+    result += escapePatternString(part.suffix);
+    if (needsGrouping) result += '}';
+    result += kModifiers[part.modifier] || '';
+  }
+  return result;
+}
+
+function compileAndCanonicalize(component, type, options = {}) {
+  if (component == null)
+    component = '*';
+
+  const partList = parsePatternString(component, type, options);
+  const {
+    regexString,
+    nameList,
+  } = generateRegexAndNameList(partList, options);
+
+  let regex;
+  try {
+    regex = new RegExp(regexString, 'u');
+  } catch (err) {
+    throw new ERR_INVALID_ARG_VALUE(`input.${type}`, component);
+  }
+
+  const pattern = generatePatternString(partList, options);
+
+  return {
+    pattern,
+    regex,
+    nameList,
+  };
+}
+
+function protocolMatchesSpecialScheme(protocol) {
+  const schemes = ObjectKeys(kSpecialSchemes);
+  for (let n = 0; n < schemes.length; n++) {
+    const scheme = schemes[n];
+    if (RegExpPrototypeExec(protocol.regex, scheme))
+      return true;
+  }
+  return false;
+}
+
+function match(urlPattern, input, baseURLString) {
+  let protocol = '';
+  let username = '';
+  let password = '';
+  let hostname = '';
+  let port = '';
+  let pathname = '';
+  let search = '';
+  let hash = '';
+  const inputs = [ input ];
+
+  if (typeof input === 'object' && input != null) {
+    if (baseURLString !== undefined) {
+      // TODO(@jasnell): Throw a proper error
+      throw new TypeError('baseURL should not be provided');
+    }
+    try {
+      const applyResult =
+        processURLPatternInit(
+          input,
+          'url',
+          protocol,
+          username,
+          password,
+          hostname,
+          port,
+          pathname,
+          search,
+          hash);
+      protocol = applyResult.protocol;
+      username = applyResult.username;
+      password = applyResult.password;
+      hostname = applyResult.hostname;
+      port = applyResult.port;
+      pathname = applyResult.pathname;
+      search = applyResult.search;
+      hash = applyResult.hash;
+    } catch {
+      return null;
+    }
+  } else {
+    let baseURL;
+    let url;
+    try {
+      if (baseURLString !== undefined) {
+        baseURL = new URL(baseURLString);
+        ArrayPrototypePush(inputs, baseURLString);
+      }
+      url = new URL(input, baseURL);
+    } catch {
+      return null;
+    }
+    protocol = url.protocol.slice(0, -1);  // Trim the trailing :
+    username = url.username;
+    password = url.password;
+    hostname = url.host;
+    port = url.port;
+    pathname = url.pathname;
+    search = url.search.slice(1);  // Trim the leading ?
+    hash = url.hash.slice(1);  // Trim the leading #
+  }
+
+  const protocolExecResult = RegExpPrototypeExec(urlPattern.protocol.regex, protocol);
+  const usernameExecResult = RegExpPrototypeExec(urlPattern.username.regex, username);
+  const passwordExecResult = RegExpPrototypeExec(urlPattern.password.regex, password);
+  const hostnameExecResult = RegExpPrototypeExec(urlPattern.hostname.regex, hostname);
+  const portExecResult = RegExpPrototypeExec(urlPattern.port.regex, port);
+  const pathnameExecResult = RegExpPrototypeExec(urlPattern.pathname.regex, pathname);
+  const searchExecResult = RegExpPrototypeExec(urlPattern.search.regex, search);
+  const hashExecResult = RegExpPrototypeExec(urlPattern.hash.regex, hash);
+  if (protocolExecResult == null &&
+      usernameExecResult == null &&
+      passwordExecResult == null &&
+      hostnameExecResult == null &&
+      portExecResult == null &&
+      pathnameExecResult == null &&
+      searchExecResult == null &&
+      hashExecResult == null) {
+    return null;
+  }
+  return {
+    inputs,
+    protocol: createResult(urlPattern.protocol, protocol, protocolExecResult),
+    username: createResult(urlPattern.username, username, usernameExecResult),
+    password: createResult(urlPattern.password, password, passwordExecResult),
+    hostname: createResult(urlPattern.hostname, hostname, hostnameExecResult),
+    port: createResult(urlPattern.port, port, portExecResult),
+    pathname: createResult(urlPattern.pathname, pathname, pathnameExecResult),
+    search: createResult(urlPattern.search, search, searchExecResult),
+    hash: createResult(urlPattern.hash, hash, hashExecResult),
+  };
+}
+
+function createResult(component, input, result) {
+  const groups = {};
+  let index = 1;
+  while (index < result.length) {
+    const name = component.nameList[index - 1];
+    const value = `${result[index++]}`;
+    groups[name] = value;
+  }
+  return {
+    input,
+    groups,
+  }
+}
+
+class URLPattern {
+  /**
+   * @param {URLPatternInput} [input]
+   * @param {string} [baseURL]
+   */
+  constructor(input = {}, baseURL = undefined) {
+    if (typeof input === 'string') {
+      input = parseConstructorString(toUsvString(input), baseURL);
+    } else {
+      validateObject(input, 'input');
+      if (baseURL !== undefined)
+        throw new ERR_INVALID_ARG_VALUE('baseURL', baseURL);
+    }
+    input = processURLPatternInit(input, 'pattern');
+
+    const defaultPort = kSpecialSchemes[input.protocol];
+    if (defaultPort !== undefined && `${input.port}` === `${defaultPort}`)
+      input.port = '';
+
+    const protocol = compileAndCanonicalize(input.protocol, 'protocol');
+
+    this[kState] = {
+      protocol,
+      username: compileAndCanonicalize(input.username, 'username'),
+      password: compileAndCanonicalize(input.password, 'password'),
+      hostname: isIPv6(input.hostname) ?
+        compileAndCanonicalize(input.hostname, 'hostname-ipv6') :
+        compileAndCanonicalize(input.hostname, 'hostname'),
+      port: compileAndCanonicalize(input.port, 'port'),
+      pathname: protocolMatchesSpecialScheme(protocol) ?
+        compileAndCanonicalize(input.pathname, 'pathname', {
+          delimiterCodePoint: '/',
+          prefixCodePoint: '/',
+        }) :
+        compileAndCanonicalize(input.pathname, 'pathname'),
+      search: compileAndCanonicalize(input.search, 'search'),
+      hash: compileAndCanonicalize(input.hash, 'hash'),
+    };
+  }
+
+  /**
+   * @param {URLPatternInput} [input]
+   * @param {string} [baseURL]
+   * @returns {boolean}
+   */
+  test(input, baseURL) {
+    if (this[kState] === undefined)
+      throw new ERR_INVALID_THIS('URLPattern');
+    return match(this[kState], input, baseURL) != null;
+  }
+
+  /**
+   * @param {URLPatternInput} [input]
+   * @param {string} [baseURL]
+   * @param {URLPatternResult}
+   */
+  exec(input, baseURL) {
+    if (this[kState] === undefined)
+      throw new ERR_INVALID_THIS('URLPattern');
+    return match(this[kState], input, baseURL);
+  }
+
+  /** @readonly @type {string} */
+  get protocol() {
+    if (this[kState] === undefined)
+      throw new ERR_INVALID_THIS('URLPattern');
+    return this[kState].protocol.pattern;
+  }
+
+  /** @readonly @type {string} */
+  get username() {
+    if (this[kState] === undefined)
+      throw new ERR_INVALID_THIS('URLPattern');
+    return this[kState].username.pattern;
+  }
+
+  /** @readonly @type {string} */
+  get password() {
+    if (this[kState] === undefined)
+      throw new ERR_INVALID_THIS('URLPattern');
+    return this[kState].password.pattern;
+  }
+
+  /** @readonly @type {string} */
+  get hostname() {
+    if (this[kState] === undefined)
+      throw new ERR_INVALID_THIS('URLPattern');
+    return this[kState].hostname.pattern;
+  }
+
+  /** @readonly @type {string} */
+  get port() {
+    if (this[kState] === undefined)
+      throw new ERR_INVALID_THIS('URLPattern');
+    return this[kState].port.pattern;
+  }
+
+  /** @readonly @type {string} */
+  get pathname() {
+    if (this[kState] === undefined)
+      throw new ERR_INVALID_THIS('URLPattern');
+    return this[kState].pathname.pattern;
+  }
+
+  /** @readonly @type {string} */
+  get search() {
+    if (this[kState] === undefined)
+      throw new ERR_INVALID_THIS('URLPattern');
+    return this[kState].search.pattern;
+  }
+
+  /** @readonly @type {string} */
+  get hash() {
+    if (this[kState] === undefined)
+      throw new ERR_INVALID_THIS('URLPattern');
+    return this[kState].hash.pattern;
+  }
+
+  [kInspect](depth, options) {
+    if (this[kState] === undefined)
+      throw new ERR_INVALID_THIS('URLPattern');
+
+    if (depth < 0)
+      return this;
+
+    const opts = {
+      ...options,
+      depth: options.depth == null ? null : options.depth - 1
+    };
+
+    return `URLPattern ${inspect({
+      protocol: this.protocol,
+      username: this.username,
+      password: this.password,
+      hostname: this.hostname,
+      port: this.port,
+      pathname: this.pathname,
+      search: this.search,
+      hash: this.hash,
+    }, opts)}`;
+  }
+}
+
+ObjectDefineProperties(URLPattern.prototype, {
+  prototcol: { enumerable: true, },
+  username: { enumerable: true, },
+  password: { enumerable: true, },
+  hostname: { enumerable: true, },
+  port: { enumerable: true, },
+  pathname: { enumerable: true, },
+  search: { enumerable: true, },
+  hash: { enumerable: true, },
+});
+
+module.exports = URLPattern;
diff --git a/lib/url.js b/lib/url.js
index 745c7c9930deda..af06d56da030e4 100644
--- a/lib/url.js
+++ b/lib/url.js
@@ -56,6 +56,8 @@ const {
   urlToHttpOptions,
 } = require('internal/url');
 
+const URLPattern = require('internal/urlpattern');
+
 // Original url.parse() API
 
 function Url() {
@@ -1014,6 +1016,8 @@ module.exports = {
   domainToASCII,
   domainToUnicode,
 
+  URLPattern,
+
   // Utilities
   pathToFileURL,
   fileURLToPath,
diff --git a/test/fixtures/wpt/README.md b/test/fixtures/wpt/README.md
index f5d946eff1123b..186bf76de0d303 100644
--- a/test/fixtures/wpt/README.md
+++ b/test/fixtures/wpt/README.md
@@ -25,6 +25,7 @@ Last update:
 - resources: https://github.com/web-platform-tests/wpt/tree/fbee645164/resources
 - streams: https://github.com/web-platform-tests/wpt/tree/8f60d94439/streams
 - url: https://github.com/web-platform-tests/wpt/tree/77d54aa9e0/url
+- urlpattern: https://github.com/web-platform-tests/wpt/tree/111b696bdb/urlpattern
 - user-timing: https://github.com/web-platform-tests/wpt/tree/df24fb604e/user-timing
 - WebCryptoAPI: https://github.com/web-platform-tests/wpt/tree/cdd0f03df4/WebCryptoAPI
 - webidl/ecmascript-binding/es-exceptions: https://github.com/web-platform-tests/wpt/tree/a370aad338/webidl/ecmascript-binding/es-exceptions
diff --git a/test/fixtures/wpt/urlpattern/resources/urlpattern-compare-test-data.json b/test/fixtures/wpt/urlpattern/resources/urlpattern-compare-test-data.json
new file mode 100644
index 00000000000000..0043ac08bca554
--- /dev/null
+++ b/test/fixtures/wpt/urlpattern/resources/urlpattern-compare-test-data.json
@@ -0,0 +1,152 @@
+[
+  {
+    "component": "pathname",
+    "left": { "pathname": "/foo/a" },
+    "right": { "pathname": "/foo/b" },
+    "expected": -1
+  },
+  {
+    "component": "pathname",
+    "left": { "pathname": "/foo/b" },
+    "right": { "pathname": "/foo/bar" },
+    "expected": -1
+  },
+  {
+    "component": "pathname",
+    "left": { "pathname": "/foo/bar" },
+    "right": { "pathname": "/foo/:bar" },
+    "expected": 1
+  },
+  {
+    "component": "pathname",
+    "left": { "pathname": "/foo/" },
+    "right": { "pathname": "/foo/:bar" },
+    "expected": 1
+  },
+  {
+    "component": "pathname",
+    "left": { "pathname": "/foo/:bar" },
+    "right": { "pathname": "/foo/*" },
+    "expected": 1
+  },
+  {
+    "component": "pathname",
+    "left": { "pathname": "/foo/{bar}" },
+    "right": { "pathname": "/foo/(bar)" },
+    "expected": 1
+  },
+  {
+    "component": "pathname",
+    "left": { "pathname": "/foo/{bar}" },
+    "right": { "pathname": "/foo/{bar}+" },
+    "expected": 1
+  },
+  {
+    "component": "pathname",
+    "left": { "pathname": "/foo/{bar}+" },
+    "right": { "pathname": "/foo/{bar}?" },
+    "expected": 1
+  },
+  {
+    "component": "pathname",
+    "left": { "pathname": "/foo/{bar}?" },
+    "right": { "pathname": "/foo/{bar}*" },
+    "expected": 1
+  },
+  {
+    "component": "pathname",
+    "left": { "pathname": "/foo/(123)" },
+    "right": { "pathname": "/foo/(12)" },
+    "expected": 1
+  },
+  {
+    "component": "pathname",
+    "left": { "pathname": "/foo/:b" },
+    "right": { "pathname": "/foo/:a" },
+    "expected": 0
+  },
+  {
+    "component": "pathname",
+    "left": { "pathname": "*/foo" },
+    "right": { "pathname": "*" },
+    "expected": 1
+  },
+  {
+    "component": "port",
+    "left": { "port": "9" },
+    "right": { "port": "100" },
+    "expected": 1
+  },
+  {
+    "component": "pathname",
+    "left": { "pathname": "foo/:bar?/baz" },
+    "right": { "pathname": "foo/{:bar}?/baz" },
+    "expected": -1
+  },
+  {
+    "component": "pathname",
+    "left": { "pathname": "foo/:bar?/baz" },
+    "right": { "pathname": "foo{/:bar}?/baz" },
+    "expected": 0
+  },
+  {
+    "component": "pathname",
+    "left": { "pathname": "foo/:bar?/baz" },
+    "right": { "pathname": "fo{o/:bar}?/baz" },
+    "expected": 1
+  },
+  {
+    "component": "pathname",
+    "left": { "pathname": "foo/:bar?/baz" },
+    "right": { "pathname": "foo{/:bar/}?baz" },
+    "expected": -1
+  },
+  {
+    "component": "pathname",
+    "left": "https://a.example.com/b?a",
+    "right": "https://b.example.com/a?b",
+    "expected": 1
+  },
+  {
+    "component": "pathname",
+    "left": { "pathname": "/foo/{bar}/baz" },
+    "right": { "pathname": "/foo/bar/baz" },
+    "expected": 0
+  },
+  {
+    "component": "protocol",
+    "left": { "protocol": "a" },
+    "right": { "protocol": "b" },
+    "expected": -1
+  },
+  {
+    "component": "username",
+    "left": { "username": "a" },
+    "right": { "username": "b" },
+    "expected": -1
+  },
+  {
+    "component": "password",
+    "left": { "password": "a" },
+    "right": { "password": "b" },
+    "expected": -1
+  },
+  {
+    "component": "hostname",
+    "left": { "hostname": "a" },
+    "right": { "hostname": "b" },
+    "expected": -1
+  },
+  {
+    "component": "search",
+    "left": { "search": "a" },
+    "right": { "search": "b" },
+    "expected": -1
+  },
+  {
+    "component": "hash",
+    "left": { "hash": "a" },
+    "right": { "hash": "b" },
+    "expected": -1
+  }
+]
diff --git a/test/fixtures/wpt/urlpattern/resources/urlpattern-compare-tests.js b/test/fixtures/wpt/urlpattern/resources/urlpattern-compare-tests.js
new file mode 100644
index 00000000000000..b92b53ee45cd98
--- /dev/null
+++ b/test/fixtures/wpt/urlpattern/resources/urlpattern-compare-tests.js
@@ -0,0 +1,26 @@
+function runTests(data) {
+  for (let entry of data) {
+    test(function() {
+      const left = new URLPattern(entry.left);
+      const right = new URLPattern(entry.right);
+
+      assert_equals(URLPattern.compareComponent(entry.component, left, right), entry.expected);
+
+      // We have to coerce to an integer here in order to avoid asserting
+      // that `+0` is `-0`.
+      const reverse_expected = ~~(entry.expected * -1);
+      assert_equals(URLPattern.compareComponent(entry.component, right, left), reverse_expected, "reverse order");
+
+      assert_equals(URLPattern.compareComponent(entry.component, left, left), 0, "left equality");
+      assert_equals(URLPattern.compareComponent(entry.component, right, right), 0, "right equality");
+    }, `Component: ${entry.component} ` +
+       `Left: ${JSON.stringify(entry.left)} ` +
+       `Right: ${JSON.stringify(entry.right)}`);
+  }
+}
+
+promise_test(async function() {
+  const response = await fetch('resources/urlpattern-compare-test-data.json');
+  const data = await response.json();
+  runTests(data);
+}, 'Loading data...');
diff --git a/test/fixtures/wpt/urlpattern/resources/urlpatterntestdata.json b/test/fixtures/wpt/urlpattern/resources/urlpatterntestdata.json
new file mode 100644
index 00000000000000..6773648da07824
--- /dev/null
+++ b/test/fixtures/wpt/urlpattern/resources/urlpatterntestdata.json
@@ -0,0 +1,2731 @@
+[
+  {
+    "pattern": [{ "pathname": "/foo/bar" }],
+    "inputs": [{ "pathname": "/foo/bar" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar", "groups": {} }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar" }],
+    "inputs": [{ "pathname": "/foo/ba" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar" }],
+    "inputs": [{ "pathname": "/foo/bar/" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar" }],
+    "inputs": [{ "pathname": "/foo/bar/baz" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar" }],
+    "inputs": [ "https://example.com/foo/bar" ],
+    "expected_match": {
+      "hostname": { "input": "example.com", "groups": { "0": "example.com" } },
+      "pathname": { "input": "/foo/bar", "groups": {} },
+      "protocol": { "input": "https", "groups": { "0": "https" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar" }],
+    "inputs": [ "https://example.com/foo/bar/baz" ],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar" }],
+    "inputs": [{ "hostname": "example.com", "pathname": "/foo/bar" }],
+    "expected_match": {
+      "hostname": { "input": "example.com", "groups": { "0": "example.com" } },
+      "pathname": { "input": "/foo/bar", "groups": {} }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar" }],
+    "inputs": [{ "hostname": "example.com", "pathname": "/foo/bar/baz" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar" }],
+    "inputs": [{ "pathname": "/foo/bar", "baseURL": "https://example.com" }],
+    "expected_match": {
+      "hostname": { "input": "example.com", "groups": { "0": "example.com" } },
+      "pathname": { "input": "/foo/bar", "groups": {} },
+      "protocol": { "input": "https", "groups": { "0": "https" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar" }],
+    "inputs": [{ "pathname": "/foo/bar/baz",
+                 "baseURL": "https://example.com" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar",
+                 "baseURL": "https://example.com?query#hash" }],
+    "inputs": [{ "pathname": "/foo/bar" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar",
+                 "baseURL": "https://example.com?query#hash" }],
+    "inputs": [{ "hostname": "example.com", "pathname": "/foo/bar" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar",
+                 "baseURL": "https://example.com?query#hash" }],
+    "inputs": [{ "protocol": "https", "hostname": "example.com",
+                 "pathname": "/foo/bar" }],
+    "exactly_empty_components": [ "username", "password", "port" ],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar",
+                 "baseURL": "https://example.com" }],
+    "inputs": [{ "protocol": "https", "hostname": "example.com",
+                 "pathname": "/foo/bar" }],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_match": {
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/foo/bar", "groups": {} },
+      "protocol": { "input": "https", "groups": {} }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar",
+                 "baseURL": "https://example.com" }],
+    "inputs": [{ "protocol": "https", "hostname": "example.com",
+                 "pathname": "/foo/bar/baz" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar",
+                 "baseURL": "https://example.com?query#hash" }],
+    "inputs": [{ "protocol": "https", "hostname": "example.com",
+                 "pathname": "/foo/bar", "search": "otherquery",
+                 "hash": "otherhash" }],
+    "exactly_empty_components": [ "username", "password", "port" ],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar",
+                 "baseURL": "https://example.com" }],
+    "inputs": [{ "protocol": "https", "hostname": "example.com",
+                 "pathname": "/foo/bar", "search": "otherquery",
+                 "hash": "otherhash" }],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar",
+                 "baseURL": "https://example.com?otherquery#otherhash" }],
+    "inputs": [{ "protocol": "https", "hostname": "example.com",
+                 "pathname": "/foo/bar", "search": "otherquery",
+                 "hash": "otherhash" }],
+    "exactly_empty_components": [ "username", "password", "port" ],
+    "expected_match": {
+      "hash": { "input": "otherhash", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/foo/bar", "groups": {} },
+      "protocol": { "input": "https", "groups": {} },
+      "search": { "input": "otherquery", "groups": {} }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar",
+                 "baseURL": "https://example.com?query#hash" }],
+    "inputs": [ "https://example.com/foo/bar" ],
+    "exactly_empty_components": [ "username", "password", "port" ],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar",
+                 "baseURL": "https://example.com?query#hash" }],
+    "inputs": [ "https://example.com/foo/bar?otherquery#otherhash" ],
+    "exactly_empty_components": [ "username", "password", "port" ],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar",
+                 "baseURL": "https://example.com?query#hash" }],
+    "inputs": [ "https://example.com/foo/bar?query#hash" ],
+    "exactly_empty_components": [ "username", "password", "port" ],
+    "expected_match": {
+      "hash": { "input": "hash", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/foo/bar", "groups": {} },
+      "protocol": { "input": "https", "groups": {} },
+      "search": { "input": "query", "groups": {} }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar",
+                 "baseURL": "https://example.com?query#hash" }],
+    "inputs": [ "https://example.com/foo/bar/baz" ],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar",
+                 "baseURL": "https://example.com?query#hash" }],
+    "inputs": [ "https://other.com/foo/bar" ],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar",
+                 "baseURL": "https://example.com?query#hash" }],
+    "inputs": [ "http://other.com/foo/bar" ],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar",
+                 "baseURL": "https://example.com?query#hash" }],
+    "inputs": [{ "pathname": "/foo/bar", "baseURL": "https://example.com" }],
+    "exactly_empty_components": [ "username", "password", "port" ],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar",
+                 "baseURL": "https://example.com?query#hash" }],
+    "inputs": [{ "pathname": "/foo/bar",
+                 "baseURL": "https://example.com?query#hash" }],
+    "exactly_empty_components": [ "username", "password", "port" ],
+    "expected_match": {
+      "hash": { "input": "hash", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/foo/bar", "groups": {} },
+      "protocol": { "input": "https", "groups": {} },
+      "search": { "input": "query", "groups": {} }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar",
+                 "baseURL": "https://example.com?query#hash" }],
+    "inputs": [{ "pathname": "/foo/bar/baz",
+                 "baseURL": "https://example.com" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar",
+                 "baseURL": "https://example.com?query#hash" }],
+    "inputs": [{ "pathname": "/foo/bar", "baseURL": "https://other.com" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar",
+                 "baseURL": "https://example.com?query#hash" }],
+    "inputs": [{ "pathname": "/foo/bar", "baseURL": "http://example.com" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar" }],
+    "inputs": [{ "pathname": "/foo/bar" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar", "groups": { "bar": "bar" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/([^\\/]+?)" }],
+    "inputs": [{ "pathname": "/foo/bar" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar", "groups": { "0": "bar" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar" }],
+    "inputs": [{ "pathname": "/foo/index.html" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/index.html", "groups": { "bar": "index.html" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar" }],
+    "inputs": [{ "pathname": "/foo/bar/" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar" }],
+    "inputs": [{ "pathname": "/foo/" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)" }],
+    "inputs": [{ "pathname": "/foo/bar" }],
+    "expected_obj": {
+      "pathname": "/foo/*"
+    },
+    "expected_match": {
+      "pathname": { "input": "/foo/bar", "groups": { "0": "bar" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/*" }],
+    "inputs": [{ "pathname": "/foo/bar" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar", "groups": { "0": "bar" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)" }],
+    "inputs": [{ "pathname": "/foo/bar/baz" }],
+    "expected_obj": {
+      "pathname": "/foo/*"
+    },
+    "expected_match": {
+      "pathname": { "input": "/foo/bar/baz", "groups": { "0": "bar/baz" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/*" }],
+    "inputs": [{ "pathname": "/foo/bar/baz" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar/baz", "groups": { "0": "bar/baz" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)" }],
+    "inputs": [{ "pathname": "/foo/" }],
+    "expected_obj": {
+      "pathname": "/foo/*"
+    },
+    "expected_match": {
+      "pathname": { "input": "/foo/", "groups": { "0": "" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/*" }],
+    "inputs": [{ "pathname": "/foo/" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/", "groups": { "0": "" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)" }],
+    "inputs": [{ "pathname": "/foo" }],
+    "expected_obj": {
+      "pathname": "/foo/*"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/*" }],
+    "inputs": [{ "pathname": "/foo" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar(.*)" }],
+    "inputs": [{ "pathname": "/foo/bar" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar", "groups": { "bar": "bar" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar(.*)" }],
+    "inputs": [{ "pathname": "/foo/bar/baz" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar/baz", "groups": { "bar": "bar/baz" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar(.*)" }],
+    "inputs": [{ "pathname": "/foo/" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/", "groups": { "bar": "" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar(.*)" }],
+    "inputs": [{ "pathname": "/foo" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar?" }],
+    "inputs": [{ "pathname": "/foo/bar" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar", "groups": { "bar": "bar" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar?" }],
+    "inputs": [{ "pathname": "/foo" }],
+    "//": "The `null` below is translated to undefined in the test harness.",
+    "expected_match": {
+      "pathname": { "input": "/foo", "groups": { "bar": null } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar?" }],
+    "inputs": [{ "pathname": "/foo/" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar?" }],
+    "inputs": [{ "pathname": "/foobar" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar?" }],
+    "inputs": [{ "pathname": "/foo/bar/baz" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar+" }],
+    "inputs": [{ "pathname": "/foo/bar" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar", "groups": { "bar": "bar" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar+" }],
+    "inputs": [{ "pathname": "/foo/bar/baz" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar/baz", "groups": { "bar": "bar/baz" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar+" }],
+    "inputs": [{ "pathname": "/foo" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar+" }],
+    "inputs": [{ "pathname": "/foo/" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar+" }],
+    "inputs": [{ "pathname": "/foobar" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar*" }],
+    "inputs": [{ "pathname": "/foo/bar" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar", "groups": { "bar": "bar" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar*" }],
+    "inputs": [{ "pathname": "/foo/bar/baz" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar/baz", "groups": { "bar": "bar/baz" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar*" }],
+    "inputs": [{ "pathname": "/foo" }],
+    "//": "The `null` below is translated to undefined in the test harness.",
+    "expected_match": {
+      "pathname": { "input": "/foo", "groups": { "bar": null } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar*" }],
+    "inputs": [{ "pathname": "/foo/" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/:bar*" }],
+    "inputs": [{ "pathname": "/foobar" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)?" }],
+    "inputs": [{ "pathname": "/foo/bar" }],
+    "expected_obj": {
+      "pathname": "/foo/*?"
+    },
+    "expected_match": {
+      "pathname": { "input": "/foo/bar", "groups": { "0": "bar" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/*?" }],
+    "inputs": [{ "pathname": "/foo/bar" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar", "groups": { "0": "bar" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)?" }],
+    "inputs": [{ "pathname": "/foo/bar/baz" }],
+    "expected_obj": {
+      "pathname": "/foo/*?"
+    },
+    "expected_match": {
+      "pathname": { "input": "/foo/bar/baz", "groups": { "0": "bar/baz" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/*?" }],
+    "inputs": [{ "pathname": "/foo/bar/baz" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar/baz", "groups": { "0": "bar/baz" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)?" }],
+    "inputs": [{ "pathname": "/foo" }],
+    "expected_obj": {
+      "pathname": "/foo/*?"
+    },
+    "//": "The `null` below is translated to undefined in the test harness.",
+    "expected_match": {
+      "pathname": { "input": "/foo", "groups": { "0": null } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/*?" }],
+    "inputs": [{ "pathname": "/foo" }],
+    "//": "The `null` below is translated to undefined in the test harness.",
+    "expected_match": {
+      "pathname": { "input": "/foo", "groups": { "0": null } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)?" }],
+    "inputs": [{ "pathname": "/foo/" }],
+    "expected_obj": {
+      "pathname": "/foo/*?"
+    },
+    "expected_match": {
+      "pathname": { "input": "/foo/", "groups": { "0": "" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/*?" }],
+    "inputs": [{ "pathname": "/foo/" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/", "groups": { "0": "" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)?" }],
+    "inputs": [{ "pathname": "/foobar" }],
+    "expected_obj": {
+      "pathname": "/foo/*?"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/*?" }],
+    "inputs": [{ "pathname": "/foobar" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)?" }],
+    "inputs": [{ "pathname": "/fo" }],
+    "expected_obj": {
+      "pathname": "/foo/*?"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/*?" }],
+    "inputs": [{ "pathname": "/fo" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)+" }],
+    "inputs": [{ "pathname": "/foo/bar" }],
+    "expected_obj": {
+      "pathname": "/foo/*+"
+    },
+    "expected_match": {
+      "pathname": { "input": "/foo/bar", "groups": { "0": "bar" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/*+" }],
+    "inputs": [{ "pathname": "/foo/bar" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar", "groups": { "0": "bar" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)+" }],
+    "inputs": [{ "pathname": "/foo/bar/baz" }],
+    "expected_obj": {
+      "pathname": "/foo/*+"
+    },
+    "expected_match": {
+      "pathname": { "input": "/foo/bar/baz", "groups": { "0": "bar/baz" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/*+" }],
+    "inputs": [{ "pathname": "/foo/bar/baz" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar/baz", "groups": { "0": "bar/baz" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)+" }],
+    "inputs": [{ "pathname": "/foo" }],
+    "expected_obj": {
+      "pathname": "/foo/*+"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/*+" }],
+    "inputs": [{ "pathname": "/foo" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)+" }],
+    "inputs": [{ "pathname": "/foo/" }],
+    "expected_obj": {
+      "pathname": "/foo/*+"
+    },
+    "expected_match": {
+      "pathname": { "input": "/foo/", "groups": { "0": "" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/*+" }],
+    "inputs": [{ "pathname": "/foo/" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/", "groups": { "0": "" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)+" }],
+    "inputs": [{ "pathname": "/foobar" }],
+    "expected_obj": {
+      "pathname": "/foo/*+"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/*+" }],
+    "inputs": [{ "pathname": "/foobar" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)+" }],
+    "inputs": [{ "pathname": "/fo" }],
+    "expected_obj": {
+      "pathname": "/foo/*+"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/*+" }],
+    "inputs": [{ "pathname": "/fo" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)*" }],
+    "inputs": [{ "pathname": "/foo/bar" }],
+    "expected_obj": {
+      "pathname": "/foo/**"
+    },
+    "expected_match": {
+      "pathname": { "input": "/foo/bar", "groups": { "0": "bar" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/**" }],
+    "inputs": [{ "pathname": "/foo/bar" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar", "groups": { "0": "bar" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)*" }],
+    "inputs": [{ "pathname": "/foo/bar/baz" }],
+    "expected_obj": {
+      "pathname": "/foo/**"
+    },
+    "expected_match": {
+      "pathname": { "input": "/foo/bar/baz", "groups": { "0": "bar/baz" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/**" }],
+    "inputs": [{ "pathname": "/foo/bar/baz" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar/baz", "groups": { "0": "bar/baz" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)*" }],
+    "inputs": [{ "pathname": "/foo" }],
+    "expected_obj": {
+      "pathname": "/foo/**"
+    },
+    "//": "The `null` below is translated to undefined in the test harness.",
+    "expected_match": {
+      "pathname": { "input": "/foo", "groups": { "0": null } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/**" }],
+    "inputs": [{ "pathname": "/foo" }],
+    "//": "The `null` below is translated to undefined in the test harness.",
+    "expected_match": {
+      "pathname": { "input": "/foo", "groups": { "0": null } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)*" }],
+    "inputs": [{ "pathname": "/foo/" }],
+    "expected_obj": {
+      "pathname": "/foo/**"
+    },
+    "expected_match": {
+      "pathname": { "input": "/foo/", "groups": { "0": "" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/**" }],
+    "inputs": [{ "pathname": "/foo/" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/", "groups": { "0": "" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)*" }],
+    "inputs": [{ "pathname": "/foobar" }],
+    "expected_obj": {
+      "pathname": "/foo/**"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/**" }],
+    "inputs": [{ "pathname": "/foobar" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/(.*)*" }],
+    "inputs": [{ "pathname": "/fo" }],
+    "expected_obj": {
+      "pathname": "/foo/**"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/**" }],
+    "inputs": [{ "pathname": "/fo" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo{/bar}" }],
+    "inputs": [{ "pathname": "/foo/bar" }],
+    "expected_obj": {
+      "pathname": "/foo/bar"
+    },
+    "expected_match": {
+      "pathname": { "input": "/foo/bar", "groups": {} }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo{/bar}" }],
+    "inputs": [{ "pathname": "/foo/bar/baz" }],
+    "expected_obj": {
+      "pathname": "/foo/bar"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo{/bar}" }],
+    "inputs": [{ "pathname": "/foo" }],
+    "expected_obj": {
+      "pathname": "/foo/bar"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo{/bar}" }],
+    "inputs": [{ "pathname": "/foo/" }],
+    "expected_obj": {
+      "pathname": "/foo/bar"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo{/bar}?" }],
+    "inputs": [{ "pathname": "/foo/bar" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar", "groups": {} }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo{/bar}?" }],
+    "inputs": [{ "pathname": "/foo/bar/baz" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo{/bar}?" }],
+    "inputs": [{ "pathname": "/foo" }],
+    "expected_match": {
+      "pathname": { "input": "/foo", "groups": {} }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo{/bar}?" }],
+    "inputs": [{ "pathname": "/foo/" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo{/bar}+" }],
+    "inputs": [{ "pathname": "/foo/bar" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar", "groups": {} }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo{/bar}+" }],
+    "inputs": [{ "pathname": "/foo/bar/bar" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar/bar", "groups": {} }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo{/bar}+" }],
+    "inputs": [{ "pathname": "/foo/bar/baz" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo{/bar}+" }],
+    "inputs": [{ "pathname": "/foo" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo{/bar}+" }],
+    "inputs": [{ "pathname": "/foo/" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo{/bar}*" }],
+    "inputs": [{ "pathname": "/foo/bar" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar", "groups": {} }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo{/bar}*" }],
+    "inputs": [{ "pathname": "/foo/bar/bar" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar/bar", "groups": {} }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo{/bar}*" }],
+    "inputs": [{ "pathname": "/foo/bar/baz" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo{/bar}*" }],
+    "inputs": [{ "pathname": "/foo" }],
+    "expected_match": {
+      "pathname": { "input": "/foo", "groups": {} }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo{/bar}*" }],
+    "inputs": [{ "pathname": "/foo/" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "protocol": "(café)" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "username": "(café)" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "password": "(café)" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hostname": "(café)" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "pathname": "(café)" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "search": "(café)" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hash": "(café)" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "protocol": ":café" }],
+    "inputs": [{ "protocol": "foo" }],
+    "expected_match": {
+      "protocol": { "input": "foo", "groups": { "café": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "username": ":café" }],
+    "inputs": [{ "username": "foo" }],
+    "expected_match": {
+      "username": { "input": "foo", "groups": { "café": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "password": ":café" }],
+    "inputs": [{ "password": "foo" }],
+    "expected_match": {
+      "password": { "input": "foo", "groups": { "café": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "hostname": ":café" }],
+    "inputs": [{ "hostname": "foo" }],
+    "expected_match": {
+      "hostname": { "input": "foo", "groups": { "café": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/:café" }],
+    "inputs": [{ "pathname": "/foo" }],
+    "expected_match": {
+      "pathname": { "input": "/foo", "groups": { "café": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "search": ":café" }],
+    "inputs": [{ "search": "foo" }],
+    "expected_match": {
+      "search": { "input": "foo", "groups": { "café": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "hash": ":café" }],
+    "inputs": [{ "hash": "foo" }],
+    "expected_match": {
+      "hash": { "input": "foo", "groups": { "café": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "protocol": ":\u2118" }],
+    "inputs": [{ "protocol": "foo" }],
+    "expected_match": {
+      "protocol": { "input": "foo", "groups": { "\u2118": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "username": ":\u2118" }],
+    "inputs": [{ "username": "foo" }],
+    "expected_match": {
+      "username": { "input": "foo", "groups": { "\u2118": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "password": ":\u2118" }],
+    "inputs": [{ "password": "foo" }],
+    "expected_match": {
+      "password": { "input": "foo", "groups": { "\u2118": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "hostname": ":\u2118" }],
+    "inputs": [{ "hostname": "foo" }],
+    "expected_match": {
+      "hostname": { "input": "foo", "groups": { "\u2118": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/:\u2118" }],
+    "inputs": [{ "pathname": "/foo" }],
+    "expected_match": {
+      "pathname": { "input": "/foo", "groups": { "\u2118": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "search": ":\u2118" }],
+    "inputs": [{ "search": "foo" }],
+    "expected_match": {
+      "search": { "input": "foo", "groups": { "\u2118": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "hash": ":\u2118" }],
+    "inputs": [{ "hash": "foo" }],
+    "expected_match": {
+      "hash": { "input": "foo", "groups": { "\u2118": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "protocol": ":\u3400" }],
+    "inputs": [{ "protocol": "foo" }],
+    "expected_match": {
+      "protocol": { "input": "foo", "groups": { "\u3400": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "username": ":\u3400" }],
+    "inputs": [{ "username": "foo" }],
+    "expected_match": {
+      "username": { "input": "foo", "groups": { "\u3400": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "password": ":\u3400" }],
+    "inputs": [{ "password": "foo" }],
+    "expected_match": {
+      "password": { "input": "foo", "groups": { "\u3400": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "hostname": ":\u3400" }],
+    "inputs": [{ "hostname": "foo" }],
+    "expected_match": {
+      "hostname": { "input": "foo", "groups": { "\u3400": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/:\u3400" }],
+    "inputs": [{ "pathname": "/foo" }],
+    "expected_match": {
+      "pathname": { "input": "/foo", "groups": { "\u3400": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "search": ":\u3400" }],
+    "inputs": [{ "search": "foo" }],
+    "expected_match": {
+      "search": { "input": "foo", "groups": { "\u3400": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "hash": ":\u3400" }],
+    "inputs": [{ "hash": "foo" }],
+    "expected_match": {
+      "hash": { "input": "foo", "groups": { "\u3400": "foo" } }
+    }
+  },
+  {
+    "pattern": [{ "protocol": "(.*)" }],
+    "inputs": [{ "protocol" : "café" }],
+    "expected_obj": {
+      "protocol": "*"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "protocol": "(.*)" }],
+    "inputs": [{ "protocol": "cafe" }],
+    "expected_obj": {
+      "protocol": "*"
+    },
+    "expected_match": {
+      "protocol": { "input": "cafe", "groups": { "0": "cafe" }}
+    }
+  },
+  {
+    "pattern": [{ "protocol": "foo-bar" }],
+    "inputs": [{ "protocol": "foo-bar" }],
+    "expected_match": {
+      "protocol": { "input": "foo-bar", "groups": {} }
+    }
+  },
+  {
+    "pattern": [{ "username": "caf%C3%A9" }],
+    "inputs": [{ "username" : "café" }],
+    "expected_match": {
+      "username": { "input": "caf%C3%A9", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "username": "café" }],
+    "inputs": [{ "username" : "café" }],
+    "expected_obj": {
+      "username": "caf%C3%A9"
+    },
+    "expected_match": {
+      "username": { "input": "caf%C3%A9", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "username": "caf%c3%a9" }],
+    "inputs": [{ "username" : "café" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "password": "caf%C3%A9" }],
+    "inputs": [{ "password" : "café" }],
+    "expected_match": {
+      "password": { "input": "caf%C3%A9", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "password": "café" }],
+    "inputs": [{ "password" : "café" }],
+    "expected_obj": {
+      "password": "caf%C3%A9"
+    },
+    "expected_match": {
+      "password": { "input": "caf%C3%A9", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "password": "caf%c3%a9" }],
+    "inputs": [{ "password" : "café" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "hostname": "xn--caf-dma.com" }],
+    "inputs": [{ "hostname" : "café.com" }],
+    "expected_match": {
+      "hostname": { "input": "xn--caf-dma.com", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "hostname": "café.com" }],
+    "inputs": [{ "hostname" : "café.com" }],
+    "expected_obj": {
+      "hostname": "xn--caf-dma.com"
+    },
+    "expected_match": {
+      "hostname": { "input": "xn--caf-dma.com", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "port": "" }],
+    "inputs": [{ "protocol": "http", "port": "80" }],
+    "exactly_empty_components": [ "port" ],
+    "expected_match": {
+      "protocol": { "input": "http", "groups": { "0": "http" }}
+    }
+  },
+  {
+    "pattern": [{ "protocol": "http", "port": "80" }],
+    "inputs": [{ "protocol": "http", "port": "80" }],
+    "exactly_empty_components": [ "port" ],
+    "expected_match": {
+      "protocol": { "input": "http", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "protocol": "http", "port": "80{20}?" }],
+    "inputs": [{ "protocol": "http", "port": "80" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "protocol": "http", "port": "80 " }],
+    "inputs": [{ "protocol": "http", "port": "80" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "port": "80" }],
+    "inputs": [{ "protocol": "http", "port": "80" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "protocol": "http{s}?", "port": "80" }],
+    "inputs": [{ "protocol": "http", "port": "80" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "port": "80" }],
+    "inputs": [{ "port": "80" }],
+    "expected_match": {
+      "port": { "input": "80", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "port": "(.*)" }],
+    "inputs": [{ "port": "invalid80" }],
+    "expected_obj": {
+      "port": "*"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar" }],
+    "inputs": [{ "pathname": "/foo/./bar" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/bar", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/baz" }],
+    "inputs": [{ "pathname": "/foo/bar/../baz" }],
+    "expected_match": {
+      "pathname": { "input": "/foo/baz", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/caf%C3%A9" }],
+    "inputs": [{ "pathname": "/café" }],
+    "expected_match": {
+      "pathname": { "input": "/caf%C3%A9", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/café" }],
+    "inputs": [{ "pathname": "/café" }],
+    "expected_obj": {
+      "pathname": "/caf%C3%A9"
+    },
+    "expected_match": {
+      "pathname": { "input": "/caf%C3%A9", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/caf%c3%a9" }],
+    "inputs": [{ "pathname": "/café" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar" }],
+    "inputs": [{ "pathname": "foo/bar" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar" }],
+    "inputs": [{ "pathname": "foo/bar", "baseURL": "https://example.com" }],
+    "expected_match": {
+      "protocol": { "input": "https", "groups": { "0": "https" }},
+      "hostname": { "input": "example.com", "groups": { "0": "example.com" }},
+      "pathname": { "input": "/foo/bar", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/../bar" }],
+    "inputs": [{ "pathname": "/bar" }],
+    "expected_obj": {
+      "pathname": "/bar"
+    },
+    "expected_match": {
+      "pathname": { "input": "/bar", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "./foo/bar", "baseURL": "https://example.com" }],
+    "inputs": [{ "pathname": "foo/bar", "baseURL": "https://example.com" }],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "pathname": "/foo/bar"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {}},
+      "hostname": { "input": "example.com", "groups": {}},
+      "pathname": { "input": "/foo/bar", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "", "baseURL": "https://example.com" }],
+    "inputs": [{ "pathname": "/", "baseURL": "https://example.com" }],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "pathname": "/"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {}},
+      "hostname": { "input": "example.com", "groups": {}},
+      "pathname": { "input": "/", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "{/bar}", "baseURL": "https://example.com/foo/" }],
+    "inputs": [{ "pathname": "./bar", "baseURL": "https://example.com/foo/" }],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "pathname": "/bar"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "\\/bar", "baseURL": "https://example.com/foo/" }],
+    "inputs": [{ "pathname": "./bar", "baseURL": "https://example.com/foo/" }],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "pathname": "/bar"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "b", "baseURL": "https://example.com/foo/" }],
+    "inputs": [{ "pathname": "./b", "baseURL": "https://example.com/foo/" }],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "pathname": "/foo/b"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {}},
+      "hostname": { "input": "example.com", "groups": {}},
+      "pathname": { "input": "/foo/b", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "foo/bar" }],
+    "inputs": [ "https://example.com/foo/bar" ],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "foo/bar", "baseURL": "https://example.com" }],
+    "inputs": [ "https://example.com/foo/bar" ],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "pathname": "/foo/bar"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {}},
+      "hostname": { "input": "example.com", "groups": {}},
+      "pathname": { "input": "/foo/bar", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "pathname": ":name.html", "baseURL": "https://example.com" }],
+    "inputs": [ "https://example.com/foo.html"] ,
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "pathname": "/:name.html"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {}},
+      "hostname": { "input": "example.com", "groups": {}},
+      "pathname": { "input": "/foo.html", "groups": { "name": "foo" }}
+    }
+  },
+  {
+    "pattern": [{ "search": "q=caf%C3%A9" }],
+    "inputs": [{ "search": "q=café" }],
+    "expected_match": {
+      "search": { "input": "q=caf%C3%A9", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "search": "q=café" }],
+    "inputs": [{ "search": "q=café" }],
+    "expected_obj": {
+      "search": "q=caf%C3%A9"
+    },
+    "expected_match": {
+      "search": { "input": "q=caf%C3%A9", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "search": "q=caf%c3%a9" }],
+    "inputs": [{ "search": "q=café" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "hash": "caf%C3%A9" }],
+    "inputs": [{ "hash": "café" }],
+    "expected_match": {
+      "hash": { "input": "caf%C3%A9", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "hash": "café" }],
+    "inputs": [{ "hash": "café" }],
+    "expected_obj": {
+      "hash": "caf%C3%A9"
+    },
+    "expected_match": {
+      "hash": { "input": "caf%C3%A9", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "hash": "caf%c3%a9" }],
+    "inputs": [{ "hash": "café" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "protocol": "about", "pathname": "(blank|sourcedoc)" }],
+    "inputs": [ "about:blank" ],
+    "expected_match": {
+      "protocol": { "input": "about", "groups": {}},
+      "pathname": { "input": "blank", "groups": { "0": "blank" }}
+    }
+  },
+  {
+    "pattern": [{ "protocol": "data", "pathname": ":number([0-9]+)" }],
+    "inputs": [ "data:8675309" ],
+    "expected_match": {
+      "protocol": { "input": "data", "groups": {}},
+      "pathname": { "input": "8675309", "groups": { "number": "8675309" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/(\\m)" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "pathname": "/foo!" }],
+    "inputs": [{ "pathname": "/foo!" }],
+    "expected_match": {
+      "pathname": { "input": "/foo!", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo\\:" }],
+    "inputs": [{ "pathname": "/foo:" }],
+    "expected_match": {
+      "pathname": { "input": "/foo:", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo\\{" }],
+    "inputs": [{ "pathname": "/foo{" }],
+    "expected_obj": {
+      "pathname": "/foo%7B"
+    },
+    "expected_match": {
+      "pathname": { "input": "/foo%7B", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo\\(" }],
+    "inputs": [{ "pathname": "/foo(" }],
+    "expected_match": {
+      "pathname": { "input": "/foo(", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "protocol": "javascript", "pathname": "var x = 1;" }],
+    "inputs": [{ "protocol": "javascript", "pathname": "var x = 1;" }],
+    "expected_match": {
+      "protocol": { "input": "javascript", "groups": {}},
+      "pathname": { "input": "var x = 1;", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "var x = 1;" }],
+    "inputs": [{ "protocol": "javascript", "pathname": "var x = 1;" }],
+    "expected_obj": {
+      "pathname": "var%20x%20=%201;"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "protocol": "javascript", "pathname": "var x = 1;" }],
+    "inputs": [{ "baseURL": "javascript:var x = 1;" }],
+    "expected_match": {
+      "protocol": { "input": "javascript", "groups": {}},
+      "pathname": { "input": "var x = 1;", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "protocol": "(data|javascript)", "pathname": "var x = 1;" }],
+    "inputs": [{ "protocol": "javascript", "pathname": "var x = 1;" }],
+    "expected_match": {
+      "protocol": { "input": "javascript", "groups": {"0": "javascript"}},
+      "pathname": { "input": "var x = 1;", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "protocol": "(https|javascript)", "pathname": "var x = 1;" }],
+    "inputs": [{ "protocol": "javascript", "pathname": "var x = 1;" }],
+    "expected_obj": {
+      "pathname": "var%20x%20=%201;"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "var x = 1;" }],
+    "inputs": [{ "pathname": "var x = 1;" }],
+    "expected_obj": {
+      "pathname": "var%20x%20=%201;"
+    },
+    "expected_match": {
+      "pathname": { "input": "var%20x%20=%201;", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar" }],
+    "inputs": [ "./foo/bar", "https://example.com" ],
+    "expected_match": {
+      "hostname": { "input": "example.com", "groups": { "0": "example.com" } },
+      "pathname": { "input": "/foo/bar", "groups": {} },
+      "protocol": { "input": "https", "groups": { "0": "https" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/foo/bar" }],
+    "inputs": [ { "pathname": "/foo/bar" }, "https://example.com" ],
+    "expected_match": "error"
+  },
+  {
+    "pattern": [ "https://example.com:8080/foo?bar#baz" ],
+    "inputs": [{ "pathname": "/foo", "search": "bar", "hash": "baz",
+                 "baseURL": "https://example.com:8080" }],
+    "exactly_empty_components": [ "username", "password" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "port": "8080",
+      "pathname": "/foo",
+      "search": "bar",
+      "hash": "baz"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "port": { "input": "8080", "groups": {} },
+      "pathname": { "input": "/foo", "groups": {} },
+      "search": { "input": "bar", "groups": {} },
+      "hash": { "input": "baz", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "/foo?bar#baz", "https://example.com:8080" ],
+    "inputs": [{ "pathname": "/foo", "search": "bar", "hash": "baz",
+                 "baseURL": "https://example.com:8080" }],
+    "exactly_empty_components": [ "username", "password" ],
+    "expected_obj": {
+      "pathname": "/foo",
+      "search": "bar",
+      "hash": "baz"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "port": { "input": "8080", "groups": {} },
+      "pathname": { "input": "/foo", "groups": {} },
+      "search": { "input": "bar", "groups": {} },
+      "hash": { "input": "baz", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "/foo" ],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [ "example.com/foo" ],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [ "http{s}?://{*.}?example.com/:product/:endpoint" ],
+    "inputs": [ "https://sub.example.com/foo/bar" ],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "protocol": "http{s}?",
+      "hostname": "{*.}?example.com",
+      "pathname": "/:product/:endpoint"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "sub.example.com", "groups": { "0": "sub" } },
+      "pathname": { "input": "/foo/bar", "groups": { "product": "foo",
+                                                     "endpoint": "bar" } }
+    }
+  },
+  {
+    "pattern": [ "https://example.com?foo" ],
+    "inputs": [ "https://example.com/?foo" ],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "pathname": "/",
+      "search": "foo"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/", "groups": {} },
+      "search": { "input": "foo", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "https://example.com#foo" ],
+    "inputs": [ "https://example.com/#foo" ],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "pathname": "/",
+      "hash": "foo"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/", "groups": {} },
+      "hash": { "input": "foo", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "https://example.com:8080?foo" ],
+    "inputs": [ "https://example.com:8080/?foo" ],
+    "exactly_empty_components": [ "username", "password", "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "port": "8080",
+      "pathname": "/",
+      "search": "foo"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "port": { "input": "8080", "groups": {} },
+      "pathname": { "input": "/", "groups": {} },
+      "search": { "input": "foo", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "https://example.com:8080#foo" ],
+    "inputs": [ "https://example.com:8080/#foo" ],
+    "exactly_empty_components": [ "username", "password", "search" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "port": "8080",
+      "pathname": "/",
+      "hash": "foo"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "port": { "input": "8080", "groups": {} },
+      "pathname": { "input": "/", "groups": {} },
+      "hash": { "input": "foo", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "https://example.com/?foo" ],
+    "inputs": [ "https://example.com/?foo" ],
+    "exactly_empty_components": [ "username", "password", "port", "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "pathname": "/",
+      "search": "foo"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/", "groups": {} },
+      "search": { "input": "foo", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "https://example.com/#foo" ],
+    "inputs": [ "https://example.com/#foo" ],
+    "exactly_empty_components": [ "username", "password", "port", "search" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "pathname": "/",
+      "hash": "foo"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/", "groups": {} },
+      "hash": { "input": "foo", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "https://example.com/*?foo" ],
+    "inputs": [ "https://example.com/?foo" ],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "pathname": "/*?foo"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [ "https://example.com/*\\?foo" ],
+    "inputs": [ "https://example.com/?foo" ],
+    "exactly_empty_components": [ "username", "password", "port", "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "pathname": "/*",
+      "search": "foo"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/", "groups": { "0": "" } },
+      "search": { "input": "foo", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "https://example.com/:name?foo" ],
+    "inputs": [ "https://example.com/bar?foo" ],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "pathname": "/:name?foo"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [ "https://example.com/:name\\?foo" ],
+    "inputs": [ "https://example.com/bar?foo" ],
+    "exactly_empty_components": [ "username", "password", "port", "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "pathname": "/:name",
+      "search": "foo"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/bar", "groups": { "name": "bar" } },
+      "search": { "input": "foo", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "https://example.com/(bar)?foo" ],
+    "inputs": [ "https://example.com/bar?foo" ],
+    "exactly_empty_components": [ "username", "password", "port", "search", "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "pathname": "/(bar)?foo"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [ "https://example.com/(bar)\\?foo" ],
+    "inputs": [ "https://example.com/bar?foo" ],
+    "exactly_empty_components": [ "username", "password", "port", "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "pathname": "/(bar)",
+      "search": "foo"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/bar", "groups": { "0": "bar" } },
+      "search": { "input": "foo", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "https://example.com/{bar}?foo" ],
+    "inputs": [ "https://example.com/bar?foo" ],
+    "exactly_empty_components": [ "username", "password", "port", "search", "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "pathname": "/{bar}?foo"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [ "https://example.com/{bar}\\?foo" ],
+    "inputs": [ "https://example.com/bar?foo" ],
+    "exactly_empty_components": [ "username", "password", "port", "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "pathname": "/bar",
+      "search": "foo"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/bar", "groups": {} },
+      "search": { "input": "foo", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "https://example.com/" ],
+    "inputs": [ "https://example.com:8080/" ],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "port": "",
+      "pathname": "/"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [ "data:foobar" ],
+    "inputs": [ "data:foobar" ],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [ "data\\:foobar" ],
+    "inputs": [ "data:foobar" ],
+    "exactly_empty_components": [ "username", "password", "hostname", "port",
+                                  "search", "hash" ],
+    "expected_obj": {
+      "protocol": "data",
+      "pathname": "foobar"
+    },
+    "expected_match": {
+      "protocol": { "input": "data", "groups": {} },
+      "pathname": { "input": "foobar", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "https://{sub.}?example.com/foo" ],
+    "inputs": [ "https://example.com/foo" ],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "{sub.}?example.com",
+      "pathname": "/foo"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/foo", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "https://{sub.}?example{.com/}foo" ],
+    "inputs": [ "https://example.com/foo" ],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [ "{https://}example.com/foo" ],
+    "inputs": [ "https://example.com/foo" ],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [ "https://(sub.)?example.com/foo" ],
+    "inputs": [ "https://example.com/foo" ],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "(sub.)?example.com",
+      "pathname": "/foo"
+    },
+    "//": "The `null` below is translated to undefined in the test harness.",
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": { "0": null } },
+      "pathname": { "input": "/foo", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "https://(sub.)?example(.com/)foo" ],
+    "inputs": [ "https://example.com/foo" ],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "(sub.)?example(.com/)foo",
+      "pathname": "/"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [ "(https://)example.com/foo" ],
+    "inputs": [ "https://example.com/foo" ],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [ "https://{sub{.}}example.com/foo" ],
+    "inputs": [ "https://example.com/foo" ],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [ "https://(sub(?:.))?example.com/foo" ],
+    "inputs": [ "https://example.com/foo" ],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "(sub(?:.))?example.com",
+      "pathname": "/foo"
+    },
+    "//": "The `null` below is translated to undefined in the test harness.",
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": { "0": null } },
+      "pathname": { "input": "/foo", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "file:///foo/bar" ],
+    "inputs": [ "file:///foo/bar" ],
+    "exactly_empty_components": [ "username", "password", "hostname", "port",
+                                  "search", "hash" ],
+    "expected_obj": {
+      "protocol": "file",
+      "pathname": "/foo/bar"
+    },
+    "expected_match": {
+      "protocol": { "input": "file", "groups": {} },
+      "pathname": { "input": "/foo/bar", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "data:" ],
+    "inputs": [ "data:" ],
+    "exactly_empty_components": [ "username", "password", "hostname", "port",
+                                  "pathname", "search", "hash" ],
+    "expected_obj": {
+      "protocol": "data"
+    },
+    "expected_match": {
+      "protocol": { "input": "data", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "foo://bar" ],
+    "inputs": [ "foo://bad_url_browser_interop" ],
+    "exactly_empty_components": [ "username", "password", "port", "pathname",
+                                  "search", "hash" ],
+    "expected_obj": {
+      "protocol": "foo",
+      "hostname": "bar"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [ "(café)://foo" ],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [ "https://example.com/foo?bar#baz" ],
+    "inputs": [{ "protocol": "https:",
+                 "search": "?bar",
+                 "hash": "#baz",
+                 "baseURL": "http://example.com/foo" }],
+    "exactly_empty_components": [ "username", "password", "port" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "pathname": "/foo",
+      "search": "bar",
+      "hash": "baz"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/foo", "groups": {} },
+      "search": { "input": "bar", "groups": {} },
+      "hash": { "input": "baz", "groups": {} }
+    }
+  },
+  {
+    "pattern": [{ "protocol": "http{s}?:",
+                  "search": "?bar",
+                  "hash": "#baz" }],
+    "inputs": [ "http://example.com/foo?bar#baz" ],
+    "expected_obj": {
+      "protocol": "http{s}?",
+      "search": "bar",
+      "hash": "baz"
+    },
+    "expected_match": {
+      "protocol": { "input": "http", "groups": {} },
+      "hostname": { "input": "example.com", "groups": { "0": "example.com" }},
+      "pathname": { "input": "/foo", "groups": { "0": "/foo" }},
+      "search": { "input": "bar", "groups": {} },
+      "hash": { "input": "baz", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "?bar#baz", "https://example.com/foo" ],
+    "inputs": [ "?bar#baz", "https://example.com/foo" ],
+    "exactly_empty_components": [ "username", "password", "port" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "pathname": "/foo",
+      "search": "bar",
+      "hash": "baz"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/foo", "groups": {} },
+      "search": { "input": "bar", "groups": {} },
+      "hash": { "input": "baz", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "?bar", "https://example.com/foo#baz" ],
+    "inputs": [ "?bar", "https://example.com/foo#snafu" ],
+    "exactly_empty_components": [ "username", "password", "port", "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "pathname": "/foo",
+      "search": "bar"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/foo", "groups": {} },
+      "search": { "input": "bar", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "#baz", "https://example.com/foo?bar" ],
+    "inputs": [ "#baz", "https://example.com/foo?bar" ],
+    "exactly_empty_components": [ "username", "password", "port" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "pathname": "/foo",
+      "search": "bar",
+      "hash": "baz"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/foo", "groups": {} },
+      "search": { "input": "bar", "groups": {} },
+      "hash": { "input": "baz", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "#baz", "https://example.com/foo" ],
+    "inputs": [ "#baz", "https://example.com/foo" ],
+    "exactly_empty_components": [ "username", "password", "port", "search" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "pathname": "/foo",
+      "hash": "baz"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/foo", "groups": {} },
+      "hash": { "input": "baz", "groups": {} }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "*" }],
+    "inputs": [ "foo", "data:data-urls-cannot-be-base-urls" ],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "*" }],
+    "inputs": [ "foo", "not|a|valid|url" ],
+    "expected_match": null
+  },
+  {
+    "pattern": [ "https://foo\\:bar@example.com" ],
+    "inputs": [ "https://foo:bar@example.com" ],
+    "exactly_empty_components": [ "port", "search", "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "username": "foo",
+      "password": "bar",
+      "hostname": "example.com",
+      "pathname": "/"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "username": { "input": "foo", "groups": {} },
+      "password": { "input": "bar", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "https://foo@example.com" ],
+    "inputs": [ "https://foo@example.com" ],
+    "exactly_empty_components": [ "password", "port", "search", "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "username": "foo",
+      "hostname": "example.com",
+      "pathname": "/"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "username": { "input": "foo", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "https://\\:bar@example.com" ],
+    "inputs": [ "https://:bar@example.com" ],
+    "exactly_empty_components": [ "username", "port", "search", "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "password": "bar",
+      "hostname": "example.com",
+      "pathname": "/"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "password": { "input": "bar", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "https://:user::pass@example.com" ],
+    "inputs": [ "https://foo:bar@example.com" ],
+    "exactly_empty_components": [ "port", "search", "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "username": ":user",
+      "password": ":pass",
+      "hostname": "example.com",
+      "pathname": "/"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "username": { "input": "foo", "groups": { "user": "foo" } },
+      "password": { "input": "bar", "groups": { "pass": "bar" } },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "https\\:foo\\:bar@example.com" ],
+    "inputs": [ "https:foo:bar@example.com" ],
+    "exactly_empty_components": [ "port", "search", "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "username": "foo",
+      "password": "bar",
+      "hostname": "example.com",
+      "pathname": "/"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "username": { "input": "foo", "groups": {} },
+      "password": { "input": "bar", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "data\\:foo\\:bar@example.com" ],
+    "inputs": [ "data:foo:bar@example.com" ],
+    "exactly_empty_components": [ "username", "password", "hostname", "port",
+                                  "search", "hash" ],
+    "expected_obj": {
+      "protocol": "data",
+      "pathname": "foo\\:bar@example.com"
+    },
+    "expected_match": {
+      "protocol": { "input": "data", "groups": {} },
+      "pathname": { "input": "foo:bar@example.com", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "https://foo{\\:}bar@example.com" ],
+    "inputs": [ "https://foo:bar@example.com" ],
+    "exactly_empty_components": [ "password", "port", "search", "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "username": "foo%3Abar",
+      "hostname": "example.com",
+      "pathname": "/"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [ "data{\\:}channel.html", "https://example.com" ],
+    "inputs": [ "https://example.com/data:channel.html" ],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "protocol": "https",
+      "hostname": "example.com",
+      "pathname": "/data\\:channel.html"
+    },
+    "expected_match": {
+      "protocol": { "input": "https", "groups": {} },
+      "hostname": { "input": "example.com", "groups": {} },
+      "pathname": { "input": "/data:channel.html", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "http://[\\:\\:1]/" ],
+    "inputs": [ "http://[::1]/" ],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "protocol": "http",
+      "hostname": "[\\:\\:1]",
+      "pathname": "/"
+    },
+    "expected_match": {
+      "protocol": { "input": "http", "groups": {} },
+      "hostname": { "input": "[::1]", "groups": {} },
+      "pathname": { "input": "/", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "http://[\\:\\:1]:8080/" ],
+    "inputs": [ "http://[::1]:8080/" ],
+    "exactly_empty_components": [ "username", "password", "search", "hash" ],
+    "expected_obj": {
+      "protocol": "http",
+      "hostname": "[\\:\\:1]",
+      "port": "8080",
+      "pathname": "/"
+    },
+    "expected_match": {
+      "protocol": { "input": "http", "groups": {} },
+      "hostname": { "input": "[::1]", "groups": {} },
+      "port": { "input": "8080", "groups": {} },
+      "pathname": { "input": "/", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "http://[\\:\\:a]/" ],
+    "inputs": [ "http://[::a]/" ],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "protocol": "http",
+      "hostname": "[\\:\\:a]",
+      "pathname": "/"
+    },
+    "expected_match": {
+      "protocol": { "input": "http", "groups": {} },
+      "hostname": { "input": "[::a]", "groups": {} },
+      "pathname": { "input": "/", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "http://[:address]/" ],
+    "inputs": [ "http://[::1]/" ],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "protocol": "http",
+      "hostname": "[:address]",
+      "pathname": "/"
+    },
+    "expected_match": {
+      "protocol": { "input": "http", "groups": {} },
+      "hostname": { "input": "[::1]", "groups": { "address": "::1" }},
+      "pathname": { "input": "/", "groups": {} }
+    }
+  },
+  {
+    "pattern": [ "http://[\\:\\:AB\\::num]/" ],
+    "inputs": [ "http://[::ab:1]/" ],
+    "exactly_empty_components": [ "username", "password", "port", "search",
+                                  "hash" ],
+    "expected_obj": {
+      "protocol": "http",
+      "hostname": "[\\:\\:ab\\::num]",
+      "pathname": "/"
+    },
+    "expected_match": {
+      "protocol": { "input": "http", "groups": {} },
+      "hostname": { "input": "[::ab:1]", "groups": { "num": "1" }},
+      "pathname": { "input": "/", "groups": {} }
+    }
+  },
+  {
+    "pattern": [{ "hostname": "[\\:\\:AB\\::num]" }],
+    "inputs": [{ "hostname": "[::ab:1]" }],
+    "expected_obj": {
+      "hostname": "[\\:\\:ab\\::num]"
+    },
+    "expected_match": {
+      "hostname": { "input": "[::ab:1]", "groups": { "num": "1" }}
+    }
+  },
+  {
+    "pattern": [{ "hostname": "[\\:\\:xY\\::num]" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hostname": "{[\\:\\:ab\\::num]}" }],
+    "inputs": [{ "hostname": "[::ab:1]" }],
+    "expected_match": {
+      "hostname": { "input": "[::ab:1]", "groups": { "num": "1" }}
+    }
+  },
+  {
+    "pattern": [{ "hostname": "{[\\:\\:fé\\::num]}" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hostname": "{[\\:\\::num\\:1]}" }],
+    "inputs": [{ "hostname": "[::ab:1]" }],
+    "expected_match": {
+      "hostname": { "input": "[::ab:1]", "groups": { "num": "ab" }}
+    }
+  },
+  {
+    "pattern": [{ "hostname": "{[\\:\\::num\\:fé]}" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hostname": "[*\\:1]" }],
+    "inputs": [{ "hostname": "[::ab:1]" }],
+    "expected_match": {
+      "hostname": { "input": "[::ab:1]", "groups": { "0": "::ab" }}
+    }
+  },
+  {
+    "pattern": [{ "hostname": "*\\:1]" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [ "https://foo{{@}}example.com" ],
+    "inputs": [ "https://foo@example.com" ],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [ "https://foo{@example.com" ],
+    "inputs": [ "https://foo@example.com" ],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [ "data\\:text/javascript,let x = 100/:tens?5;" ],
+    "inputs": [ "data:text/javascript,let x = 100/5;" ],
+    "exactly_empty_components": [ "username", "password", "hostname", "port",
+                                  "search", "hash" ],
+    "expected_obj": {
+      "protocol": "data",
+      "pathname": "text/javascript,let x = 100/:tens?5;"
+    },
+    "//": "The `null` below is translated to undefined in the test harness.",
+    "expected_match": {
+      "protocol": { "input": "data", "groups": {} },
+      "pathname": { "input": "text/javascript,let x = 100/5;", "groups": { "tens": null } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/:id/:id" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "pathname": "/foo", "baseURL": "" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [ "/foo", "" ],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "pathname": "/foo" }, "https://example.com" ],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "pathname": ":name*" }],
+    "inputs": [{ "pathname": "foobar" }],
+    "expected_match": {
+      "pathname": { "input": "foobar", "groups": { "name": "foobar" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": ":name+" }],
+    "inputs": [{ "pathname": "foobar" }],
+    "expected_match": {
+      "pathname": { "input": "foobar", "groups": { "name": "foobar" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": ":name" }],
+    "inputs": [{ "pathname": "foobar" }],
+    "expected_match": {
+      "pathname": { "input": "foobar", "groups": { "name": "foobar" }}
+    }
+  },
+  {
+    "pattern": [{ "protocol": ":name*" }],
+    "inputs": [{ "protocol": "foobar" }],
+    "expected_match": {
+      "protocol": { "input": "foobar", "groups": { "name": "foobar" }}
+    }
+  },
+  {
+    "pattern": [{ "protocol": ":name+" }],
+    "inputs": [{ "protocol": "foobar" }],
+    "expected_match": {
+      "protocol": { "input": "foobar", "groups": { "name": "foobar" }}
+    }
+  },
+  {
+    "pattern": [{ "protocol": ":name" }],
+    "inputs": [{ "protocol": "foobar" }],
+    "expected_match": {
+      "protocol": { "input": "foobar", "groups": { "name": "foobar" }}
+    }
+  },
+  {
+    "pattern": [{ "hostname": "bad hostname" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hostname": "bad#hostname" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hostname": "bad%hostname" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hostname": "bad/hostname" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hostname": "bad\\:hostname" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hostname": "bad<hostname" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hostname": "bad>hostname" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hostname": "bad?hostname" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hostname": "bad@hostname" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hostname": "bad[hostname" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hostname": "bad]hostname" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hostname": "bad\\\\hostname" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hostname": "bad^hostname" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hostname": "bad|hostname" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hostname": "bad\nhostname" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hostname": "bad\rhostname" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{ "hostname": "bad\thostname" }],
+    "expected_obj": "error"
+  },
+  {
+    "pattern": [{}],
+    "inputs": ["https://example.com/"],
+    "expected_match": {
+      "protocol": { "input": "https", "groups": { "0": "https" }},
+      "hostname": { "input": "example.com", "groups": { "0": "example.com" }},
+      "pathname": { "input": "/", "groups": { "0": "/" }}
+    }
+  },
+  {
+    "pattern": [],
+    "inputs": ["https://example.com/"],
+    "expected_match": {
+      "protocol": { "input": "https", "groups": { "0": "https" }},
+      "hostname": { "input": "example.com", "groups": { "0": "example.com" }},
+      "pathname": { "input": "/", "groups": { "0": "/" }}
+    }
+  },
+  {
+    "pattern": [],
+    "inputs": [{}],
+    "expected_match": {}
+  },
+  {
+    "pattern": [],
+    "inputs": [],
+    "expected_match": { "inputs": [{}] }
+  },
+  {
+    "pattern": [{ "pathname": "(foo)(.*)" }],
+    "inputs": [{ "pathname": "foobarbaz" }],
+    "expected_match": {
+      "pathname": { "input": "foobarbaz", "groups": { "0": "foo", "1": "barbaz" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "{(foo)bar}(.*)" }],
+    "inputs": [{ "pathname": "foobarbaz" }],
+    "expected_match": {
+      "pathname": { "input": "foobarbaz", "groups": { "0": "foo", "1": "baz" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "(foo)?(.*)" }],
+    "inputs": [{ "pathname": "foobarbaz" }],
+    "expected_obj": {
+      "pathname": "(foo)?*"
+    },
+    "expected_match": {
+      "pathname": { "input": "foobarbaz", "groups": { "0": "foo", "1": "barbaz" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "{:foo}(.*)" }],
+    "inputs": [{ "pathname": "foobarbaz" }],
+    "expected_match": {
+      "pathname": { "input": "foobarbaz", "groups": { "foo": "f", "0": "oobarbaz" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "{:foo}(barbaz)" }],
+    "inputs": [{ "pathname": "foobarbaz" }],
+    "expected_match": {
+      "pathname": { "input": "foobarbaz", "groups": { "foo": "foo", "0": "barbaz" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "{:foo}{(.*)}" }],
+    "inputs": [{ "pathname": "foobarbaz" }],
+    "expected_obj": {
+      "pathname": "{:foo}(.*)"
+    },
+    "expected_match": {
+      "pathname": { "input": "foobarbaz", "groups": { "foo": "f", "0": "oobarbaz" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "{:foo}{(.*)bar}" }],
+    "inputs": [{ "pathname": "foobarbaz" }],
+    "expected_obj": {
+      "pathname": ":foo{*bar}"
+    },
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "{:foo}{bar(.*)}" }],
+    "inputs": [{ "pathname": "foobarbaz" }],
+    "expected_obj": {
+      "pathname": ":foo{bar*}"
+    },
+    "expected_match": {
+      "pathname": { "input": "foobarbaz", "groups": { "foo": "foo", "0": "baz" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "{:foo}:bar(.*)" }],
+    "inputs": [{ "pathname": "foobarbaz" }],
+    "expected_obj": {
+      "pathname": ":foo:bar(.*)"
+    },
+    "expected_match": {
+      "pathname": { "input": "foobarbaz", "groups": { "foo": "f", "bar": "oobarbaz" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "{:foo}?(.*)" }],
+    "inputs": [{ "pathname": "foobarbaz" }],
+    "expected_obj": {
+      "pathname": ":foo?*"
+    },
+    "expected_match": {
+      "pathname": { "input": "foobarbaz", "groups": { "foo": "f", "0": "oobarbaz" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "{:foo\\bar}" }],
+    "inputs": [{ "pathname": "foobar" }],
+    "expected_match": {
+      "pathname": { "input": "foobar", "groups": { "foo": "foo" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "{:foo\\.bar}" }],
+    "inputs": [{ "pathname": "foo.bar" }],
+    "expected_obj": {
+      "pathname": "{:foo.bar}"
+    },
+    "expected_match": {
+      "pathname": { "input": "foo.bar", "groups": { "foo": "foo" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "{:foo(foo)bar}" }],
+    "inputs": [{ "pathname": "foobar" }],
+    "expected_match": {
+      "pathname": { "input": "foobar", "groups": { "foo": "foo" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "{:foo}bar" }],
+    "inputs": [{ "pathname": "foobar" }],
+    "expected_match": {
+      "pathname": { "input": "foobar", "groups": { "foo": "foo" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": ":foo\\bar" }],
+    "inputs": [{ "pathname": "foobar" }],
+    "expected_obj": {
+      "pathname": "{:foo}bar"
+    },
+    "expected_match": {
+      "pathname": { "input": "foobar", "groups": { "foo": "foo" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": ":foo{}(.*)" }],
+    "inputs": [{ "pathname": "foobar" }],
+    "expected_obj": {
+      "pathname": "{:foo}(.*)"
+    },
+    "expected_match": {
+      "pathname": { "input": "foobar", "groups": { "foo": "f", "0": "oobar" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": ":foo{}bar" }],
+    "inputs": [{ "pathname": "foobar" }],
+    "expected_obj": {
+      "pathname": "{:foo}bar"
+    },
+    "expected_match": {
+      "pathname": { "input": "foobar", "groups": { "foo": "foo" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": ":foo{}?bar" }],
+    "inputs": [{ "pathname": "foobar" }],
+    "expected_obj": {
+      "pathname": "{:foo}bar"
+    },
+    "expected_match": {
+      "pathname": { "input": "foobar", "groups": { "foo": "foo" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "*{}**?" }],
+    "inputs": [{ "pathname": "foobar" }],
+    "expected_obj": {
+      "pathname": "*(.*)?"
+    },
+    "//": "The `null` below is translated to undefined in the test harness.",
+    "expected_match": {
+      "pathname": { "input": "foobar", "groups": { "0": "foobar", "1": null }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": ":foo(baz)(.*)" }],
+    "inputs": [{ "pathname": "bazbar" }],
+    "expected_match": {
+      "pathname": { "input": "bazbar", "groups": { "foo": "baz", "0": "bar" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": ":foo(baz)bar" }],
+    "inputs": [{ "pathname": "bazbar" }],
+    "expected_match": {
+      "pathname": { "input": "bazbar", "groups": { "foo": "baz" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "*/*" }],
+    "inputs": [{ "pathname": "foo/bar" }],
+    "expected_match": {
+      "pathname": { "input": "foo/bar", "groups": { "0": "foo", "1": "bar" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "*\\/*" }],
+    "inputs": [{ "pathname": "foo/bar" }],
+    "expected_obj": {
+      "pathname": "*/{*}"
+    },
+    "expected_match": {
+      "pathname": { "input": "foo/bar", "groups": { "0": "foo", "1": "bar" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "*/{*}" }],
+    "inputs": [{ "pathname": "foo/bar" }],
+    "expected_match": {
+      "pathname": { "input": "foo/bar", "groups": { "0": "foo", "1": "bar" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "*//*" }],
+    "inputs": [{ "pathname": "foo/bar" }],
+    "expected_match": null
+  },
+  {
+    "pattern": [{ "pathname": "/:foo." }],
+    "inputs": [{ "pathname": "/bar." }],
+    "expected_match": {
+      "pathname": { "input": "/bar.", "groups": { "foo": "bar" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/:foo.." }],
+    "inputs": [{ "pathname": "/bar.." }],
+    "expected_match": {
+      "pathname": { "input": "/bar..", "groups": { "foo": "bar" } }
+    }
+  },
+  {
+    "pattern": [{ "pathname": "./foo" }],
+    "inputs": [{ "pathname": "./foo" }],
+    "expected_match": {
+      "pathname": { "input": "./foo", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "../foo" }],
+    "inputs": [{ "pathname": "../foo" }],
+    "expected_match": {
+      "pathname": { "input": "../foo", "groups": {}}
+    }
+  },
+  {
+    "pattern": [{ "pathname": ":foo./" }],
+    "inputs": [{ "pathname": "bar./" }],
+    "expected_match": {
+      "pathname": { "input": "bar./", "groups": { "foo": "bar" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": ":foo../" }],
+    "inputs": [{ "pathname": "bar../" }],
+    "expected_match": {
+      "pathname": { "input": "bar../", "groups": { "foo": "bar" }}
+    }
+  },
+  {
+    "pattern": [{ "pathname": "/:foo\\bar" }],
+    "inputs": [{ "pathname": "/bazbar" }],
+    "expected_obj": {
+      "pathname": "{/:foo}bar"
+    },
+    "expected_match": {
+      "pathname": { "input": "/bazbar", "groups": { "foo": "baz" }}
+    }
+  }
+]
diff --git a/test/fixtures/wpt/urlpattern/resources/urlpatterntests.js b/test/fixtures/wpt/urlpattern/resources/urlpatterntests.js
new file mode 100644
index 00000000000000..f774699bff99c3
--- /dev/null
+++ b/test/fixtures/wpt/urlpattern/resources/urlpatterntests.js
@@ -0,0 +1,169 @@
+const kComponents = [
+  'protocol',
+  'username',
+  'password',
+  'hostname',
+  'port',
+  'password',
+  'pathname',
+  'search',
+  'hash',
+];
+
+function runTests(data) {
+  for (let entry of data) {
+    test(function() {
+      if (entry.expected_obj === 'error') {
+        assert_throws_js(TypeError, _ => new URLPattern(...entry.pattern),
+                         'URLPattern() constructor');
+        return;
+      }
+
+      const pattern = new URLPattern(...entry.pattern);
+
+      // If the expected_obj property is not present we will automatically
+      // fill it with the most likely expected values.
+      entry.expected_obj = entry.expected_obj || {};
+
+      // The compiled URLPattern object should have a property for each
+      // component exposing the compiled pattern string.
+      for (let component of kComponents) {
+        // If the test case explicitly provides an expected pattern string,
+        // then use that.  This is necessary in cases where the original
+        // construction pattern gets canonicalized, etc.
+        let expected = entry.expected_obj[component];
+
+        // If there is no explicit expected pattern string, then compute
+        // the expected value based on the URLPattern constructor args.
+        if (expected == undefined) {
+          // First determine if there is a baseURL present in the pattern
+          // input.  A baseURL can be the source for many component patterns.
+          let baseURL = null;
+          if (entry.pattern.length > 0 && entry.pattern[0].baseURL) {
+            baseURL = new URL(entry.pattern[0].baseURL);
+          } else if (entry.pattern.length > 1 &&
+                     typeof entry.pattern[1] === 'string') {
+            baseURL = new URL(entry.pattern[1]);
+          }
+
+          // We automatically populate the expected pattern string using
+          // the following options in priority order:
+          //
+          //  1. If the original input explicitly provided a pattern, then
+          //     echo that back as the expected value.
+          //  2. If the baseURL exists and provides a component value then
+          //     use that for the expected pattern.
+          //  3. Otherwise fall back on the default pattern of `*` for an
+          //     empty component pattern.
+          if (entry.exactly_empty_components &&
+              entry.exactly_empty_components.includes(component)) {
+            expected = '';
+          } else if (typeof entry.pattern[0] === 'object' &&
+              entry.pattern[0][component]) {
+            expected = entry.pattern[0][component];
+          } else if (baseURL) {
+            let base_value = baseURL[component];
+            // Unfortunately some URL() getters include separator chars; e.g.
+            // the trailing `:` for the protocol.  Strip those off if necessary.
+            if (component === 'protocol')
+              base_value = base_value.substring(0, base_value.length - 1);
+            else if (component === 'search' || component === 'hash')
+              base_value = base_value.substring(1, base_value.length);
+            expected = base_value;
+          } else {
+            expected = '*';
+          }
+        }
+
+        // Finally, assert that the compiled object property matches the
+        // expected property.
+        assert_equals(pattern[component], expected,
+                      `compiled pattern property '${component}'`);
+      }
+
+      if (entry.expected_match === 'error') {
+        assert_throws_js(TypeError, _ => pattern.test(...entry.inputs),
+                         'test() result');
+        assert_throws_js(TypeError, _ => pattern.exec(...entry.inputs),
+                         'exec() result');
+        return;
+      }
+
+      // First, validate the test() method by converting the expected result to
+      // a truthy value.
+      assert_equals(pattern.test(...entry.inputs), !!entry.expected_match,
+                    'test() result');
+
+      // Next, start validating the exec() method.
+      const exec_result = pattern.exec(...entry.inputs);
+
+      // On a failed match exec() returns null.
+      if (!entry.expected_match || typeof entry.expected_match !== "object") {
+        assert_equals(exec_result, entry.expected_match, 'exec() failed match result');
+        return;
+      }
+
+      if (!entry.expected_match.inputs)
+        entry.expected_match.inputs = entry.inputs;
+
+      // Next verify the result.input is correct.  This may be a structured
+      // URLPatternInit dictionary object or a URL string.
+      assert_equals(exec_result.inputs.length,
+                    entry.expected_match.inputs.length,
+                    'exec() result.inputs.length');
+      for (let i = 0; i < exec_result.inputs.length; ++i) {
+        const input = exec_result.inputs[i];
+        const expected_input = entry.expected_match.inputs[i];
+        if (typeof input === 'string') {
+          assert_equals(input, expected_input, `exec() result.inputs[${i}]`);
+          continue;
+        }
+        for (let component of kComponents) {
+          assert_equals(input[component], expected_input[component],
+                        `exec() result.inputs[${i}][${component}]`);
+        }
+      }
+
+      // Next we will compare the URLPatternComponentResult for each of these
+      // expected components.
+      for (let component of kComponents) {
+        let expected_obj = entry.expected_match[component];
+
+        // If the test expectations don't include a component object, then
+        // we auto-generate one.  This is convenient for the many cases
+        // where the pattern has a default wildcard or empty string pattern
+        // for a component and the input is essentially empty.
+        if (!expected_obj) {
+          expected_obj = { input: '', groups: {} };
+
+          // Next, we must treat default wildcards differently than empty string
+          // patterns.  The wildcard results in a capture group, but the empty
+          // string pattern does not.  The expectation object must list which
+          // components should be empty instead of wildcards in
+          // |exactly_empty_components|.
+          if (!entry.exactly_empty_components ||
+              !entry.exactly_empty_components.includes(component)) {
+            expected_obj.groups['0'] = '';
+          }
+        }
+        // JSON does not allow us to use undefined directly, so the data file
+        // contains null instead.  Translate to the expected undefined value
+        // here.
+        for (const key in expected_obj.groups) {
+          if (expected_obj.groups[key] === null) {
+            expected_obj.groups[key] = undefined;
+          }
+        }
+        assert_object_equals(exec_result[component], expected_obj,
+                             `exec() result for ${component}`);
+      }
+    }, `Pattern: ${JSON.stringify(entry.pattern)} ` +
+       `Inputs: ${JSON.stringify(entry.inputs)}`);
+  }
+}
+
+promise_test(async function() {
+  const response = await fetch('resources/urlpatterntestdata.json');
+  const data = await response.json();
+  runTests(data);
+}, 'Loading data...');
diff --git a/test/fixtures/wpt/urlpattern/urlpattern-compare.any.js b/test/fixtures/wpt/urlpattern/urlpattern-compare.any.js
new file mode 100644
index 00000000000000..8db38adfd41d47
--- /dev/null
+++ b/test/fixtures/wpt/urlpattern/urlpattern-compare.any.js
@@ -0,0 +1,2 @@
+// META: global=window,worker
+// META: script=resources/urlpattern-compare-tests.js
diff --git a/test/fixtures/wpt/urlpattern/urlpattern-compare.https.any.js b/test/fixtures/wpt/urlpattern/urlpattern-compare.https.any.js
new file mode 100644
index 00000000000000..8db38adfd41d47
--- /dev/null
+++ b/test/fixtures/wpt/urlpattern/urlpattern-compare.https.any.js
@@ -0,0 +1,2 @@
+// META: global=window,worker
+// META: script=resources/urlpattern-compare-tests.js
diff --git a/test/fixtures/wpt/urlpattern/urlpattern.any.js b/test/fixtures/wpt/urlpattern/urlpattern.any.js
new file mode 100644
index 00000000000000..7d47d22609bf8e
--- /dev/null
+++ b/test/fixtures/wpt/urlpattern/urlpattern.any.js
@@ -0,0 +1,2 @@
+// META: global=window,worker
+// META: script=resources/urlpatterntests.js
diff --git a/test/fixtures/wpt/urlpattern/urlpattern.https.any.js b/test/fixtures/wpt/urlpattern/urlpattern.https.any.js
new file mode 100644
index 00000000000000..7d47d22609bf8e
--- /dev/null
+++ b/test/fixtures/wpt/urlpattern/urlpattern.https.any.js
@@ -0,0 +1,2 @@
+// META: global=window,worker
+// META: script=resources/urlpatterntests.js
diff --git a/test/fixtures/wpt/versions.json b/test/fixtures/wpt/versions.json
index 9f81c28c198c48..3c7b6bcf6b5e4c 100644
--- a/test/fixtures/wpt/versions.json
+++ b/test/fixtures/wpt/versions.json
@@ -59,6 +59,10 @@
     "commit": "77d54aa9e0405f737987b59331f3584e3e1c26f9",
     "path": "url"
   },
+  "urlpattern": {
+    "commit": "111b696bdbb572a89065ce2d3cd524f7d6798301",
+    "path": "urlpattern"
+  },
   "user-timing": {
     "commit": "df24fb604e2d40528ac1d1b5dd970e32fc5c2978",
     "path": "user-timing"
diff --git a/test/parallel/test-urlpattern.js b/test/parallel/test-urlpattern.js
new file mode 100644
index 00000000000000..9a01eba87bd374
--- /dev/null
+++ b/test/parallel/test-urlpattern.js
@@ -0,0 +1,458 @@
+'use strict';
+
+require('../common');
+
+const {
+  ok,
+  strictEqual,
+  deepStrictEqual,
+} = require('assert');
+
+const {
+  URLPattern,
+} = require('url');
+
+const kTests = [
+  {
+    pattern: undefined,
+    components: {
+      protocol: '*',
+      username: '*',
+      password: '*',
+      hostname: '*',
+      port: '*',
+      pathname: '*',
+      search: '*',
+      hash: '*',
+    },
+    urls: [
+      {
+        input: 'https://a:b@example.org/a/b/c?foo#bar',
+        result: {
+          inputs: ['https://a:b@example.org/a/b/c?foo#bar'],
+          protocol: { input: 'https', groups: { '0': 'https' } },
+          username: { input: 'a', groups: { '0': 'a' } },
+          password: { input: 'b', groups: { '0': 'b' } },
+          hostname: { input: 'example.org', groups: { '0': 'example.org' } },
+          port: { input: '', groups: { '0': '' } },
+          pathname: { input: '/a/b/c', groups: { '0': '/a/b/c' } },
+          search: { input: 'foo', groups: { '0': 'foo' } },
+          hash: { input: 'bar', groups: { '0': 'bar' } },
+        },
+      },
+      {
+        input: 'https://a:b@example.org/a/b/c?foo',
+        result: {
+          inputs: ['https://a:b@example.org/a/b/c?foo'],
+          protocol: { input: 'https', groups: { '0': 'https' } },
+          username: { input: 'a', groups: { '0': 'a' } },
+          password: { input: 'b', groups: { '0': 'b' } },
+          hostname: { input: 'example.org', groups: { '0': 'example.org' } },
+          port: { input: '', groups: { '0': '' } },
+          pathname: { input: '/a/b/c', groups: { '0': '/a/b/c' } },
+          search: { input: 'foo', groups: { '0': 'foo' } },
+          hash: { input: '', groups: { '0': '' } },
+        },
+      },
+    ],
+  },
+];
+
+kTests.forEach((test) => {
+  const pattern = new URLPattern(test.pattern);
+  strictEqual(pattern.protocol, test.components.protocol);
+  strictEqual(pattern.username, test.components.username);
+  strictEqual(pattern.password, test.components.password);
+  strictEqual(pattern.hostname, test.components.hostname);
+  strictEqual(pattern.port, test.components.port);
+  strictEqual(pattern.pathname, test.components.pathname);
+  strictEqual(pattern.search, test.components.search);
+  strictEqual(pattern.hash, test.components.hash);
+
+  test.urls.forEach((url) => {
+    ok(pattern.test(url.input));
+    deepStrictEqual(pattern.exec(url.input), url.result);
+  });
+});
+
+{
+ const pattern = new URLPattern({ pathname: '/books' });
+//  console.log(pattern.test('https://example.com/books')); // true
+//  console.log(pattern.exec('https://example.com/books').pathname.groups); // {}
+}
+
+{
+  // const pattern = new URLPattern({ pathname: '/books/:id' });
+  // console.log(pattern.test('https://example.com/books/123')); // true
+  // console.log(pattern.exec('https://example.com/books/123').pathname.groups); // { id: '123' }
+}
+
+{
+  // const pattern = new URLPattern('/books/:id(\\d+)', 'https://example.com');
+  // console.log(pattern.test('https://example.com/books/123')); // true
+  // console.log(pattern.test('https://example.com/books/abc')); // false
+  // console.log(pattern.test('https://example.com/books/')); // false
+}
+
+{
+  // // A named group
+  // const pattern = new URLPattern('/books/:id(\\d+)', 'https://example.com');
+  // console.log(pattern.exec('https://example.com/books/123').pathname.groups); // { id: '123' }
+
+  // // An unnamed group
+  // const pattern = new URLPattern('/books/(\\d+)', 'https://example.com');
+  // console.log(pattern.exec('https://example.com/books/123').pathname.groups); // { '0': '123' }
+}
+
+{
+  // // An optional group
+  // const pattern = new URLPattern('/books/:id?', 'https://example.com');
+  // console.log(pattern.test('https://example.com/books/123')); // true
+  // console.log(pattern.test('https://example.com/books')); // true
+  // console.log(pattern.test('https://example.com/books/')); // false
+  // console.log(pattern.test('https://example.com/books/123/456')); // false
+  // console.log(pattern.test('https://example.com/books/123/456/789')); // false
+
+  // // A repeating group with a minimum of one
+  // const pattern = new URLPattern('/books/:id+', 'https://example.com');
+  // console.log(pattern.test('https://example.com/books/123')); // true
+  // console.log(pattern.test('https://example.com/books')); // false
+  // console.log(pattern.test('https://example.com/books/')); // false
+  // console.log(pattern.test('https://example.com/books/123/456')); // true
+  // console.log(pattern.test('https://example.com/books/123/456/789')); // true
+
+  // // A repeating group with a minimum of zero
+  // const pattern = new URLPattern('/books/:id*', 'https://example.com');
+  // console.log(pattern.test('https://example.com/books/123')); // true
+  // console.log(pattern.test('https://example.com/books')); // true
+  // console.log(pattern.test('https://example.com/books/')); // false
+  // console.log(pattern.test('https://example.com/books/123/456')); // true
+  // console.log(pattern.test('https://example.com/books/123/456/789')); // true
+}
+
+{
+  // // A group delimiter with a ? (optional) modifier
+  // const pattern = new URLPattern('/book{s}?', 'https://example.com');
+  // console.log(pattern.test('https://example.com/books')); // true
+  // console.log(pattern.test('https://example.com/book')); // true
+  // console.log(pattern.exec('https://example.com/books').pathname.groups); // {}
+
+  // // A group delimiter without a modifier
+  // const pattern = new URLPattern('/book{s}', 'https://example.com');
+  // console.log(pattern.pathname); // /books
+  // console.log(pattern.test('https://example.com/books')); // true
+  // console.log(pattern.test('https://example.com/book')); // false
+
+  // // A group delimiter containing a capturing group
+  // const pattern = new URLPattern({ pathname: '/blog/:id(\\d+){-:title}?' });
+  // console.log(pattern.test('https://example.com/blog/123-my-blog')); // true
+  // console.log(pattern.test('https://example.com/blog/123')); // true
+  // console.log(pattern.test('https://example.com/blog/my-blog')); // false
+}
+
+{
+  // // A pattern with an optional group, preceded by a slash
+  // const pattern = new URLPattern('/books/:id?', 'https://example.com');
+  // console.log(pattern.test('https://example.com/books/123')); // true
+  // console.log(pattern.test('https://example.com/books')); // true
+  // console.log(pattern.test('https://example.com/books/')); // false
+
+  // // A pattern with a repeating group, preceded by a slash
+  // const pattern = new URLPattern('/books/:id+', 'https://example.com');
+  // console.log(pattern.test('https://example.com/books/123')); // true
+  // console.log(pattern.test('https://example.com/books/123/456')); // true
+  // console.log(pattern.test('https://example.com/books/123/')); // false
+  // console.log(pattern.test('https://example.com/books/123/456/')); // false
+
+  // // Segment prefixing does not occur outside of pathname patterns
+  // const pattern = new URLPattern({ hash: '/books/:id?' });
+  // console.log(pattern.test('https://example.com#/books/123')); // true
+  // console.log(pattern.test('https://example.com#/books')); // false
+  // console.log(pattern.test('https://example.com#/books/')); // true
+
+  // // Disabling segment prefixing for a group using a group delimiter
+  // const pattern = new URLPattern({ pathname: '/books/{:id}?' });
+  // console.log(pattern.test('https://example.com/books/123')); // true
+  // console.log(pattern.test('https://example.com/books')); // false
+  // console.log(pattern.test('https://example.com/books/')); // true
+}
+
+{
+  // // A wildcard at the end of a pattern
+  // const pattern = new URLPattern('/books/', 'https://example.com');
+  // console.log(pattern.test('https://example.com/books/123')); // true
+  // console.log(pattern.test('https://example.com/books')); // false
+  // console.log(pattern.test('https://example.com/books/')); // true
+  // console.log(pattern.test('https://example.com/books/123/456')); // true
+
+  // // A wildcard in the middle of a pattern
+  // const pattern = new URLPattern('/*.png', 'https://example.com');
+  // console.log(pattern.test('https://example.com/image.png')); // true
+  // console.log(pattern.test('https://example.com/image.png/123')); // false
+  // console.log(pattern.test('https://example.com/folder/image.png')); // true
+  // console.log(pattern.test('https://example.com/.png')); // true
+}
+
+{
+  // // Construct a URLPattern that matches a specific domain and its subdomains.
+  // // All other URL components default to the wildcard `*` pattern.
+  // const pattern = new URLPattern({
+  //   hostname: '{*.}?example.com',
+  // });
+
+  // console.log(pattern.hostname); // '{*.}?example.com'
+
+  // console.log(pattern.protocol); // '*'
+  // console.log(pattern.username); // '*'
+  // console.log(pattern.password); // '*'
+  // console.log(pattern.pathname); // '*'
+  // console.log(pattern.search); // '*'
+  // console.log(pattern.hash); // '*'
+
+  // console.log(pattern.test('https://example.com/foo/bar')); // true
+
+  // console.log(pattern.test({ hostname: 'cdn.example.com' })); // true
+
+  // console.log(pattern.test('custom-protocol://example.com/other/path?q=1')); // true
+
+  // // Prints `false` because the hostname component does not match
+  // console.log(pattern.test('https://cdn-example.com/foo/bar'));
+}
+
+{
+  // // Construct a URLPattern that matches URLs to CDN servers loading jpg images.
+  // // URL components not explicitly specified, like search and hash here, result
+  // // in the empty string similar to the URL() constructor.
+  // const pattern = new URLPattern('https://cdn-*.example.com/*.jpg');
+
+  // console.log(pattern.protocol); // 'https'
+
+  // console.log(pattern.hostname); // 'cdn-*.example.com'
+
+  // console.log(pattern.pathname); // '/*.jpg'
+
+  // console.log(pattern.username); // ''
+  // console.log(pattern.password); // ''
+  // console.log(pattern.search); // ''
+  // console.log(pattern.hash); // ''
+
+  // // Prints `true`
+  // console.log(
+  //     pattern.test("https://cdn-1234.example.com/product/assets/hero.jpg");
+
+  // // Prints `false` because the search component does not match
+  // console.log(
+  //     pattern.test("https://cdn-1234.example.com/product/assets/hero.jpg?q=1");
+}
+
+{
+  // // Throws because this is interpreted as a single relative pathname pattern
+  // // with a ":foo" named group and there is no base URL.
+  // const pattern = new URLPattern('data:foo*');
+}
+
+{
+  // // Constructs a URLPattern treating the `:` as the protocol suffix.
+  // const pattern = new URLPattern('data\\:foo*');
+
+  // console.log(pattern.protocol); // 'data'
+
+  // console.log(pattern.pathname); // 'foo*'
+
+  // console.log(pattern.username); // ''
+  // console.log(pattern.password); // ''
+  // console.log(pattern.hostname); // ''
+  // console.log(pattern.port); // ''
+  // console.log(pattern.search); // ''
+  // console.log(pattern.hash); // ''
+
+  // console.log(pattern.test('data:foobar')); // true
+}
+
+{
+  // const pattern = new URLPattern({ hostname: 'example.com', pathname: '/foo/*' });
+
+  // // Prints `true` as the hostname based in the dictionary `baseURL` property
+  // // matches.
+  // console.log(pattern.test({
+  //   pathname: '/foo/bar',
+  //   baseURL: 'https://example.com/baz',
+  // }));
+
+  // // Prints `true` as the hostname in the second argument base URL matches.
+  // console.log(pattern.test('/foo/bar', 'https://example.com/baz'));
+
+  // // Throws because the second argument cannot be passed with a dictionary input.
+  // try {
+  //   pattern.test({ pathname: '/foo/bar' }, 'https://example.com/baz');
+  // } catch (e) {}
+
+  // // The `exec()` method takes the same arguments as `test()`.
+  // const result = pattern.exec('/foo/bar', 'https://example.com/baz');
+
+  // console.log(result.pathname.input); // '/foo/bar'
+
+  // console.log(result.pathname.groups[0]); // 'bar'
+
+  // console.log(result.hostname.input); // 'example.com'
+}
+
+{
+  // const pattern1 = new URLPattern({ pathname: '/foo/*',
+  // baseURL: 'https://example.com' });
+
+  // console.log(pattern1.protocol); // 'https'
+  // console.log(pattern1.hostname); // 'example.com'
+  // console.log(pattern1.pathname); // '/foo/*'
+
+  // console.log(pattern1.username); // ''
+  // console.log(pattern1.password); // ''
+  // console.log(pattern1.port); // ''
+  // console.log(pattern1.search); // ''
+  // console.log(pattern1.hash); // ''
+
+  // // Equivalent to pattern1
+  // const pattern2 = new URLPattern('/foo/*', 'https://example.com' });
+
+  // // Throws because a relative constructor string must have a base URL to resolve
+  // // against.
+  // try {
+  // const pattern3 = new URLPattern('/foo/*');
+  // } catch (e) {}
+}
+
+{
+  // const pattern = new URLPattern({ hostname: '*.example.com' });
+  // const result = pattern.exec({ hostname: 'cdn.example.com' });
+
+  // console.log(result.hostname.groups[0]); // 'cdn'
+
+  // console.log(result.hostname.input); // 'cdn.example.com'
+
+  // console.log(result.inputs); // [{ hostname: 'cdn.example.com' }]
+}
+
+{
+  // // Construct a URLPattern using matching groups with custom names.  These
+  // // names can then be later used to access the matched values in the result
+  // // object.
+  // const pattern = new URLPattern({ pathname: '/:product/:user/:action' });
+  // const result = pattern.exec({ pathname: '/store/wanderview/view' });
+
+  // console.log(result.pathname.groups.product); // 'store'
+  // console.log(result.pathname.groups.user); // 'wanderview'
+  // console.log(result.pathname.groups.action); // 'view'
+
+  // console.log(result.pathname.input); // '/store/wanderview/view'
+
+  // console.log(result.inputs); // [{ pathname: '/store/wanderview/view' }]
+}
+
+{
+  // const pattern = new URLPattern({ pathname: '/(foo|bar)' });
+
+  // console.log(pattern.test({ pathname: '/foo' })); // true
+  // console.log(pattern.test({ pathname: '/bar' })); // true
+  // console.log(pattern.test({ pathname: '/baz' })); // false
+
+  // const result = pattern.exec({ pathname: '/foo' });
+
+  // console.log(result.pathname.groups[0]); // 'foo'
+}
+
+{
+  // const pattern = new URLPattern({ pathname: '/:type(foo|bar)' });
+  // const result = pattern.exec({ pathname: '/foo' });
+
+  // console.log(result.pathname.groups.type); // 'foo'
+}
+
+{
+  // const pattern = new URLPattern({ pathname: '/product/(index.html)?' });
+
+  // console.log(pattern.test({ pathname: '/product/index.html' })); // true
+  // console.log(pattern.test({ pathname: '/product' })); // true
+
+  // const pattern2 = new URLPattern({ pathname: '/product/:action?' });
+
+  // console.log(pattern2.test({ pathname: '/product/view' })); // true
+  // console.log(pattern2.test({ pathname: '/product' })); // true
+
+  // // Wildcards can be made optional as well.  This may not seem to make sense
+  // // since they already match the empty string, but it also makes the prefix
+  // // `/` optional in a pathname pattern.
+  // const pattern3 = new URLPattern({ pathname: '/product/*?' });
+
+  // console.log(pattern3.test({ pathname: '/product/wanderview/view' })); // true
+  // console.log(pattern3.test({ pathname: '/product' })); // true
+  // console.log(pattern3.test({ pathname: '/product/' })); // true
+}
+
+{
+  // const pattern = new URLPattern({ pathname: '/product/:action+' });
+  // const result = pattern.exec({ pathname: '/product/do/some/thing/cool' });
+
+  // result.pathname.groups.action; // 'do/some/thing/cool'
+
+  // console.log(pattern.test({ pathname: '/product' })); // false
+}
+
+{
+  // const pattern = new URLPattern({ pathname: '/product/:action*' });
+  // const result = pattern.exec({ pathname: '/product/do/some/thing/cool' });
+
+  // console.log(result.pathname.groups.action); // 'do/some/thing/cool'
+
+  // console.log(pattern.test({ pathname: '/product' })); // true
+}
+
+{
+  // const pattern = new URLPattern({ pathname: '/product/:action*' });
+  // const result = pattern.exec({ pathname: '/product/do/some/thing/cool' });
+
+  // console.log(result.pathname.groups.action); // 'do/some/thing/cool'
+
+  // console.log(pattern.test({ pathname: '/product' })); // true
+}
+
+{
+  // const pattern = new URLPattern({ hostname: '{:subdomain.}*example.com' });
+
+  // console.log(pattern.test({ hostname: 'example.com' })); // true
+  // console.log(pattern.test({ hostname: 'foo.bar.example.com' })); // true
+  // console.log(pattern.test({ hostname: '.example.com' })); // false
+
+  // const result = pattern.exec({ hostname: 'foo.bar.example.com' });
+
+  // console.log(result.hostname.groups.subdomain); // 'foo.bar'
+}
+
+{
+  // const pattern = new URLPattern({ pathname: '/product{/}?' });
+
+  // console.log(pattern.test({ pathname: '/product' })); // true
+  // console.log(pattern.test({ pathname: '/product/' })); // true
+
+  // const result = pattern.exec({ pathname: '/product/' });
+
+  // console.log(result.pathname.groups); // {}
+}
+
+{
+  // const pattern = new URLPattern({
+  //   protocol: 'http{s}?',
+  //   username: ':user?',
+  //   password: ':pass?',
+  //   hostname: '{:subdomain.}*example.com',
+  //   pathname: '/product/:action*',
+  // });
+
+  // const result = pattern.exec(
+  //   'http://foo:bar@sub.example.com/product/view?q=12345',
+  // );
+
+  // console.log(result.username.groups.user); // 'foo'
+  // console.log(result.password.groups.pass); // 'bar'
+  // console.log(result.hostname.groups.subdomain); // 'sub'
+  // console.log(result.pathname.groups.action); // 'view'
+}
diff --git a/test/wpt/status/urlpattern.json b/test/wpt/status/urlpattern.json
new file mode 100644
index 00000000000000..ad8adcd4477ccb
--- /dev/null
+++ b/test/wpt/status/urlpattern.json
@@ -0,0 +1,8 @@
+{
+    "urlpattern-compare.any.js": {
+        "skip": "TODO: implement URLPatter.compareComponent"
+    },
+    "urlpattern-compare.https.any.js": {
+        "skip": "TODO: implement URLPatter.compareComponent"
+    }
+}
\ No newline at end of file
diff --git a/test/wpt/test-urlpattern.js b/test/wpt/test-urlpattern.js
new file mode 100644
index 00000000000000..55da1ef0778e01
--- /dev/null
+++ b/test/wpt/test-urlpattern.js
@@ -0,0 +1,17 @@
+'use strict';
+
+require('../common');
+const { WPTRunner } = require('../common/wpt');
+
+const runner = new WPTRunner('urlpattern');
+
+// Set Node.js flags required for the tests.
+runner.setFlags(['--expose-internals']);
+
+// Set a script that will be executed in the worker before running the tests.
+runner.setInitScript(`
+  const {URLPattern} = require('url');
+  global.URLPattern = URLPattern;
+`);
+
+runner.runJsTests();
diff --git a/tools/doc/type-parser.mjs b/tools/doc/type-parser.mjs
index e17bf077d70f3c..f67a36b64d6937 100644
--- a/tools/doc/type-parser.mjs
+++ b/tools/doc/type-parser.mjs
@@ -228,6 +228,10 @@ const customTypesMap = {
 
   'URL': 'url.html#the-whatwg-url-api',
   'URLSearchParams': 'url.html#class-urlsearchparams',
+  'URLPattern': 'url.html#class-urlpattern',
+  'URLPatternInit': 'url.html#object-urlpatterninit',
+  'URLPatternResult': 'url.html#object-urlpatternresult',
+  'URLPatternComponentResult': 'url.html#object-urlpatterncomponentresult',
 
   'vm.Module': 'vm.html#class-vmmodule',
   'vm.Script': 'vm.html#class-vmscript',