fast-uri 4.1.1 → 4.1.3

package/test/fixtures/uri-js-parse.json

@@ -53,6 +53,7 @@
       "host": "[2001:dbz::1]",
       "port": 80,
       "path": "",
+      "error": "URI host is malformed.",
       "reference": "relative"
     }
   ],
@@ -242,6 +243,7 @@
     {
       "host": "[2606:2800:220:1:248:1893:25c8:1946:43209]",
       "path": "",
+      "error": "URI host is malformed.",
       "reference": "relative"
     }
   ],
@@ -497,5 +499,26 @@
       "subject": "Test",
       "body": "NATTO"
     }
+  ],
+  [
+    "mailto:addr1@an.example,addr2@an.example",
+    {
+      "scheme": "mailto",
+      "reference": "absolute",
+      "to": [
+        "addr1@an.example",
+        "addr2@an.example"
+      ]
+    }
+  ],
+  [
+    "mailto:user@example.org?",
+    {
+      "scheme": "mailto",
+      "reference": "absolute",
+      "to": [
+        "user@example.org"
+      ]
+    }
   ]
-]
+]

package/test/fixtures/uri-js-serialize.json

@@ -116,5 +116,27 @@
       "path": "with:colon"
     },
     "scheme:with:colon"
+  ],
+  [
+    {
+      "scheme": "mailto",
+      "to": [
+        "chris@example.com"
+      ]
+    },
+    "mailto:chris@example.com"
+  ],
+  [
+    {
+      "scheme": "mailto",
+      "to": [
+        "joe@example.com"
+      ],
+      "headers": {
+        "cc": "bob@example.com"
+      },
+      "body": "hello"
+    },
+    "mailto:joe@example.com?cc=bob@example.com&body=hello"
   ]
-]
+]

package/test/ipv6-canonical.test.js

@@ -0,0 +1,34 @@
+'use strict'
+
+const test = require('tape')
+const fastURI = require('..')
+
+test('IPv6 hosts normalize to the RFC 5952 canonical form', (t) => {
+  const cases = [
+    ['http://[0:0:0:0:0:0:0:1]/', 'http://[::1]/'],
+    ['http://[0:0:0:0:0:0:0:0]/', 'http://[::]/'],
+    ['http://[2001:0db8:0000:0000:0000:0000:0000:0001]/', 'http://[2001:db8::1]/'],
+    ['http://[2001:0:0:0:0:0:0:1]/', 'http://[2001::1]/'],
+    ['http://[fe80:0:0:0:0:0:0:1]/', 'http://[fe80::1]/'],
+    ['http://[1:0:0:0:2:0:0:3]/', 'http://[1::2:0:0:3]/']
+  ]
+
+  for (const [uri, normalized] of cases) {
+    t.equal(fastURI.normalize(uri), normalized, `${uri} normalizes to ${normalized}`)
+  }
+  t.end()
+})
+
+test('IPv6 equal() matches the same address across compressed and expanded forms', (t) => {
+  const pairs = [
+    ['http://[::1]/', 'http://[0:0:0:0:0:0:0:1]/'],
+    ['http://[::]/', 'http://[0:0:0:0:0:0:0:0]/'],
+    ['http://[2001:db8::1]/', 'http://[2001:0db8:0000:0000:0000:0000:0000:0001]/'],
+    ['http://[1::2:0:0:3]/', 'http://[1:0:0:0:2:0:0:3]/']
+  ]
+
+  for (const [a, b] of pairs) {
+    t.equal(fastURI.equal(a, b), true, `${a} equals ${b}`)
+  }
+  t.end()
+})

package/test/ipv6-validation.test.js

