bare-url 0.0.0 → 0.1.1

package/README.md

@@ -1,14 +1,14 @@
 # bare-url
 
-URL parser for Javascript
+URL parser for JavaScript.
 
 ```
-npm install bare-url
+npm i bare-url
 ```
 
 ## Usage
 
-``` js
+```js
 const url = require('bare-url')
 
 const p = url.fileURLToPath('file:///foo') // --> /foo

package/index.js

@@ -1,8 +1,222 @@
 const path = require('path')
+const constants = require('./lib/constants')
+const errors = require('./lib/errors')
+const parse = require('./lib/parse')
+const serialize = require('./lib/serialize')
 
-exports.fileURLToPath = fileURLToPath
+const URL = exports.URL = class URL {
+  constructor (href, base) {
+    if (typeof base === 'string') {
+      try {
+        base = new URL(base)
+      } catch (err) {
+        err.message = 'Invalid base URL'
+        throw err
+      }
+    }
 
-function fileURLToPath (u) {
-  if (u.startsWith('file://')) u = u.slice(7)
-  return path.normalize(u)
+    this._url = parse(href, base ? base._url : null)
+  }
+
+  // https://url.spec.whatwg.org/#dom-url-href
+
+  get href () {
+    return serialize(this._url)
+  }
+
+  set href (value) {
+    this._url = parse(value)
+  }
+
+  // https://url.spec.whatwg.org/#dom-url-protocol
+
+  get protocol () {
+    return `${this._url.scheme}:`
+  }
+
+  set protocol (value) {
+    parse(`${value}:`, null, this._url, constants.STATE_SCHEME_START)
+  }
+
+  // https://url.spec.whatwg.org/#dom-url-username
+
+  get username () {
+    return this._url.username
+  }
+
+  set username (value) {
+    if (this._url.host === null || this._url.host === '' || this._url.scheme === 'file') {
+      return
+    }
+
+    this._url.username = encodeURIComponent(value)
+  }
+
+  // https://url.spec.whatwg.org/#dom-url-password
+
+  get password () {
+    return this._url.password
+  }
+
+  set password (value) {
+    if (this._url.host === null || this._url.host === '' || this._url.scheme === 'file') {
+      return
+    }
+
+    this._url.password = encodeURIComponent(value)
+  }
+
+  // https://url.spec.whatwg.org/#dom-url-host
+
+  get host () {
+    if (this._url.host === null) return ''
+    if (this._url.port === null) return this._url.host
+
+    return `${this._url.host}:${this._url.port}`
+  }
+
+  set host (value) {
+    if (typeof this._url.path === 'string') return
+
+    parse(value, null, this._url, constants.STATE_HOST)
+  }
+
+  // https://url.spec.whatwg.org/#dom-url-hostname
+
+  get hostname () {
+    if (this._url.host === null) return ''
+
+    return this._url.host
+  }
+
+  set hostname (value) {
+    if (typeof this._url.path === 'string') return
+
+    parse(value, null, this._url, constants.STATE_HOSTNAME)
+  }
+
+  // https://url.spec.whatwg.org/#dom-url-port
+
+  get port () {
+    if (this._url.port === null) return ''
+
+    return `${this._url.port}`
+  }
+
+  set port (value) {
+    if (this._url.host === null || this._url.host === '' || this._url.scheme === 'file') {
+      return
+    }
+
+    if (value === '') {
+      this._url.port = null
+    } else {
+      parse(value, null, this._url, constants.STATE_PORT)
+    }
+  }
+
+  // https://url.spec.whatwg.org/#dom-url-pathname
+
+  get pathname () {
+    if (typeof this._url.path === 'string') return this._url.path
+
+    let output = ''
+
+    for (const segment of this._url.path) output += `/${segment}`
+
+    return output
+  }
+
+  set pathname (value) {
+    if (typeof this._url.path === 'string') return
+
+    this._url.path = []
+
+    parse(value, null, this._url, constants.STATE_PATH_START)
+  }
+
+  // https://url.spec.whatwg.org/#dom-url-search
+
+  get search () {
+    if (this._url.query === null || this._url.query === '') return ''
+
+    return `?${this._url.query}`
+  }
+
+  set search (value) {
+    if (value === '') {
+      this._url.query = null
+
+      return
+    }
+
+    if (value.charCodeAt(0) === 0x3f) {
+      value = value.substring(1)
+    }
+
+    this._url.query = ''
+
+    parse(value, null, this._url, constants.STATE_QUERY)
+  }
+
+  // https://url.spec.whatwg.org/#dom-url-hash
+
+  get hash () {
+    if (this._url.fragment === null || this._url.fragment === '') return ''
+
+    return `#${this._url.fragment}`
+  }
+
+  set hash (value) {
+    if (value === '') {
+      this._url.fragment = null
+
+      return
+    }
+
+    if (value.charCodeAt(0) === 0x23) {
+      value = value.substring(1)
+    }
+
+    this._url.fragment = ''
+
+    parse(value, null, this._url, constants.STATE_FRAGMENT)
+  }
+
+  [Symbol.for('bare.inspect')] () {
+    return {
+      __proto__: { constructor: URL },
+
+      href: this.href,
+      protocol: this.protocol,
+      username: this.username,
+      password: this.password,
+      host: this.host,
+      hostname: this.hostname,
+      port: this.port,
+      pathname: this.pathname,
+      search: this.search,
+      hash: this.hash
+    }
+  }
+}
+
+exports.fileURLToPath = function fileURLToPath (url) {
+  if (typeof url === 'string') {
+    url = new URL(url)
+  }
+
+  if (url.protocol !== 'file:') {
+    throw errors.INVALID_URL_SCHEME('The URL must use the file: protocol')
+  }
+
+  const pathname = path.normalize(decodeURIComponent(url.pathname))
+
+  if (process.platform === 'win32') {
+    if (url.hostname) return `\\\\${url.hostname}${pathname}`
+
+    return pathname.slice(1)
+  }
+
+  return pathname
 }

package/lib/constants.js

@@ -0,0 +1,25 @@
+module.exports = {
+  // Parser states
+  // https://url.spec.whatwg.org/#url-parsing
+  STATE_SCHEME_START: 1,
+  STATE_SCHEME: 2,
+  STATE_NO_SCHEME: 3,
+  STATE_SPECIAL_RELATIVE_OR_AUTHORITY: 4,
+  STATE_PATH_OR_AUTHORITY: 5,
+  STATE_RELATIVE: 6,
+  STATE_RELATIVE_SLASH: 7,
+  STATE_SPECIAL_AUTHORITY_SLASHES: 8,
+  STATE_SPECIAL_AUTHORITY_IGNORE_SLASHES: 9,
+  STATE_AUTHORITY: 10,
+  STATE_HOST: 11,
+  STATE_HOSTNAME: 12,
+  STATE_PORT: 13,
+  STATE_FILE: 14,
+  STATE_FILE_SLASH: 15,
+  STATE_FILE_HOST: 16,
+  STATE_PATH_START: 17,
+  STATE_PATH: 18,
+  STATE_OPAQUE_PATH: 19,
+  STATE_QUERY: 20,
+  STATE_FRAGMENT: 21
+}

package/lib/errors.js

@@ -0,0 +1,47 @@
+module.exports = class URLError extends Error {
+  constructor (msg, code, fn = URLError) {
+    super(`${code}: ${msg}`)
+    this.code = code
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, fn)
+    }
+  }
+
+  get name () {
+    return 'URLError'
+  }
+
+  static INVALID_URL (msg = 'Invalid URL') {
+    return new URLError(msg, 'INVALID_URL', URLError.INVALID_URL)
+  }
+
+  static INVALID_URL_SCHEME (msg = 'Invalid URL') {
+    return new URLError(msg, 'INVALID_URL_SCHEME', URLError.INVALID_URL_SCHEME)
+  }
+
+  // https://url.spec.whatwg.org/#missing-scheme-non-relative-url
+  static MISSING_SCHEME_NON_RELATIVE_URL (msg = 'Invalid URL') {
+    return new URLError(msg, 'MISSING_SCHEME_NON_RELATIVE_URL', URLError.MISSING_SCHEME_NON_RELATIVE_URL)
+  }
+
+  // https://url.spec.whatwg.org/#invalid-credentials
+  static INVALID_CREDENTIALS (msg = 'Invalid URL') {
+    return new URLError(msg, 'INVALID_CREDENTIALS', URLError.INVALID_CREDENTIALS)
+  }
+
+  // https://url.spec.whatwg.org/#host-missing
+  static HOST_MISSING (msg = 'Invalid URL') {
+    return new URLError(msg, 'HOST_MISSING', URLError.HOST_MISSING)
+  }
+
+  // https://url.spec.whatwg.org/#port-out-of-range
+  static PORT_OUT_OF_RANGE (msg = 'Invalid URL') {
+    return new URLError(msg, 'PORT_OUT_OF_RANGE', URLError.PORT_OUT_OF_RANGE)
+  }
+
+  // https://url.spec.whatwg.org/#port-invalid
+  static PORT_INVALID (msg = 'Invalid URL') {
+    return new URLError(msg, 'PORT_INVALID', URLError.PORT_INVALID)
+  }
+}

