function parseUrl(urlStr) {
    const [scheme, addressWithQuery] = extractScheme(urlStr)
    const [queryParameters, address] = extractQuery(addressWithQuery)
    const [authority, segments]      = extractSegments(address)
    return [scheme, authority, segments, queryParameters]
}

function extractScheme(urlStr) {
    let parts = urlStr.split("://")
    if (parts.length != 2)
        throw "URL is invalid"
    validateScheme(parts[0])
    return parts
}

function validateScheme(scheme) {
    if (validSchemes.includes(scheme))
        return
    else
        throw `${scheme} is not a valid URL scheme`
}

function extractQuery(addressWithQuery) {
    let parts = urlStr.split("?")
    switch (parts.length) {
        case 1:  return [{}, parts[0]]
        case 2:  return [extractQueryParameters(parts[1]), parts[0]]
        default: throw "URL is invalid"
    }
}

function extractQueryParameters(parametersStr) {
    let parametersStr = parametersStr.split("&")
    let parameters = {}
    for (parameterStr of parametersStr) {
        const [key, value] = parseQueryParameter(parameterStr)
        parameters[key] = value
    }
    return parameters
}

function parseQueryParameter(parameterStr) {
    let keyValue = parameterStr.split("=")
    switch (keyValue.length) {
        case 1:  return [keyValue[0], null]
        case 2:  return keyValue
        default: throw "URL is invalid"
    }
}

function extractSegments(address) {
    let [authority, ...segments] = address.split("/")
    validateAuthority(authority)
    for (segment of segments)
        validateSegment(segment)
    return [authority, segments]
}

function validateAuthority(authority) {
    // put authority validation here
    return
}

function validateSegment(segment) {
    // put segment validation here
    return
}

const validSchemes = ["http", "https", "ftp", "sftp"] // etc.