@@ -0,0 +1,90 @@
+'use strict'
+
+const test = require('tape')
+const fastURI = require('..')
+
+const HOST_ERROR = 'URI host is malformed.'
+
+const malformedLiterals = [
+  '::not-valid',
+  'fc00::not-hex',
+  'fe80::not-hex',
+  '1:2:3',
+  '1:2:3:4:5:6:7',
+  '1:2:3:4:5:6:7:8:9',
+  '1::2::3',
+  '1:::2',
+  ':::1',
+  '12345::',
+  '1:2:3:4:5:6:7::8',
+  '::ffff:192.0.2.999',
+  '::ffff:192.0.2',
+  '::ffff:192.168.001.1',
+  '::192.0.2.1:1',
+  '1:2:3:4:5:192.0.2.1::',
+  'v.foo',
+  'v1.',
+  'v1.foo%25bar',
+  'v1.K',
+  'fe80::1%25',
+  'fe80::1%25eth 0',
+  'fe80::1%25eth%ZZ',
+  'fe80::1%25K',
+  'not-an-ip'
+]
+
+test('malformed bracketed IP literals fail without being rewritten', (t) => {
+  for (const literal of malformedLiterals) {
+    const uri = `http://[${literal}]/private`
+    const parsed = fastURI.parse(uri)
+
+    t.equal(parsed.error, HOST_ERROR, `parse rejects ${literal}`)
+    t.equal(parsed.host, `[${literal.toLowerCase()}]`, `parse does not truncate ${literal}`)
+    t.equal(fastURI.normalize(uri), uri, `normalize preserves ${literal}`)
+    t.equal(fastURI.equal(uri, uri), false, `equal rejects ${literal}`)
+  }
+  t.end()
+})
+
+test('resolve throws for malformed bracketed IP literals', (t) => {
+  for (const literal of malformedLiterals) {
+    const uri = `http://[${literal}]/private`
+
+    t.throws(
+      () => fastURI.resolve(uri, 'child'),
+      /URI host is malformed\./,
+      `rejects malformed base ${literal}`
+    )
+    t.throws(
+      () => fastURI.resolve('http://example.com/', uri),
+      /URI host is malformed\./,
+      `rejects malformed relative input ${literal}`
+    )
+  }
+  t.end()
+})
+
+test('valid IPv6, IPvFuture, embedded IPv4, and zone forms normalize safely', (t) => {
+  const cases = [
+    ['http://[::]/', 'http://[::]/', '::'],
+    ['http://[::1]/', 'http://[::1]/', '::1'],
+    ['http://[1::]/', 'http://[1::]/', '1::'],
+    ['http://[2001:0DB8::0001]/', 'http://[2001:db8::1]/', '2001:db8::1'],
+    ['http://[0:0:0:0:0:0:0:0]/', 'http://[::]/', '::'],
+    ['http://[::ffff:192.0.2.1]/', 'http://[::ffff:192.0.2.1]/', '::ffff:192.0.2.1'],
+    ['http://[1:2:3:4:5:6:192.0.2.1]/', 'http://[1:2:3:4:5:6:192.0.2.1]/', '1:2:3:4:5:6:192.0.2.1'],
+    ['http://[fe80::A%25EN1]/', 'http://[fe80::a%25EN1]/', 'fe80::a%EN1'],
+    ['http://[fe80::a%en1]/', 'http://[fe80::a%25en1]/', 'fe80::a%en1'],
+    ['http://[fe80::a%25eth%2D0]/', 'http://[fe80::a%25eth%2D0]/', 'fe80::a%eth%2D0'],
+    ['http://[v1.example]/', 'http://[v1.example]/', '[v1.example]'],
+    ['http://[vF.A:b]/', 'http://[vf.a:b]/', '[vf.a:b]']
+  ]
+
+  for (const [uri, normalized, host] of cases) {
+    const parsed = fastURI.parse(uri)
+    t.equal(parsed.error, undefined, `${uri} parses without error`)
+    t.equal(parsed.host, host, `${uri} has the expected host`)
+    t.equal(fastURI.normalize(uri), normalized, `${uri} normalizes safely`)
+  }
+  t.end()
+})

package/test/malformed-percent.test.js