package/lib/infra.js

@@ -0,0 +1,39 @@
+// https://infra.spec.whatwg.org/#ascii-digit
+exports.isASCIIDigit = function isASCIIDigit (c) {
+  return c >= 0x30 && c <= 0x39
+}
+
+// https://infra.spec.whatwg.org/#ascii-upper-hex-digit
+exports.isASCIIUpperHexDigit = function isASCIIUpperHexDigit (c) {
+  return exports.isASCIIDigit(c) || (c >= 0x41 && c <= 0x46)
+}
+
+// https://infra.spec.whatwg.org/#ascii-lower-hex-digit
+exports.isASCIILowerHexDigit = function isASCIILowerHexDigit (c) {
+  return exports.isASCIIDigit(c) || (c >= 0x61 && c <= 0x66)
+}
+
+// https://infra.spec.whatwg.org/#ascii-hex-digit
+exports.isASCIIHexDigit = function isASCIIHexDigit (c) {
+  return exports.isASCIIDigit(c) || (c >= 0x41 && c <= 0x46) || (c >= 0x61 && c <= 0x66)
+}
+
+// https://infra.spec.whatwg.org/#ascii-upper-alpha
+exports.isASCIIUpperAlpha = function isASCIIUpperAlpha (c) {
+  return c >= 0x41 && c <= 0x5a
+}
+
+// https://infra.spec.whatwg.org/#ascii-lower-alpha
+exports.isASCIILowerAlpha = function isASCIILowerAlpha (c) {
+  return c >= 0x61 && c <= 0x7a
+}
+
+// https://infra.spec.whatwg.org/#ascii-alpha
+exports.isASCIIAlpha = function isASCIIAlpha (c) {
+  return exports.isASCIIUpperAlpha(c) || exports.isASCIILowerAlpha(c)
+}
+
+// https://infra.spec.whatwg.org/#ascii-alphanumeric
+exports.isASCIIAlphanumeric = function isASCIIAlphanumeric (c) {
+  return exports.isASCIIDigit(c) || exports.isASCIIAlpha(c)
+}

