 							return .throttled(nil)
 						} else {
 							if case let .throttled(value?) = state {
-								schedulerDisposable.innerDisposable = scheduler.schedule {
-									observer.send(value: value)
-								}
+								valueToSend = value
 							}
 							return .resumed
 						}
 					}
+
+					if let value = valueToSend {
+						schedulerDisposable.innerDisposable = scheduler.schedule {
+							observer.send(value: value)
+						}
+					}
 				}
 
 			disposable += self.observe { event in
+				var eventToSend: Event<Value, Error>?
+
 				state.modify { state -> ThrottleWhileState<Value> in
 					switch event {
 					case let .value(value):

			disposable += shouldThrottle.producer
				.skipRepeats()
				.startWithValues { shouldThrottle in
					state.modify { state -> ThrottleWhileState<Value> in
						guard !state.isTerminated else { return state }


						case .throttled:
							return .throttled(value)
						case .resumed:
							eventToSend = event
							return state
						case .terminated:
							return state
						}

					case .completed, .interrupted, .failed:
						eventToSend = event
						return .terminated
					}
				}

				if let event = eventToSend {
					schedulerDisposable.innerDisposable = scheduler.schedule {
						observer.action(event)
					}
				}
			}
