@Override
    protected Invoker<MavenInvokerRequest<MavenOptions>> createInvoker() {
        return new DefaultLocalMavenInvoker(ProtoLookup.builder()
                .addMapping(ClassWorld.class, new ClassWorld("plexus.core", ClassLoader.getSystemClassLoader()))
                .build());
    }

    @Override
    protected Parser<MavenInvokerRequest<MavenOptions>> createParser() {
        return new DefaultMavenParser();
    }

    val proxyConnectRequest =
      Request.Builder()
        .url(route.address.url)
        .method("CONNECT", null)
        .header("Host", route.address.url.toHostHeader(includeDefaultPort = true))
        .header("Proxy-Connection", "Keep-Alive") // For HTTP/1.0 proxies like Squid.
        .header("User-Agent", USER_AGENT)
        .build()

    val fakeAuthChallengeResponse =
      Response.Builder()

              appendQuotedString(filename)
            }
          }

        val headers =
          Headers.Builder()
            .addUnsafeNonAscii("Content-Disposition", disposition)
            .build()

        return create(headers, body)
      }
    }
  }

  class Builder
    @JvmOverloads
    constructor(boundary: String = UUID.randomUUID().toString()) {

 * its default classifier, and how the artifact will be used in the build when creating
 * class-paths or module-paths.
 * <p>
 * For example, the type {@code java-source} has a {@code jar} extension and a
 * {@code sources} classifier. The artifact and its dependencies should be added
 * to the build path.
 *
 * @since 4.0.0
 */
@Experimental
@Immutable

import org.apache.maven.api.annotations.Nonnull;

import static org.apache.maven.api.ExtensibleEnums.pathScope;

/**
 * Path scope.
 * A path scope is used to determine the kind of build or class path that will be built when resolving
 * dependencies using the {@link org.apache.maven.api.services.DependencyResolver} service.
 * <p>
 * This extensible enum has four defined values, {@link #MAIN_COMPILE}, {@link #MAIN_RUNTIME},

      <artifactId>maven-settings-builder</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.maven</groupId>
      <artifactId>maven-toolchain-model</artifactId>
    </dependency>
    <!-- Used for Javadoc in a deprecated class only -->
    <dependency>
      <groupId>org.apache.maven</groupId>
      <artifactId>maven-toolchain-builder</artifactId>
    </dependency>
    <dependency>

 *     if (myConfig.isInvalid()) {
 *       return Response.Builder()
 *           .request(chain.request())
 *           .protocol(Protocol.HTTP_1_1)
 *           .code(400)
 *           .message("client config invalid")
 *           .body("client config invalid".toResponseBody(null))
 *           .build()
 *     }
 *
 *     return chain.proceed(chain.request())
 *   }
 * ```
 */

    s.defaultReadObject();

    int length = s.readInt();
    ImmutableLongArray.Builder builder = ImmutableLongArray.builder();
    for (int i = 0; i < length; i++) {
      builder.add(doubleToRawLongBits(s.readDouble()));
    }
    this.longs = new AtomicLongArray(builder.build().toArray());
  }

          .put(RowSortedTable.class, Tables.unmodifiableRowSortedTable(TreeBasedTable.create()))
          .put(ClassToInstanceMap.class, ImmutableClassToInstanceMap.builder().build())
          .put(ImmutableClassToInstanceMap.class, ImmutableClassToInstanceMap.builder().build())
          .put(Comparable.class, ByToString.INSTANCE)
          .put(Comparator.class, AlwaysEqual.INSTANCE)
          .put(Ordering.class, AlwaysEqual.INSTANCE)

        this.javadocConverter = javadocConverter;
        this.listener = listener;
    }

    /**
     * Builds the properties of the given class
     */
    void build(ClassDoc classDoc) {
        Element thead = getChild(classDoc.getPropertiesTable(), "thead");
        Element tr = getChild(thead, "tr");
        List<Element> header = children(tr, "td");