@@ -0,0 +1,77 @@
+'use strict'
+
+const test = require('tape')
+const fastURI = require('..')
+
+const MALFORMED_PERCENT_ERROR = 'URI contains malformed percent-encoding.'
+
+const malformedComponents = [
+  ['path', 'x://example.test/a%'],
+  ['path with one trailing hex digit', 'x://example.test/a%2'],
+  ['path with non-hex digits', 'x://example.test/a%GG'],
+  ['host', 'x://exa%mple.test/path'],
+  ['userinfo', 'x://us%er@example.test/path'],
+  ['query', 'x://example.test/path?q=%G0'],
+  ['fragment', 'x://example.test/path#frag%1']
+]
+
+test('parse reports malformed percent syntax in generic URI components', (t) => {
+  for (const [component, uri] of malformedComponents) {
+    t.equal(fastURI.parse(uri).error, MALFORMED_PERCENT_ERROR, component)
+  }
+  t.end()
+})
+
+test('normalize preserves malformed percent input unchanged', (t) => {
+  for (const [component, uri] of malformedComponents) {
+    t.equal(fastURI.normalize(uri), uri, component)
+  }
+  t.end()
+})
+
+test('equal does not equate malformed input with repaired valid input', (t) => {
+  const cases = [
+    ['x://example.test/a%', 'x://example.test/a%25'],
+    ['x://exa%mple.test/path', 'x://exa%25mple.test/path'],
+    ['x://us%er@example.test/path', 'x://us%25er@example.test/path'],
+    ['x://example.test/path?q=%', 'x://example.test/path?q=%25'],
+    ['x://example.test/path#%', 'x://example.test/path#%25']
+  ]
+
+  for (const [malformed, repaired] of cases) {
+    t.equal(fastURI.equal(malformed, repaired, {}), false, malformed)
+  }
+  t.end()
+})
+
+test('resolve rejects malformed percent syntax in either input', (t) => {
+  t.throws(
+    () => fastURI.resolve('x://example.test/base%', 'child'),
+    /URI contains malformed percent-encoding\./,
+    'malformed base'
+  )
+  t.throws(
+    () => fastURI.resolve('x://example.test/base', 'child%'),
+    /URI contains malformed percent-encoding\./,
+    'malformed relative reference'
+  )
+  t.end()
+})
+
+test('valid percent octets remain valid without UTF-8 validation', (t) => {
+  const uri = '/%ff?q=%80#%fe'
+  const parsed = fastURI.parse(uri)
+
+  t.equal(parsed.error, undefined, 'non-UTF-8 octets are valid percent syntax')
+  t.equal(parsed.path, '/%FF', 'path octet is preserved and hex is uppercased')
+  t.equal(parsed.query, 'q=%80', 'query octet is preserved')
+  t.equal(parsed.fragment, '%FE', 'fragment octet is preserved and hex is uppercased')
+  t.equal(fastURI.normalize(uri), '/%FF?q=%80#%FE', 'normalization preserves the octets')
+
+  const allGenericComponents = fastURI.parse('x://u%2f@exa%2fmple.test/%2f?q=%2f#%2f')
+  t.equal(allGenericComponents.error, undefined, 'valid escapes are accepted in every generic component')
+
+  const ipv6Zone = fastURI.parse('//[2001:db8::7%en0]')
+  t.equal(ipv6Zone.error, undefined, 'historically accepted raw IPv6 zone separator is unchanged')
+  t.end()
+})

package/test/malformed-urn.test.js

@@ -0,0 +1,61 @@
+'use strict'
+
+const test = require('tape')
+const fastURI = require('..')
+
+const malformedURNs = [
+  'urn:',
+  'URN:',
+  'urn:foo',
+  'urn::foo',
+  'urn:foo:',
+  'urn:%66oo:bar'
+]
+
+test('parse reports malformed ordinary URNs', (t) => {
+  for (const uri of malformedURNs) {
+    t.match(fastURI.parse(uri).error, /^URN can not be parsed\.?$/, uri)
+  }
+  t.end()
+})
+
+test('normalize preserves malformed ordinary URNs without throwing', (t) => {
+  for (const uri of malformedURNs) {
+    t.doesNotThrow(() => fastURI.normalize(uri), `${uri} does not throw`)
+    t.equal(fastURI.normalize(uri), uri, `${uri} is preserved`)
+  }
+  t.equal(
+    fastURI.normalize('urn:foo', { reference: 'relative' }),
+    'urn:foo',
+    'an earlier parse error does not hide the missing URN nid'
+  )
+  t.end()
+})
+
+test('equal returns false for malformed ordinary URNs', (t) => {
+  for (const uri of malformedURNs) {
+    t.equal(fastURI.equal(uri, uri, {}), false, `${uri} is not equal to itself as malformed input`)
+    t.equal(fastURI.equal(uri, 'urn:foo:bar', {}), false, `${uri} is not equal to a valid URN`)
+  }
+  t.end()
+})
+
+test('resolve handles malformed ordinary URNs without throwing', (t) => {
+  for (const uri of malformedURNs) {
+    t.doesNotThrow(() => fastURI.resolve('uri://base/', uri), `${uri} does not throw as a relative reference`)
+    t.doesNotThrow(() => fastURI.resolve(uri, ''), `${uri} does not throw as a base URI`)
+  }
+  // resolve preserves the malformed scheme-specific input rather than surfacing
+  // an uncaught 'URN without nid cannot be serialized' error (matches upstream uri-js)
+  t.equal(fastURI.resolve('uri://base/', 'urn:'), 'urn:', 'malformed relative URN is preserved')
+  t.equal(fastURI.resolve('URN:', ''), 'urn:', 'scheme case is normalized')
+  t.equal(fastURI.resolve('uri://base/', 'urn:%66oo:bar'), 'urn:foo:bar', 'percent-encoding is decoded')
+  t.end()
+})
+
+test('valid URNs retain their existing behavior', (t) => {
+  t.equal(fastURI.normalize('URN:FOO:a123,456'), 'urn:foo:a123,456')
+  t.equal(fastURI.equal('urn:foo:a123,456', 'URN:FOO:a123,456', {}), true)
+  t.equal(fastURI.resolve('uri://base/', 'urn:'), 'urn:', 'default resolve behavior is unchanged')
+  t.end()
+})