package/lib/parse.js

@@ -0,0 +1,602 @@
+const constants = require('./constants')
+const errors = require('./errors')
+const infra = require('./infra')
+
+// https://url.spec.whatwg.org/#url-parsing
+module.exports = function parse (
+  input,
+  base = null,
+  // https://url.spec.whatwg.org/#url-representation
+  url = {
+    scheme: '',
+    username: '',
+    password: '',
+    host: null,
+    port: null,
+    path: [],
+    query: null,
+    fragment: null
+  },
+  stateOverride = 0
+) {
+  let state = stateOverride || constants.STATE_SCHEME_START
+  let buffer = ''
+  let atSignSeen = false
+  let insideBrackets = false
+  let passwordTokenSeen = false
+
+  for (let pointer = 0; pointer <= input.length; pointer++) {
+    const c = pointer < input.length ? input.charCodeAt(pointer) : -1
+
+    switch (state) {
+      // https://url.spec.whatwg.org/#scheme-start-state
+      case constants.STATE_SCHEME_START:
+        if (infra.isASCIIAlpha(c)) {
+          buffer += String.fromCharCode(c).toLowerCase()
+          state = constants.STATE_SCHEME
+        } else if (!stateOverride) {
+          state = constants.STATE_NO_SCHEME
+          pointer--
+        } else {
+          throw errors.INVALID_URL()
+        }
+        break
+
+      // https://url.spec.whatwg.org/#scheme-state
+      case constants.STATE_SCHEME:
+        if (infra.isASCIIAlphanumeric(c) || c === 0x2b || c === 0x2d || c === 0x2e) {
+          buffer += String.fromCharCode(c).toLowerCase()
+        } else if (c === 0x3a) {
+          if (stateOverride) {
+            if (isSpecialScheme(url.scheme) && !isSpecialScheme(buffer)) {
+              return
+            }
+
+            if (!isSpecialScheme(url.scheme) && isSpecialScheme(buffer)) {
+              return
+            }
+
+            if ((includesCredentials(url) || url.port !== null) && buffer === 'file') {
+              return
+            }
+
+            if (url.scheme === 'file' && url.host === '') {
+              return
+            }
+          }
+
+          url.scheme = buffer
+
+          if (stateOverride) {
+            if (url.port === defaultPort(url.scheme)) {
+              url.port = null
+            }
+
+            return
+          }
+
+          buffer = ''
+
+          if (url.scheme === 'file') {
+            state = constants.STATE_FILE
+          } else if (isSpecial(url)) {
+            if (base && base.scheme === url.scheme) {
+              state = constants.STATE_SPECIAL_RELATIVE_OR_AUTHORITY
+            } else {
+              state = constants.STATE_SPECIAL_AUTHORITY_SLASHES
+            }
+          } else if (input.charCodeAt(pointer + 1) === 0x2f) {
+            state = constants.STATE_PATH_OR_AUTHORITY
+            pointer++
+          } else {
+            url.path = ''
+            state = constants.STATE_OPAQUE_PATH
+          }
+        } else if (!stateOverride) {
+          buffer = ''
+          state = constants.STATE_NO_SCHEME
+          pointer = 0
+        } else {
+          throw errors.INVALID_URL()
+        }
+        break
+
+      // https://url.spec.whatwg.org/#no-scheme-state
+      case constants.STATE_NO_SCHEME:
+        if (base === null || (hasOpaquePath(base) && c !== 0x23)) {
+          throw errors.MISSING_SCHEME_NON_RELATIVE_URL()
+        }
+
+        if (hasOpaquePath(base) && c === 0x23) {
+          url.scheme = base.scheme
+          url.path = base.path
+          url.query = base.query
+          url.fragment = ''
+          state = constants.STATE_FRAGMENT
+        } else if (base.sceheme !== 'file') {
+          state = constants.STATE_RELATIVE
+          pointer--
+        } else {
+          state = constants.STATE_FILE
+          pointer++
+        }
+        break
+
+      // https://url.spec.whatwg.org/#special-relative-or-authority-state
+      case constants.STATE_SPECIAL_RELATIVE_OR_AUTHORITY:
+        if (c === 0x2f && input.charCodeAt(pointer + 1) === 0x2f) {
+          state = constants.STATE_SPECIAL_AUTHORITY_IGNORE_SLASHES
+          pointer++
+        } else {
+          state = constants.STATE_RELATIVE
+          pointer--
+        }
+        break
+
+      // https://url.spec.whatwg.org/#path-or-authority-state
+      case constants.STATE_PATH_OR_AUTHORITY:
+        if (c === 0x2f) {
+          state = constants.STATE_AUTHORITY
+        } else {
+          state = constants.STATE_PATH
+          pointer--
+        }
+        break
+
+      // https://url.spec.whatwg.org/#relative-state
+      case constants.STATE_RELATIVE:
+        url.scheme = base.scheme
+
+        if (c === 0x2f) {
+          state = constants.STATE_RELATIVE_SLASH
+        } else if (isSpecial(url) && c === 0x5c) {
+          state = constants.STATE_RELATIVE_SLASH
+        } else {
+          url.username = base.username
+          url.password = base.password
+          url.host = base.host
+          url.port = base.port
+          url.path = [...base.path]
+          url.query = base.query
+
+          if (c === 0x3f) {
+            url.query = ''
+            state = constants.STATE_QUERY
+          } else if (c === 0x23) {
+            url.fragment = ''
+            state = constants.STATE_FRAGMENT
+          } else if (c !== -1) {
+            url.query = null
+            shortenPath(url)
+            state = constants.STATE_PATH
+            pointer--
+          }
+        }
+        break
+
+      // https://url.spec.whatwg.org/#relative-slash-state
+      case constants.STATE_RELATIVE_SLASH:
+        if (isSpecial(url) && (c === 0x2f || c === 0x5c)) {
+          state = constants.STATE_SPECIAL_AUTHORITY_IGNORE_SLASHES
+        } else if (c === 0x2f) {
+          state = constants.STATE_AUTHORITY
+        } else {
+          url.username = base.username
+          url.password = base.password
+          url.host = base.url
+          url.port = base.port
+          state = constants.STATE_PATH
+          pointer--
+        }
+        break
+
+      // https://url.spec.whatwg.org/#special-authority-slashes-state
+      case constants.STATE_SPECIAL_AUTHORITY_SLASHES:
+        if (c === 0x2f && input.charCodeAt(pointer + 1) === 0x2f) {
+          state = constants.STATE_SPECIAL_AUTHORITY_IGNORE_SLASHES
+          pointer++
+        } else {
+          state = constants.STATE_SPECIAL_AUTHORITY_IGNORE_SLASHES
+          pointer--
+        }
+        break
+
+      // https://url.spec.whatwg.org/#special-authority-ignore-slashes-state
+      case constants.STATE_SPECIAL_AUTHORITY_IGNORE_SLASHES:
+        if (c !== 0x2f || c !== 0x5c) {
+          state = constants.STATE_AUTHORITY
+          pointer--
+        }
+        break
+
+      // https://url.spec.whatwg.org/#authority-state
+      case constants.STATE_AUTHORITY:
+        if (c === 0x40) {
+          if (atSignSeen) buffer = '%40' + buffer
+
+          atSignSeen = true
+
+          for (let i = 0, n = buffer.length; i < n; i++) {
+            const c = buffer.charCodeAt(i)
+
+            if (c === 0x3a && !passwordTokenSeen) {
+              passwordTokenSeen = true
+              continue
+            }
+
+            if (passwordTokenSeen) {
+              url.password += encodeURIComponent(buffer[i])
+            } else {
+              url.username += encodeURIComponent(buffer[i])
+            }
+          }
+
+          buffer = ''
+        } else if (
+          (c === -1 || c === 0x2f || c === 0x3f || c === 0x23) ||
+          (isSpecial(url) && c === 0x5c)
+        ) {
+          if (atSignSeen && buffer === '') {
+            throw errors.INVALID_CREDENTIALS()
+          }
+
+          pointer -= buffer.length + 1
+          buffer = ''
+          state = constants.STATE_HOST
+        } else {
+          buffer += String.fromCharCode(c)
+        }
+        break
+
+      // https://url.spec.whatwg.org/#host-state
+      // https://url.spec.whatwg.org/#hostname-state
+      case constants.STATE_HOST:
+      case constants.STATE_HOSTNAME:
+        if (stateOverride && url.scheme === 'file') {
+          pointer--
+          state = constants.STATE_FILE_HOST
+        } else if (c === 0x3a && !insideBrackets) {
+          if (buffer === '') {
+            throw errors.HOST_MISSING()
+          }
+
+          if (stateOverride === constants.STATE_HOSTNAME) return
+
+          url.host = parseHost(buffer, !isSpecial(url))
+
+          buffer = ''
+          state = constants.STATE_PORT
+        } else if (
+          (c === -1 || c === 0x2f || c === 0x3f || c === 0x23) ||
+          (isSpecial(url) && c === 0x5c)
+        ) {
+          pointer--
+
+          if (isSpecial(url) && buffer === '') {
+            throw errors.HOST_MISSING()
+          }
+
+          if (stateOverride && buffer === '' && (includesCredentials(url) || url.port !== null)) {
+            return
+          }
+
+          url.host = parseHost(buffer, !isSpecial(url))
+
+          buffer = ''
+          state = constants.STATE_PATH_START
+
+          if (stateOverride) return
+        } else {
+          if (c === 0x5b) insideBrackets = true
+          else if (c === 0x5d) insideBrackets = false
+
+          buffer += String.fromCharCode(c)
+        }
+        break
+
+      // https://url.spec.whatwg.org/#port-state
+      case constants.STATE_PORT:
+        if (infra.isASCIIDigit(c)) {
+          buffer += String.fromCharCode(c)
+        } else if (
+          (c === -1 || c === 0x2f || c === 0x3f || c === 0x23) ||
+          (isSpecial(url) && c === 0x5c) ||
+          stateOverride
+        ) {
+          if (buffer) {
+            const port = parseInt(buffer, 10)
+
+            if (port > 2 ** 16 - 1) {
+              throw errors.PORT_OUT_OF_RANGE()
+            }
+
+            url.port = port === defaultPort(url.scheme) ? null : port
+
+            buffer = ''
+          }
+
+          if (stateOverride) return
+
+          state = constants.STATE_PATH_START
+          pointer--
+        } else {
+          throw errors.PORT_INVALID()
+        }
+        break
+
+      // https://url.spec.whatwg.org/#file-state
+      case constants.STATE_FILE:
+        url.scheme = 'file'
+        url.host = ''
+
+        if (c === 0x2f || c === 0x5c) {
+          state = constants.STATE_FILE_SLASH
+        } else if (base && base.scheme === 'file') {
+          url.host = base.host
+          url.path = [...base.path]
+          url.query = base.query
+
+          if (c === 0x3f) {
+            url.query = ''
+            state = constants.STATE_QUERY
+          } else if (c === 0x23) {
+            url.fragment = ''
+            state = constants.STATE_FRAGMENT
+          } else if (c !== -1) {
+            url.query = null
+
+            if (!startsWithWindowsDriveLetter(input.substring(pointer))) {
+              shortenPath(url)
+            } else {
+              url.path = []
+            }
+
+            state = constants.STATE_PATH
+            pointer--
+          }
+        } else {
+          state = constants.STATE_PATH
+          pointer--
+        }
+        break
+
+      // https://url.spec.whatwg.org/#file-slash-state
+      case constants.STATE_FILE_SLASH:
+        if (c === 0x2f || c === 0x5c) {
+          state = constants.STATE_FILE_HOST
+        } else {
+          if (base && base.scheme === 'file') {
+            url.host = base.host
+
+            if (!startsWithWindowsDriveLetter(input.substring(pointer)) && isNormalizedWindowsDriveLetter(base.path[0])) {
+              url.path.push(base.path[0])
+            }
+          }
+
+          state = constants.STATE_PATH
+          pointer--
+        }
+        break
+
+      // https://url.spec.whatwg.org/#file-host-state
+      case constants.STATE_FILE_HOST:
+        if (c === -1 || c === 0x2f || c === 0x5c || c === 0x3f || c === 0x23) {
+          pointer--
+
+          if (!stateOverride && isWindowsDriveLetter(buffer)) {
+            state = constants.STATE_PATH
+          } else if (buffer === '') {
+            url.host = ''
+
+            if (stateOverride) return
+
+            state = constants.STATE_PATH_START
+          } else {
+            let host = parseHost(buffer, !isSpecial(url))
+            if (host === 'localhost') host = ''
+
+            url.host = host
+
+            if (stateOverride) return
+
+            buffer = ''
+            state = constants.STATE_PATH_START
+          }
+        } else {
+          buffer += String.fromCharCode(c)
+        }
+        break
+
+      // https://url.spec.whatwg.org/#path-start-state
+      case constants.STATE_PATH_START:
+        if (isSpecial(url)) {
+          state = constants.STATE_PATH
+
+          if (c !== 0x2f || c !== 0x5c) pointer--
+        } else if (!stateOverride && c === 0x3f) {
+          url.query = ''
+          state = constants.STATE_QUERY
+        } else if (!stateOverride && c === 0x23) {
+          url.fragment = ''
+          state = constants.STATE_FRAGMENT
+        } else if (c !== -1) {
+          state = constants.STATE_PATH
+
+          if (c !== 0x2f) pointer--
+        } else if (stateOverride && url.host === null) {
+          url.path.push('')
+        }
+        break
+
+      // https://url.spec.whatwg.org/#path-state
+      case constants.STATE_PATH:
+        if (
+          (c === -1 || c === 0x2f) ||
+          (isSpecial(url) && c === 0x5c) ||
+          (!stateOverride && (c === 0x3f || c === 0x23))
+        ) {
+          if (isDoubleDotPathSegment(buffer)) {
+            shortenPath(url)
+
+            if (c !== 0x2f || !(isSpecial(url) && c === 0x5c)) {
+              url.path.push('')
+            }
+          } else if (isSingleDotPathSegment(buffer)) {
+            if (c !== 0x2f || !(isSpecial(url) && c === 0x5c)) {
+              url.path.push('')
+            }
+          } else {
+            if (url.scheme === 'file' && url.path.length === 0 && isWindowsDriveLetter(buffer)) {
+              buffer[1] = ':'
+            }
+
+            url.path.push(buffer)
+          }
+
+          buffer = ''
+
+          if (c === 0x3f) {
+            url.query = ''
+            state = constants.STATE_QUERY
+          } else if (c === 0x23) {
+            url.fragment = ''
+            state = constants.STATE_FRAGMENT
+          }
+        } else {
+          buffer += encodeURIComponent(String.fromCharCode(c))
+        }
+        break
+
+      // https://url.spec.whatwg.org/#cannot-be-a-base-url-path-state
+      case constants.STATE_OPAQUE_PATH:
+        if (c === 0x3f) {
+          url.query = ''
+          state = constants.STATE_QUERY
+        } else if (c === 0x23) {
+          url.fragment = ''
+          state = constants.STATE_FRAGMENT
+        } else {
+          if (c !== -1) {
+            url.path += encodeURIComponent(String.fromCharCode(c))
+          }
+        }
+        break
+
+      // https://url.spec.whatwg.org/#query-state
+      case constants.STATE_QUERY:
+        if ((!stateOverride && c === 0x23) || c === -1) {
+          url.query += encodeURI(buffer)
+          buffer = ''
+
+          if (c === 0x23) {
+            url.fragment = ''
+            state = constants.STATE_FRAGMENT
+          }
+        } else if (c !== -1) {
+          buffer += String.fromCharCode(c)
+        }
+        break
+
+      // https://url.spec.whatwg.org/#fragment-state
+      case constants.STATE_FRAGMENT:
+        if (c !== -1) {
+          url.fragment += encodeURI(String.fromCharCode(c))
+        }
+    }
+  }
+
+  return url
+}
+
+// https://url.spec.whatwg.org/#host-parsing
+function parseHost (host, isNotSpecial) {
+  return host
+}
+
+// https://url.spec.whatwg.org/#special-scheme
+function isSpecialScheme (scheme) {
+  switch (scheme) {
+    case 'ftp':
+    case 'file':
+    case 'http':
+    case 'https':
+    case 'ws':
+    case 'wss':
+      return true
+    default:
+      return false
+  }
+}
+
+// https://url.spec.whatwg.org/#default-port
+function defaultPort (scheme) {
+  switch (scheme) {
+    case 'ftp': return 21
+    case 'file': return null
+    case 'http': return 80
+    case 'https': return 443
+    case 'ws': return 80
+    case 'wss': return 443
+    default: return null
+  }
+}
+
+// https://url.spec.whatwg.org/#is-special
+function isSpecial (url) {
+  return isSpecialScheme(url)
+}
+
+// https://url.spec.whatwg.org/#include-credentials
+function includesCredentials (url) {
+  return url.username !== '' && url.password !== ''
+}
+
+// https://url.spec.whatwg.org/#url-opaque-path
+function hasOpaquePath (url) {
+  return typeof url.path === 'string'
+}
+
+// https://url.spec.whatwg.org/#windows-drive-letter
+function isWindowsDriveLetter (input) {
+  return input.length >= 2 && infra.isASCIIAlpha(input.charCodeAt(0)) && (
+    input.charCodeAt(1) === 0x3a ||
+    input.charCodeAt(1) === 0x7c
+  )
+}
+
+// https://url.spec.whatwg.org/#normalized-windows-drive-letter
+function isNormalizedWindowsDriveLetter (input) {
+  return input.length >= 2 && infra.isASCIIAlpha(input.charCodeAt(0)) && input.charCodeAt(1) === 0x3a
+}
+
+// https://url.spec.whatwg.org/#start-with-a-windows-drive-letter
+function startsWithWindowsDriveLetter (input) {
+  return input.length >= 2 && isWindowsDriveLetter(input) && (
+    input.length === 2 ||
+    input.charCodeAt(2) === 0x2f ||
+    input.charCodeAt(2) === 0x5c ||
+    input.charCodeAt(2) === 0x3f ||
+    input.charCodeAt(2) === 0x23
+  )
+}
+
+// https://url.spec.whatwg.org/#shorten-a-urls-path
+function shortenPath (url) {
+  const path = url.path
+
+  if (url.scheme === 'file' && path.length === 1 && isNormalizedWindowsDriveLetter(path[0])) {
+    return
+  }
+
+  path.pop()
+}
+
+// https://url.spec.whatwg.org/#single-dot-path-segment
+function isSingleDotPathSegment (segment) {
+  return segment === '.' || decodeURIComponent(segment) === '.'
+}
+
+// https://url.spec.whatwg.org/#double-dot-path-segment
+function isDoubleDotPathSegment (segment) {
+  return segment === '..' || decodeURIComponent(segment) === '..'
+}

