bind(SessionScope.class).toInstance(scope);

        bind(MavenSession.class)
                .toProvider(SessionScope.seededKeyProvider(MavenSession.class))
                .in(scope);
        bind(Session.class)
                .toProvider(SessionScope.seededKeyProvider(Session.class))
                .in(scope);
        bind(InternalMavenSession.class)

        return project.getConfigurations().detachedConfiguration(
                dependencies.create("javax.xml.bind:jaxb-api:2.3.0"),
                dependencies.create("com.sun.xml.bind:jaxb-core:2.3.0.1"),
                dependencies.create("com.sun.xml.bind:jaxb-impl:2.3.0.1"),
                dependencies.create("javax.activation:activation:1.1.1")
        );
    }

                                .distinct()
                                .collect(Collectors.joining("\n - ", " - ", "")));
            }
        };
        injector.bindInstance(Injector.class, injector);
        bind(Injector.class).toInstance(injector);
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        if (classLoader == null) {
            classLoader = getClass().getClassLoader();
        }

                .groupId(artifact.getGroupId())
                .artifactId(artifact.getArtifactId())
                .version(artifact.getBaseVersion())
                .build();
    }

    public void bind(Artifact artifact) {
        artifacts.add(artifact);
    }

    public Object getKey() {
        return getGroupId() + ':' + getArtifactId() + ':' + getVersion();
    }

            if (configuration == null) {
                configuration = new XmlNodeImpl("configuration");
            }
            binder.bind(XmlNode.class)
                    .annotatedWith(Names.named(plugin.getKey()))
                    .toInstance(configuration);
            binder.bind(PlexusConfiguration.class)
                    .annotatedWith(Names.named(plugin.getKey()))

    @Inject
    public MojoExecutionScopeCoreModule() {
        super(new MojoExecutionScope());
    }

    @Override
    protected void configure() {
        super.configure();
        bind(MojoExecutionListener.class).toInstance(scope);
    }

    @Override
    public void write ( byte[] b, int off, int len ) throws IOException {
        writeDirect(b, off, len, 0);
    }


    /**
     * Just bypasses TransWaitNamedPipe - used by DCERPC bind.
     * 
     * @param b
     * @param off
     * @param len
     * @param flags
     * @throws IOException
     */
    public void writeDirect ( byte[] b, int off, int len, int flags ) throws IOException {

  @GuardedBy("lock")
  private void endWaitingFor(Guard guard) {
    int waiters = --guard.waiterCount;
    if (waiters == 0) {
      // unlink guard from activeGuards
      for (Guard p = activeGuards, pred = null; ; pred = p, p = p.next) {
        if (p == guard) {
          if (pred == null) {
            activeGuards = p.next;
          } else {

@Target(ElementType.TYPE)
@Inherited
public @interface Mojo {
    /**
     * goal name (required).
     * @return the goal name
     */
    @Nonnull
    String name();

    /**
     * default phase to bind your mojo.
     * @return the default phase
     */
    @Nonnull
    String defaultPhase() default "";

    /**
     * does your mojo requires a project to be executed?
     * @return requires a project
     */

         * clearListeners.
         */
        Runnable task = requireNonNull(curr.task);
        if (task instanceof SetFuture) {
          SetFuture<?> setFuture = (SetFuture<?>) task;
          // We unwind setFuture specifically to avoid StackOverflowErrors in the case of long
          // chains of SetFutures
          // Handling this special case is important because there is no way to pass an executor to