bare-url 0.3.6 → 0.3.8

package/index.js

@@ -71,9 +71,9 @@ const URL = exports.URL = class URL {
 
   get host () {
     if (this._url.host === null) return ''
-    if (this._url.port === null) return this._url.host
+    if (this._url.port === null) return serialize.host(this._url.host)
 
-    return this._url.host + ':' + this._url.port
+    return serialize.host(this._url.host) + ':' + this._url.port.toString(10)
   }
 
   set host (value) {
@@ -87,7 +87,7 @@ const URL = exports.URL = class URL {
   get hostname () {
     if (this._url.host === null) return ''
 
-    return this._url.host
+    return serialize.host(this._url.host)
   }
 
   set hostname (value) {

package/lib/errors.js

@@ -44,4 +44,84 @@ module.exports = class URLError extends Error {
   static PORT_INVALID (msg = 'Invalid URL') {
     return new URLError(msg, 'PORT_INVALID', URLError.PORT_INVALID)
   }
+
+  // https://url.spec.whatwg.org/#validation-error-domain-to-ascii
+  static DOMAIN_TO_ASCII (msg = 'Invalid URL') {
+    return new URLError(msg, 'DOMAIN_TO_ASCII', URLError.DOMAIN_TO_ASCII)
+  }
+
+  // https://url.spec.whatwg.org/#domain-invalid-code-point
+  static DOMAIN_INVALID_CODE_POINT (msg = 'Invalid URL') {
+    return new URLError(msg, 'DOMAIN_INVALID_CODE_POINT', URLError.DOMAIN_INVALID_CODE_POINT)
+  }
+
+  // https://url.spec.whatwg.org/#host-invalid-code-point
+  static HOST_INVALID_CODE_POINT (msg = 'Invalid URL') {
+    return new URLError(msg, 'HOST_INVALID_CODE_POINT', URLError.HOST_INVALID_CODE_POINT)
+  }
+
+  // https://url.spec.whatwg.org/#ipv4-too-many-parts
+  static IPV4_TOO_MANY_PARTS (msg = 'Invalid URL') {
+    return new URLError(msg, 'IPV4_TOO_MANY_PARTS', URLError.IPV4_TOO_MANY_PARTS)
+  }
+
+  // https://url.spec.whatwg.org/#ipv4-non-numeric-part
+  static IPV4_NON_NUMERIC_PART (msg = 'Invalid URL') {
+    return new URLError(msg, 'IPV4_NON_NUMERIC_PART', URLError.IPV4_NON_NUMERIC_PART)
+  }
+
+  // https://url.spec.whatwg.org/#ipv4-out-of-range-part
+  static IPV4_OUT_OF_RANGE_PART (msg = 'Invalid URL') {
+    return new URLError(msg, 'IPV4_OUT_OF_RANGE_PART', URLError.IPV4_OUT_OF_RANGE_PART)
+  }
+
+  // https://url.spec.whatwg.org/#ipv6-unclosed
+  static IPV6_UNCLOSED (msg = 'Invalid URL') {
+    return new URLError(msg, 'IPV6_UNCLOSED', URLError.IPV6_UNCLOSED)
+  }
+
+  // https://url.spec.whatwg.org/#ipv6-invalid-compression
+  static IPV6_INVALID_COMPRESSION (msg = 'Invalid URL') {
+    return new URLError(msg, 'IPV6_INVALID_COMPRESSION', URLError.IPV6_INVALID_COMPRESSION)
+  }
+
+  // https://url.spec.whatwg.org/#ipv6-too-many-pieces
+  static IPV6_TOO_MANY_PIECES (msg = 'Invalid URL') {
+    return new URLError(msg, 'IPV6_TOO_MANY_PIECES', URLError.IPV6_TOO_MANY_PIECES)
+  }
+
+  // https://url.spec.whatwg.org/#ipv6-multiple-compression
+  static IPV6_MULTIPLE_COMPRESSION (msg = 'Invalid URL') {
+    return new URLError(msg, 'IPV6_MULTIPLE_COMPRESSION', URLError.IPV6_MULTIPLE_COMPRESSION)
+  }
+
+  // https://url.spec.whatwg.org/#ipv6-invalid-code-point
+  static IPV6_INVALID_CODE_POINT (msg = 'Invalid URL') {
+    return new URLError(msg, 'IPV6_INVALID_CODE_POINT', URLError.IPV6_INVALID_CODE_POINT)
+  }
+
+  // https://url.spec.whatwg.org/#ipv6-too-few-pieces
+  static IPV6_TOO_FEW_PIECES (msg = 'Invalid URL') {
+    return new URLError(msg, 'IPV6_TOO_FEW_PIECES', URLError.IPV6_TOO_FEW_PIECES)
+  }
+
+  // https://url.spec.whatwg.org/#ipv4-in-ipv6-too-many-pieces
+  static IPV4_IN_IPV6_TOO_MANY_PIECES (msg = 'Invalid URL') {
+    return new URLError(msg, 'IPV4_IN_IPV6_TOO_MANY_PIECES', URLError.IPV4_IN_IPV6_TOO_MANY_PIECES)
+  }
+
+  // https://url.spec.whatwg.org/#ipv4-in-ipv6-invalid-code-point
+  static IPV4_IN_IPV6_INVALID_CODE_POINT (msg = 'Invalid URL') {
+    return new URLError(msg, 'IPV4_IN_IPV6_INVALID_CODE_POINT', URLError.IPV4_IN_IPV6_INVALID_CODE_POINT)
+  }
+
+  // https://url.spec.whatwg.org/#ipv4-in-ipv6-out-of-range-part
+  static IPV4_IN_IPV6_OUT_OF_RANGE_PART (msg = 'Invalid URL') {
+    return new URLError(msg, 'IPV4_IN_IPV6_OUT_OF_RANGE_PART', URLError.IPV4_IN_IPV6_OUT_OF_RANGE_PART)
+  }
+
+  // https://url.spec.whatwg.org/#ipv4-in-ipv6-too-few-parts
+  static IPV4_IN_IPV6_TOO_FEW_PARTS (msg = 'Invalid URL') {
+    return new URLError(msg, 'IPV4_IN_IPV6_TOO_FEW_PARTS', URLError.IPV4_IN_IPV6_TOO_FEW_PARTS)
+  }
 }

package/lib/parse.js

@@ -1,3 +1,4 @@
+const tr46 = require('tr46')
 const constants = require('./constants')
 const errors = require('./errors')
 const infra = require('./infra')
@@ -118,7 +119,7 @@ module.exports = function parse (
           pointer--
         } else {
           state = constants.STATE_FILE
-          pointer++
+          pointer--
         }
         break
 
@@ -440,16 +441,16 @@ module.exports = function parse (
           if (isDoubleDotPathSegment(buffer)) {
             shortenPath(url)
 
-            if (c !== 0x2f && !isSpecial(url) && c === 0x5c) {
+            if (c !== 0x2f && !(isSpecial(url) && c === 0x5c)) {
               url.path.push('')
             }
           } else if (isSingleDotPathSegment(buffer)) {
-            if (c !== 0x2f && !isSpecial(url) && c === 0x5c) {
+            if (c !== 0x2f && !(isSpecial(url) && c === 0x5c)) {
               url.path.push('')
             }
           } else {
             if (url.scheme === 'file' && url.path.length === 0 && isWindowsDriveLetter(buffer)) {
-              buffer[1] = ':'
+              buffer = buffer.substring(0, 1) + ':' + buffer.substring(2)
             }
 
             url.path.push(buffer)
@@ -512,9 +513,241 @@ module.exports = function parse (
   return url
 }
 
-// https://url.spec.whatwg.org/#host-parsing
-function parseHost (host, isNotSpecial) {
-  return host
+// https://url.spec.whatwg.org/#concept-host-parser
+function parseHost (input, isOpaque = false) {
+  if (input.charCodeAt(0) === 0x5b) {
+    if (input.charCodeAt(input.length - 1) !== 0x5d) throw errors.IPV6_UNCLOSED()
+
+    return parseIPv6(input.substring(1, input.length - 1))
+  }
+
+  if (isOpaque) return parseOpaqueHost(input)
+
+  const domain = percentDecode(Buffer.from(input, 'utf8'))
+
+  const asciiDomain = domainToASCII(domain.toString('utf8'), false)
+
+  for (const codePoint of asciiDomain) {
+    if (isForbiddenDomainCodePoint(codePoint.codePointAt(0))) {
+      throw errors.DOMAIN_INVALID_CODE_POINT()
+    }
+  }
+
+  if (endsInANumber(asciiDomain)) return parseIPv4(asciiDomain)
+
+  return asciiDomain
+}
+
+// https://url.spec.whatwg.org/#ends-in-a-number-checker
+function endsInANumber (input) {
+  const parts = input.split('.')
+
+  const last = parts[parts.length - 1]
+
+  if (last === '') {
+    if (parts.length === 1) return false
+    parts.pop()
+  }
+
+  try {
+    parseIPv4Number(last)
+
+    return true
+  } catch {
+    return false
+  }
+}
+
+// https://url.spec.whatwg.org/#concept-ipv4-parser
+function parseIPv4 (input) {
+  const parts = input.split('.')
+
+  if (parts[parts.length - 1] === '') {
+    if (parts.length > 1) parts.pop()
+  }
+
+  if (parts.length > 4) throw errors.IPV4_TOO_MANY_PARTS()
+
+  const numbers = []
+
+  for (const part of parts) {
+    numbers.push(parseIPv4Number(part))
+  }
+
+  for (let i = 0, n = numbers.length - 1; i < n; i++) {
+    if (numbers[i] > 255) {
+      throw errors.IPV4_OUT_OF_RANGE_PART()
+    }
+  }
+
+  if (numbers[numbers.length - 1] > 256 ** (5 - numbers.length)) {
+    throw errors.IPV4_OUT_OF_RANGE_PART()
+  }
+
+  let ipv4 = numbers.pop()
+  let counter = 0
+
+  for (const n of numbers) ipv4 += n * 256 ** (3 - counter++)
+
+  return ipv4
+}
+
+// https://url.spec.whatwg.org/#ipv4-number-parser
+function parseIPv4Number (input) {
+  if (input === '') throw errors.IPV4_NON_NUMERIC_PART()
+
+  input = input.toLowerCase()
+
+  let R = 10
+
+  if (input.length >= 2) {
+    if (input[0] === '0') {
+      if (input[1] === 'x') {
+        input.substring(2)
+        R = 16
+      } else {
+        input.substring(1)
+        R = 8
+      }
+    }
+  }
+
+  if (input === '') return 0
+
+  const n = parseInt(input, R)
+
+  if (n.toString(R) !== input) throw errors.IPV4_NON_NUMERIC_PART()
+
+  return n
+}
+
+// https://url.spec.whatwg.org/#concept-ipv6-parser
+function parseIPv6 (input) {
+  const address = [0, 0, 0, 0, 0, 0, 0, 0]
+  let pieceIndex = 0
+  let compress = null
+  let pointer = 0
+
+  if (input.charCodeAt(pointer) === 0x3a) {
+    if (input.charCodeAt(pointer + 1) !== 0x3a) {
+      throw errors.IPV6_INVALID_COMPRESSION()
+    }
+
+    pointer += 2
+    compress = ++pieceIndex
+  }
+
+  while (pointer < input.length) {
+    if (pieceIndex === 8) throw errors.IPV6_TOO_MANY_PIECES()
+
+    if (input.charCodeAt(pointer) === 0x3a) {
+      if (compress !== null) throw errors.IPV6_MULTIPLE_COMPRESSION()
+
+      pointer++
+      compress = ++pieceIndex
+      continue
+    }
+
+    let value = 0
+    let length = 0
+
+    while (length < 4 && infra.isASCIIHexDigit(input.charCodeAt(pointer))) {
+      value = value * 0x10 + parseInt(input[pointer], 16)
+
+      pointer++
+      length++
+    }
+
+    if (input.charCodeAt(pointer) === 0x2e) {
+      if (length === 0) throw errors.IPV4_IN_IPV6_INVALID_CODE_POINT()
+
+      pointer -= length
+
+      if (pieceIndex > 6) throw errors.IPV4_IN_IPV6_TOO_MANY_PIECES()
+
+      let numbersSeen = 0
+
+      while (pointer < input.length) {
+        let ipv4Piece = null
+
+        if (numbersSeen > 0) {
+          if (input.charCodeAt(pointer) === 0x2e && numbersSeen < 4) {
+            pointer++
+          } else {
+            throw errors.IPV4_IN_IPV6_INVALID_CODE_POINT()
+          }
+        }
+
+        if (!infra.isASCIIDigit(input.charCodeAt(pointer))) {
+          throw errors.IPV4_IN_IPV6_INVALID_CODE_POINT()
+        }
+
+        while (infra.isASCIIDigit(input.charCodeAt(pointer))) {
+          const number = parseInt(input[pointer], 10)
+
+          if (ipv4Piece === null) {
+            ipv4Piece = number
+          } else if (ipv4Piece === 0) {
+            throw errors.IPV4_IN_IPV6_INVALID_CODE_POINT()
+          } else {
+            ipv4Piece = ipv4Piece * 10 + number
+          }
+
+          if (ipv4Piece > 255) throw errors.IPV4_IN_IPV6_OUT_OF_RANGE_PART()
+
+          pointer++
+        }
+
+        address[pieceIndex] = address[pieceIndex] * 0x100 + ipv4Piece
+
+        numbersSeen++
+
+        if (numbersSeen === 2 || numbersSeen === 4) pieceIndex++
+      }
+
+      if (numbersSeen !== 4) throw errors.IPV4_IN_IPV6_TOO_FEW_PARTS()
+
+      break
+    }
+
+    if (input.charCodeAt(pointer) === 0x3a) {
+      pointer++
+
+      if (pointer === input.length) {
+        throw errors.IPV6_INVALID_CODE_POINT()
+      }
+    } else if (pointer !== input.length) {
+      throw errors.IPV6_INVALID_CODE_POINT()
+    }
+
+    address[pieceIndex++] = value
+  }
+
+  if (compress !== null) {
+    let swaps = pieceIndex - compress
+
+    pieceIndex = 7
+
+    while (pieceIndex !== 0 && swaps > 0) {
+      [address[pieceIndex], address[compress + swaps - 1]] = [address[compress + swaps - 1], address[pieceIndex]]
+
+      pieceIndex--
+      swaps--
+    }
+  } else if (pieceIndex !== 8) {
+    throw errors.IPV6_TOO_FEW_PIECES()
+  }
+
+  return address
+}
+
+// https://url.spec.whatwg.org/#concept-opaque-host-parser
+function parseOpaqueHost (input) {
+  const bytes = Buffer.from(input, 'utf8')
+
+  if (bytes.some(isForbiddenHostCodePoint)) throw errors.HOST_INVALID_CODE_POINT()
+
+  return percentEncodeAfterEncoding(bytes, c0ControlPercentEncodeSet)
 }
 
 // https://url.spec.whatwg.org/#special-scheme
@@ -605,6 +838,31 @@ function isDoubleDotPathSegment (segment) {
   return segment === '..' || decodeURIComponent(segment) === '..'
 }
 
+// https://url.spec.whatwg.org/#forbidden-host-code-point
+function isForbiddenHostCodePoint (c) {
+  return c === 0x0 || c === 0x9 || c === 0xa || c === 0xd || c === 0x20 || c === 0x23 || c === 0x2f || c === 0x3a || c === 0x3c || c === 0x3e || c === 0x3f || c === 0x40 || c === 0x5b || c === 0x5c || c === 0x5d || c === 0x5e || c === 0x7c
+}
+
+// https://url.spec.whatwg.org/#forbidden-domain-code-point
+function isForbiddenDomainCodePoint (c) {
+  return isForbiddenHostCodePoint(c) || c <= 0x1f || c === 0x25 || c === 0x7f
+}
+
+// https://url.spec.whatwg.org/#concept-domain-to-ascii
+function domainToASCII (domain, beStrict) {
+  const result = tr46.toASCII(domain, {
+    checkHyphens: false,
+    checkBidi: true,
+    checkJoiners: true,
+    useSTD3ASCIIRules: beStrict,
+    verifyDNSLength: beStrict
+  })
+
+  if (result === null || result === '') throw errors.DOMAIN_TO_ASCII()
+
+  return result
+}
+
 // https://url.spec.whatwg.org/#percent-encode
 function percentEncode (byte) {
   return `%${byte.toString(16).toUpperCase().padStart(2, '0')}`
@@ -625,6 +883,28 @@ function percentEncodeAfterEncoding (bytes, percentEncodeSet) {
   return output
 }
 
+// https://url.spec.whatwg.org/#percent-decode
+function percentDecode (input) {
+  const output = Buffer.alloc(input.byteLength)
+  let outputIndex = 0
+
+  for (let i = 0, n = input.byteLength; i < n; i++) {
+    const byte = input[i]
+
+    if (byte !== 0x25) {
+      output[outputIndex++] = byte
+    } else if (byte === 0x25 && (!infra.isASCIIHexDigit(input[i + 1]) || !infra.isASCIIHexDigit(input[i + 2]))) {
+      output[outputIndex++] = byte
+    } else {
+      const bytePoint = parseInt(String.fromCodePoint(input[i + 1], input[i + 2]), 16)
+      output[outputIndex++] = bytePoint
+      i += 2
+    }
+  }
+
+  return output.subarray(0, outputIndex)
+}
+
 // https://url.spec.whatwg.org/#string-utf-8-percent-encode
 function UTF8PercentEncode (input, percentEncodeSet) {
   return percentEncodeAfterEncoding(Buffer.from(input, 'utf8'), percentEncodeSet)

package/lib/serialize.js

@@ -1,5 +1,5 @@
 // https://url.spec.whatwg.org/#url-serializing
-module.exports = function serialize (url, excludeFragment = false) {
+module.exports = exports = function serialize (url, excludeFragment = false) {
   let output = url.scheme + ':'
 
   if (url.host !== null) {
@@ -15,7 +15,7 @@ module.exports = function serialize (url, excludeFragment = false) {
       output += '@'
     }
 
-    output += url.host
+    output += serializeHost(url.host)
 
     if (url.port !== null) {
       output += ':' + url.port.toString(10)
@@ -47,3 +47,52 @@ module.exports = function serialize (url, excludeFragment = false) {
 
   return output
 }
+
+// https://url.spec.whatwg.org/#concept-host-serializer
+const serializeHost = exports.host = function serializeHost (host) {
+  if (typeof host === 'number') return serializeIPv4(host)
+  if (typeof host !== 'string') return '[' + serializeIPv6(host) + ']'
+
+  return host
+}
+
+// https://url.spec.whatwg.org/#concept-ipv4-serializer
+function serializeIPv4 (address) {
+  let output = ''
+  let n = address
+
+  for (let i = 1; i <= 4; i++) {
+    output = (n % 256).toString(10) + output
+
+    if (i !== 4) output = '.' + output
+
+    n = n / 256 | 0
+  }
+
+  return output
+}
+
+// https://url.spec.whatwg.org/#concept-ipv6-serializer
+function serializeIPv6 (address) {
+  let output = ''
+  const compress = 8 // TODO Find first longest 0 sequence
+  let ignore0 = false
+
+  for (let pieceIndex = 0; pieceIndex <= 7; pieceIndex++) {
+    if (ignore0 && address[pieceIndex] === 0) continue
+
+    ignore0 = false
+
+    if (compress === pieceIndex) {
+      output += pieceIndex === 0 ? '::' : ':'
+      ignore0 = true
+      continue
+    }
+
+    output += address[pieceIndex].toString(16)
+
+    if (pieceIndex !== 7) output += ':'
+  }
+
+  return output
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-url",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "URL parser for JavaScript",
   "main": "index.js",
   "files": [
@@ -22,7 +22,8 @@
   "homepage": "https://github.com/holepunchto/bare-url",
   "dependencies": {
     "bare-os": "^2.0.0",
-    "bare-path": "^2.0.0"
+    "bare-path": "^2.0.0",
+    "tr46": "^5.0.0"
   },
   "devDependencies": {
     "brittle": "^3.3.2",