constructor(private _mockConfig: MockConfig) {
   if (_mockConfig.elements) {
     this._elements = _mockConfig.elements as FantasyObservable;
   } else {
     this._elements = adapt(xs.empty());
   }
 }

 public elements(): MemoryStream<HTMLBodyElement> {
   const out: DevToolEnabledSource & MemoryStream<HTMLBodyElement> = adapt(
     xs.of(document.body),
   );
   out._isCycleSource = this._name;
   return out;
 }

    return function delayOperator<T>(inputStream: Stream<T>): Stream<T> {
      const stream = xs.fromObservable(inputStream);
      let delayListener: any = null;

      const producer = {
        start(listener: Listener<T>) {
          delayListener = makeDelayListener<T>(
            schedule,
            currentTime,
            delayTime,
            listener
          );

          stream.addListener(delayListener);
        },

        stop() {
          if (delayListener) {
            stream.removeListener(delayListener);
          }
        },
      };

      return adapt(xs.create<T>(producer));
    };

  public events(eventType: string, options?: EventsFnOptions): any {
    const streamForEventType = this._mockConfig[eventType] as any;
    const out: DevToolEnabledSource & FantasyObservable = adapt(streamForEventType || xs.empty());

    out._isCycleSource = 'MockedDOM';

    return out;
  }

 public element(): any {
   const output$: MemoryStream<Element> = this.elements()
     .filter((arr: Array<any>) => arr.length > 0)
     .map((arr: Array<any>) => arr[0])
     .remember();
   const out: DevToolEnabledSource & MemoryStream<Element> = adapt(output$);
   out._isCycleSource = 'MockedDOM';
   return out;
 }

    animationFrames: () => {
      const s = timeSource.periodic(16);

      if ('pipe' in s) {
        // This hack brought to you by the need to import rxjs's operators
        // and my desire to not force a dependency on rxjs
        return adapt(xs.fromObservable<number>(s).map(frame));
      }

      return s.map(frame);
    },

 public events(eventType: string, options: EventsFnOptions = {}): Stream<Event> {
   let stream: Stream<Event>;
   if (options && typeof options.useCapture === 'boolean') {
     stream = fromEvent(document, eventType, options.useCapture);
   } else {
     stream = fromEvent(document, eventType);
   }
   const out: DevToolEnabledSource & Stream<Event> = adapt(stream);
   out._isCycleSource = this._name;
   return out;
 }

 public isolateSink(sink: any, scope: string): any {
   return adapt(
     xs.fromObservable<any>(sink).map((vnode: VNode) => {
       if (vnode.sel && vnode.sel.indexOf(SCOPE_PREFIX + scope) !== -1) {
         return vnode;
       } else {
         vnode.sel += `.${SCOPE_PREFIX}${scope}`;
         return vnode;
       }
     })
   );
 }

function requestInputToResponse$(reqInput: RequestInput): ResponseMemoryStream {
  let response$ = createResponse$(reqInput).remember();
  const reqOptions = softNormalizeRequestInput(reqInput);
  if (!reqOptions.lazy) {
    response$.addListener({next: () => {}, error: () => {}, complete: () => {}});
  }
  response$ = adapt(response$);
  Object.defineProperty(response$, 'request', {
    value: reqOptions,
    writable: false,
  });
  return response$ as ResponseMemoryStream;
};