code: public final Mono<T> delayUntil(Function<? super T, ? extends Publisher<?>> triggerProvider) {
  		Objects.requireNonNull(triggerProvider, "triggerProvider required");
  		if (this instanceof MonoDelayUntil) {
  			return ((MonoDelayUntil<T>) this).copyWithNewTriggerGenerator(false,triggerProvider);
  		}
  		return onAssembly(new MonoDelayUntil<>(this, triggerProvider));
  	}
docs: Subscribe to this {@link Mono} and another {@link Publisher} that is generated from
  this Mono's element and which will be used as a trigger for relaying said element.
  <p>
  That is to say, the resulting {@link Mono} delays until this Mono's element is
  emitted, generates a trigger Publisher and then delays again until the trigger
  Publisher terminates.
  <p>
  Note that contiguous calls to all delayUntil are fused together.
  The triggers are generated and subscribed to in sequence, once the previous trigger
  completes. Error is propagated immediately
  downstream. In both cases, an error in the source is immediately propagated.
  <p>
  <img class="marble" src="doc-files/marbles/delayUntilForMono.svg" alt="">
  
  @param triggerProvider a {@link Function} that maps this Mono's value into a
  {@link Publisher} whose termination will trigger relaying the value.
  
  @return this Mono, but delayed until the derived publisher terminates.