package/lib/serialize.js

@@ -0,0 +1,49 @@
+// https://url.spec.whatwg.org/#url-serializing
+module.exports = function serialize (url, excludeFragment = false) {
+  let output = url.scheme + ':'
+
+  if (url.host) {
+    output += '//'
+
+    if (url.username !== '' || url.password !== '') {
+      output += url.username
+
+      if (url.password !== '') {
+        output += ':' + url.password
+      }
+
+      output += '@'
+    }
+
+    output += url.host
+
+    if (url.port !== null) {
+      output += ':' + url.port.toString(10)
+    }
+  }
+
+  if (
+    url.host === null &&
+    typeof url.path !== 'string' &&
+    url.path.length > 1 &&
+    url.path[0] === ''
+  ) {
+    output += '/.'
+  }
+
+  if (typeof url.path === 'string') {
+    output += url.path
+  } else {
+    output += '/' + url.path.join('/')
+  }
+
+  if (url.query !== null) {
+    output += '?' + url.query
+  }
+
+  if (url.fragment !== null && !excludeFragment) {
+    output += '#' + url.fragment
+  }
+
+  return output
+}

package/package.json

@@ -1,23 +1,27 @@
 {
   "name": "bare-url",
-  "version": "0.0.0",
-  "description": "URL parser for Javascript",
+  "version": "0.1.1",
+  "description": "URL parser for JavaScript",
   "main": "index.js",
+  "files": [
+    "index.js",
+    "lib"
+  ],
   "scripts": {
-    "test": "standard && brittle test.js"
-  },
-  "devDependencies": {
-    "standard": "^17.1.0",
-    "brittle": "^3.3.2"
+    "test": "standard && bare test.js"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/holepunchto/bare-url.git"
+    "url": "git+https://github.com/holepunchto/bare-url.git"
   },
   "author": "Holepunch",
   "license": "Apache-2.0",
   "bugs": {
     "url": "https://github.com/holepunchto/bare-url/issues"
   },
-  "homepage": "https://github.com/holepunchto/bare-url"
+  "homepage": "https://github.com/holepunchto/bare-url",
+  "devDependencies": {
+    "brittle": "^3.3.2",
+    "standard": "^17.1.0"
+  }
 }

package/.github/workflows/ci.yml

@@ -1,23 +0,0 @@
-name: Build Status
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
-jobs:
-  build:
-    strategy:
-      matrix:
-        node-version: [lts/*]
-        os: [ubuntu-latest, macos-latest, windows-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - uses: actions/checkout@v2
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v2
-      with:
-        node-version: ${{ matrix.node-version }}
-    - run: npm install
-    - run: npm test

package/NOTICE

@@ -1,13 +0,0 @@
-Copyright 2023 Holepunch Inc
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

package/test.js

@@ -1,6 +0,0 @@
-const test = require('brittle')
-const url = require('./')
-
-test('fileURLToPath', function (t) {
-  t.is(url.fileURLToPath('file:///foo/bar'), process.platform === 'win32' ? '\\foo\\bar' : '/foo/bar')
-})