package/test/parse.test.js

@@ -214,6 +214,7 @@ test('URI parse', (t) => {
   // invalid IPv6
   components = fastURI.parse('//[2001:dbZ::7]')
   t.equal(components.host, '[2001:dbz::7]')
+  t.equal(components.error, 'URI host is malformed.')
 
   // mixed IPv4address & IPv6address
   components = fastURI.parse('//[::ffff:129.144.52.38]')
@@ -318,8 +319,152 @@ test('URI parse', (t) => {
 
   components = fastURI.parse('//[2606:2800:220:1:248:1893:25c8:1946:43209]')
   t.equal(components.host, '[2606:2800:220:1:248:1893:25c8:1946:43209]')
+  t.equal(components.error, 'URI host is malformed.')
 
   components = fastURI.parse('urn:foo:|\\24fpl')
   t.equal(components.error, 'URN can not be parsed.')
   t.end()
 })
+
+test('Mailto parsing normalizes Unicode domains according to options', (t) => {
+  t.deepEqual(
+    fastURI.parse('mailto:user@納豆.example.org').to,
+    ['user@xn--99zt52a.example.org'],
+    'Unicode domain defaults to ASCII'
+  )
+  t.deepEqual(
+    fastURI.parse('mailto:user@納豆.example.org', { unicodeSupport: true }).to,
+    ['user@納豆.example.org'],
+    'Unicode domain is preserved when requested'
+  )
+  t.deepEqual(
+    fastURI.parse('mailto:user@xn--99zt52a.example.org', { unicodeSupport: true }).to,
+    ['user@xn--99zt52a.example.org'],
+    'existing punycode remains unchanged in Unicode mode'
+  )
+  t.end()
+})
+
+test('Mailto parsing preserves and reports malformed recipient domains', (t) => {
+  const cases = [
+    ['mailto:user@example.org:25', 'user@example.org:25'],
+    ['mailto:user@example.org/path', 'user@example.org/path'],
+    ['mailto:user@example.org%40evil.test', 'user@example.org@evil.test'],
+    ['mailto:user@example.org%3Fquery', 'user@example.org?query'],
+    ['mailto:user@example.org%23fragment', 'user@example.org#fragment'],
+    ['mailto:user@[broken', 'user@[broken'],
+    ['mailto:user', 'user']
+  ]
+
+  for (const [uri, recipient] of cases) {
+    const parsed = fastURI.parse(uri)
+    t.equal(parsed.error, 'URI mailto has an invalid recipient domain.', 'error for ' + uri)
+    t.deepEqual(parsed.to, [recipient], 'recipient is preserved for ' + uri)
+  }
+  t.end()
+})
+
+test('Mailto parsing handles domain literals, empty queries, and malformed headers', (t) => {
+  const literal = fastURI.parse('mailto:user@[IPv6:2001:db8::1]')
+  t.equal(literal.error, undefined, 'valid domain literal has no error')
+  t.deepEqual(literal.to, ['user@[ipv6:2001:db8::1]'], 'domain literal is preserved')
+
+  const emptyQuery = fastURI.parse('mailto:user@example.org?')
+  t.equal(emptyQuery.query, undefined, 'empty query is cleared')
+  t.equal(emptyQuery.headers, undefined, 'empty query does not create a header')
+
+  const malformedHeaders = fastURI.parse('mailto:joe@example.com?cc=bob@example.com?body=hello')
+  t.equal(malformedHeaders.error, 'URI mailto has malformed header fields.', 'malformed fields set an error')
+  t.deepEqual(malformedHeaders.to, ['joe@example.com'], 'path recipient is retained')
+  t.end()
+})
+
+test('Mailto parsing folds lone surrogates in raw input', (t) => {
+  // The handler sets `skipNormalize`, so it must fold lone surrogates itself --
+  // the generic query/path normalizers no longer run to do it.
+  const lone = '\uD800'
+  const trailing = '\uDC00'
+
+  t.deepEqual(
+    // spread: `headers` has a null prototype, which t.deepEqual compares strictly
+    { ...fastURI.parse('mailto:a@b.test?x=' + lone).headers },
+    { x: '�' },
+    'lone high surrogate in a header value becomes U+FFFD'
+  )
+  t.equal(
+    fastURI.parse('mailto:a@b.test?subject=' + trailing).subject,
+    '�',
+    'lone low surrogate in a subject becomes U+FFFD'
+  )
+  t.deepEqual(
+    fastURI.parse('mailto:' + lone + '@b.test').to,
+    ['�@b.test'],
+    'lone surrogate in a local part becomes U+FFFD'
+  )
+  t.deepEqual(
+    fastURI.parse('mailto:a@b.test?subject=😀').subject,
+    '😀',
+    'a valid surrogate pair is left intact'
+  )
+  t.end()
+})
+
+test('Mailto domain fast path agrees with the WHATWG parser', (t) => {
+  // `mailtoNormalizeDomain` skips `new URL` when `nonSimpleMailtoDomain` is
+  // false. Every domain here must come out the same either way -- especially the
+  // all-numeric last labels, which `new URL` reads as IPv4 shorthand.
+  const domains = [
+    'example.com',
+    'example.org',
+    'mail2.example.org',
+    's3.amazonaws.com',
+    'ex4mple.com',
+    '_dmarc.example.com',
+    '-a.com',
+    'a..b',
+    'a.com.',
+    '1.2.3',
+    '127.1',
+    '12',
+    '0x7f.1',
+    '9.9.9.9',
+    '1.2.3.4'
+  ]
+
+  for (const domain of domains) {
+    const parsed = fastURI.parse('mailto:user@' + domain)
+    let expected
+    try {
+      const url = new URL('http://' + domain)
+      const invalid = url.username || url.password || url.port ||
+        url.pathname !== '/' || url.search || url.hash || !url.hostname
+      expected = invalid ? domain : url.hostname
+    } catch {
+      expected = domain
+    }
+    t.deepEqual(parsed.to, ['user@' + expected], 'matches new URL for ' + domain)
+  }
+
+  // The fast path must not be taken for a domain whose last label is numeric.
+  t.deepEqual(fastURI.parse('mailto:user@1.2.3').to, ['user@1.2.0.3'], 'IPv4 shorthand is still applied')
+  t.deepEqual(fastURI.parse('mailto:user@mail2.example.org').to, ['user@mail2.example.org'], 'digits stay on the fast path')
+  t.end()
+})
+
+test('Mailto headers use a null prototype', (t) => {
+  // Header names come from untrusted input, so a lookup must not resolve to an
+  // inherited member of Object.prototype.
+  const parsed = fastURI.parse('mailto:a@b.test?blat=foop')
+  t.equal(Object.getPrototypeOf(parsed.headers), null, 'headers has no prototype')
+  t.equal(parsed.headers.toString, undefined, 'inherited members do not leak')
+  t.equal(parsed.headers.constructor, undefined, 'constructor does not leak')
+
+  // With a null prototype "__proto__" is an ordinary key rather than a setter,
+  // so it round-trips instead of being silently discarded.
+  const polluted = fastURI.parse('mailto:a@b.test?__proto__=x')
+  t.deepEqual(Object.keys(polluted.headers), ['__proto__'], '__proto__ is kept as an own key')
+  t.equal(fastURI.serialize(polluted), 'mailto:a@b.test?__proto__=x', '__proto__ round-trips')
+  t.equal({}.x, undefined, 'Object.prototype is not polluted')
+  t.equal(Object.getPrototypeOf({}), Object.prototype, 'Object.prototype is intact')
+  t.end()
+})

package/test/reserved-path-normalization.test.js

@@ -0,0 +1,109 @@
+'use strict'
+
+const test = require('tape')
+const fastURI = require('..')
+
+const PATH_RESERVED = "!$&'()*+,;=:@/"
+
+function percentEncode (character, lowerCase) {
+  const hex = character.charCodeAt(0).toString(16).padStart(2, '0')
+  return '%' + (lowerCase ? hex : hex.toUpperCase())
+}
+
+test('normalize preserves literal and escaped reserved path characters', (t) => {
+  t.equal(
+    fastURI.normalize('http://example.com/a;b'),
+    'http://example.com/a;b',
+    'literal semicolon remains literal'
+  )
+  t.equal(
+    fastURI.normalize('http://example.com/a%3ab'),
+    'http://example.com/a%3Ab',
+    'escaped colon remains escaped and its hex is uppercased'
+  )
+
+  for (const character of PATH_RESERVED) {
+    const literal = `http://example.com/a${character}b`
+    const escaped = `http://example.com/a${percentEncode(character, true)}b`
+    const normalizedEscape = `http://example.com/a${percentEncode(character, false)}b`
+
+    t.equal(fastURI.normalize(literal), literal, `preserves literal ${character}`)
+    t.equal(fastURI.normalize(escaped), normalizedEscape, `preserves escaped ${character}`)
+  }
+
+  t.equal(
+    fastURI.normalize('http://example.com/a/./café'),
+    'http://example.com/a/caf%C3%A9',
+    'removes real dot segments and UTF-8 encodes raw non-ASCII'
+  )
+  t.equal(
+    fastURI.normalize('http://example.com/a/%2e%2e/b'),
+    'http://example.com/a/%2E%2E/b',
+    'preserves escaped dots as path data'
+  )
+  t.equal(
+    fastURI.normalize('http://example.com/Kſ'),
+    'http://example.com/%E2%84%AA%C5%BF',
+    'UTF-8 encodes Unicode characters that case-fold to ASCII'
+  )
+  t.end()
+})
+
+test('serialize uses the RFC 3986 path character set without opening escapes', (t) => {
+  const rawPath = `/a${PATH_RESERVED}b`
+  t.equal(
+    fastURI.serialize({ scheme: 'http', host: 'example.com', path: rawPath }),
+    `http://example.com${rawPath}`,
+    'keeps all legal raw path characters'
+  )
+
+  const escapedPath = Array.from(PATH_RESERVED, (character) => percentEncode(character, true)).join('')
+  const normalizedEscapedPath = Array.from(PATH_RESERVED, (character) => percentEncode(character, false)).join('')
+  t.equal(
+    fastURI.serialize({ scheme: 'http', host: 'example.com', path: '/' + escapedPath }),
+    'http://example.com/' + normalizedEscapedPath,
+    'uppercases valid escapes without decoding reserved characters'
+  )
+
+  t.equal(
+    fastURI.serialize({ scheme: 'http', host: 'example.com', path: '/a?b#c[d]' }),
+    'http://example.com/a%3Fb%23c%5Bd%5D',
+    'encodes characters that would leave the path component'
+  )
+  t.equal(
+    fastURI.serialize({ path: 'a:b/c:d' }),
+    'a%3Ab/c:d',
+    'only escapes a colon where path-noscheme requires it'
+  )
+  t.equal(
+    fastURI.serialize({ path: './a:b/c:d' }),
+    'a%3Ab/c:d',
+    'escapes a first-segment colon exposed by dot-segment removal'
+  )
+  t.equal(
+    fastURI.normalize('./a:b'),
+    'a%3Ab',
+    'normalization keeps a relative path from becoming a scheme'
+  )
+  t.equal(
+    fastURI.serialize({ path: '/Kſ' }),
+    '/%E2%84%AA%C5%BF',
+    'UTF-8 encodes Unicode characters that case-fold to ASCII'
+  )
+  t.end()
+})
+
+test('equal distinguishes escaped reserved path data from literal syntax', (t) => {
+  for (const character of PATH_RESERVED) {
+    const literal = `http://example.com/a${character}b`
+    const escaped = `http://example.com/a${percentEncode(character, false)}b`
+    t.equal(fastURI.equal(literal, escaped, {}), false, `distinguishes literal and escaped ${character}`)
+  }
+
+  t.equal(
+    fastURI.equal('./a:b', 'a:b', {}),
+    false,
+    'does not equate a relative path with an absolute URI after removing dot segments'
+  )
+  t.end()
+})