 						case .throttled:
 							return .throttled(value)
 						case .resumed:
-							schedulerDisposable.innerDisposable = scheduler.schedule {
-								observer.action(event)
-							}
+							eventToSend = event
 							return state
 						case .terminated:
 							return state
 						}
 
 					case .completed, .interrupted, .failed:
-						schedulerDisposable.innerDisposable = scheduler.schedule {
-							observer.action(event)
-						}
+						eventToSend = event
 						return .terminated
+					}
+				}
+
+				if let event = eventToSend {
+					schedulerDisposable.innerDisposable = scheduler.schedule {
+						observer.action(event)
 					}
 				}
 			}

							return .throttled(nil)
						} else {
							if case let .throttled(value?) = state {
								schedulerDisposable.innerDisposable = scheduler.schedule {
									observer.send(value: value)
								}
							}
							return .resumed
						}
					}
				}

			disposable += self.observe { event in
				state.modify { state -> ThrottleWhileState<Value> in
					switch event {
					case let .value(value):

			disposable += shouldThrottle.producer
				.skipRepeats()
				.startWithValues { shouldThrottle in
					var valueToSend: Value?

					state.modify { state -> ThrottleWhileState<Value> in
						guard !state.isTerminated else { return state }

