@folklore/hooks 0.0.83 → 0.0.85

package/dist/cjs.js

@@ -1,1960 +0,0 @@
-'use strict';
-
-var raf = require('raf');
-var react = require('react');
-var services = require('@folklore/services');
-var createDebug = require('debug');
-var EventsManager = require('@folklore/events');
-var cancelablePromise = require('cancelable-promise');
-var isNumber = require('lodash/isNumber');
-
-function useCounter(desiredValue, {
-  disabled = false,
-  maxDuration = 2000,
-  speed = 1 / 10,
-  initialValue = null
-}) {
-  const [currentValue, setCurrentValue] = react.useState(initialValue !== null ? initialValue : desiredValue);
-  react.useEffect(() => {
-    if (initialValue !== null && !disabled) {
-      setCurrentValue(initialValue);
-    }
-  }, [initialValue, disabled]);
-  react.useEffect(() => {
-    const finalCurrentValue = disabled ? desiredValue : currentValue;
-    let animationFrame = null;
-    let startTime = null;
-    let duration = 0;
-    let canceled = false;
-    const startValue = finalCurrentValue;
-    const delta = desiredValue - startValue;
-    function loop() {
-      if (canceled) {
-        return;
-      }
-      const currentTime = Date.now();
-      const elapsedTime = currentTime - startTime;
-      const progress = Math.min(elapsedTime / duration, 1);
-      const newValue = Math.round(startValue + progress * delta);
-      setCurrentValue(newValue);
-      if (newValue !== desiredValue) {
-        animationFrame = raf(loop);
-      }
-    }
-    if (delta !== 0) {
-      duration = Math.min(maxDuration, Math.abs(delta) * speed * 1000);
-      startTime = Date.now();
-      animationFrame = raf(loop);
-    } else if (disabled) {
-      setCurrentValue(desiredValue);
-    }
-    return () => {
-      canceled = true;
-      if (animationFrame !== null) {
-        raf.cancel(animationFrame);
-      }
-    };
-  }, [desiredValue, disabled, initialValue, maxDuration, speed]);
-  return currentValue;
-}
-
-const NO_PLAYER_ERROR$3 = new Error('No player');
-function useDailymotionPlayer(id = null, params = {}) {
-  const {
-    width = 0,
-    height = 0,
-    duration = 0,
-    muted: providedMuted = false,
-    initialMuted = false,
-    start = 0,
-    embedPlayerId = null,
-    onTimeUpdate: customOnTimeUpdate = null,
-    getVideoId = url => {
-      if (url === null || url.match(/^https?:/) === null) {
-        return url;
-      }
-      let match = url.match(/\/video\/([^/?]+)/);
-      if (match !== null) {
-        return match[1];
-      }
-      match = url.match(/video=([^/?&]+)/);
-      if (match !== null) {
-        return match[1];
-      }
-      return null;
-    }
-  } = params;
-  const debug = react.useMemo(() => createDebug('folklore:video:dailymotion'), []);
-  const [apiLoaded, setApiLoaded] = react.useState(typeof window !== 'undefined' && typeof window.dailymotion !== 'undefined');
-  const [playerReady, setPlayerReady] = react.useState(false);
-  const [loaded, setLoaded] = react.useState(false);
-  const apiRef = react.useRef(typeof window !== 'undefined' && typeof window.dailymotion !== 'undefined' ? window.dailymotion : null);
-  const ready = apiLoaded && playerReady;
-  const videoId = react.useMemo(() => getVideoId(id), [id]);
-  const elementRef = react.useRef(null);
-  const playerRef = react.useRef(null);
-  const playerElementRef = react.useRef(elementRef.current);
-  if (elementRef.current !== null && playerElementRef.current === null) {
-    playerElementRef.current = elementRef.current;
-  }
-  const elementHasChanged = elementRef.current !== playerElementRef.current;
-  const [muted, setMuted] = react.useState(initialMuted || providedMuted);
-  const [volume, setVolumeState] = react.useState(initialMuted || providedMuted ? 0 : 1);
-  const [currentTime, setCurrentTime] = react.useState(0);
-  const [playState, setPlayState] = react.useState({
-    playing: false,
-    paused: false,
-    ended: false,
-    buffering: false,
-    adPlaying: false
-  });
-  const [metadata, setMetadata] = react.useState({
-    width,
-    height,
-    duration
-  });
-
-  // Load SDK
-  react.useEffect(() => {
-    let canceled = false;
-    if (!apiLoaded && videoId !== null) {
-      debug('Load API');
-      services.loadDailymotion({
-        url: embedPlayerId !== null ? `https://geo.dailymotion.com/libs/player/${embedPlayerId}.js` : 'https://geo.dailymotion.com/libs/player.js',
-        callback: null
-      }).then(api => {
-        if (!canceled) {
-          apiRef.current = api;
-          setApiLoaded(true);
-          debug('API Loaded');
-        }
-      });
-    }
-    return () => {
-      canceled = true;
-    };
-  }, [videoId, apiLoaded, setApiLoaded, embedPlayerId]);
-
-  // Create or update player
-  react.useEffect(() => {
-    const {
-      current: dailymotion = null
-    } = apiRef;
-    const {
-      current: currentPlayer = null
-    } = playerRef;
-    const {
-      current: element = null
-    } = elementRef;
-    if (!apiLoaded || videoId === null || element === null) {
-      return;
-    }
-    const playerParams = {
-      startTime: start,
-      aspectRatio: 'inherit'
-    };
-    let player = currentPlayer;
-    if (player !== null) {
-      player.loadContent({
-        video: videoId
-      });
-      debug('Load video [ID: %s]', videoId);
-    } else {
-      element.id = `dailymotion-player-${videoId}-${Date.now()}`;
-      player = dailymotion.createPlayer(element.id, {
-        video: videoId,
-        width,
-        height,
-        params: playerParams
-      }).then(newPlayer => {
-        debug('Player ready [ID: %s]', videoId);
-        setPlayerReady(true);
-        playerRef.current = newPlayer;
-      });
-      debug('Create player [ID: %s]', videoId);
-    }
-    playerElementRef.current = element;
-  }, [apiLoaded, elementHasChanged, videoId, width, height, start]);
-  react.useEffect(() => {
-    const {
-      current: player = null
-    } = playerRef;
-    const {
-      current: dailymotion = null
-    } = apiRef;
-    if (player === null) {
-      return () => {};
-    }
-    let currentPlayState = playState;
-    let currentMetadata = metadata;
-    function onPlaybackReady() {
-      setLoaded(true);
-      debug('onPlaybackReady [ID: %s]', videoId);
-    }
-    function onDurationChange({
-      videoTime,
-      videoDuration
-    }) {
-      currentMetadata = {
-        ...currentMetadata,
-        duration: videoDuration
-      };
-      setMetadata(currentMetadata);
-      setCurrentTime(videoTime);
-      debug('onDurationChange [ID: %s]', videoId);
-    }
-    function onVolumeChange({
-      playerIsMuted,
-      playerVolume,
-      videoTime
-    }) {
-      setMuted(playerIsMuted);
-      setVolumeState(playerVolume);
-      setCurrentTime(videoTime);
-      debug('onVolumeChange [ID: %s]', videoId);
-    }
-    function onPlay({
-      videoTime
-    }) {
-      currentPlayState = {
-        ...currentPlayState,
-        playing: true,
-        paused: false,
-        ended: false
-      };
-      setPlayState(currentPlayState);
-      setCurrentTime(videoTime);
-      debug('onPlay [ID: %s]', videoId);
-    }
-    function onPause({
-      videoTime
-    }) {
-      currentPlayState = {
-        ...currentPlayState,
-        playing: false,
-        paused: true,
-        ended: false
-      };
-      setPlayState(currentPlayState);
-      setCurrentTime(videoTime);
-      debug('onPause [ID: %s]', videoId);
-    }
-    function onEnd({
-      videoTime
-    }) {
-      currentPlayState = {
-        ...currentPlayState,
-        playing: false,
-        paused: false,
-        ended: true
-      };
-      setPlayState(currentPlayState);
-      setCurrentTime(videoTime);
-      debug('onEnd [ID: %s]', videoId);
-    }
-    function onPlaying({
-      videoTime
-    }) {
-      currentPlayState = {
-        ...currentPlayState,
-        buffering: false
-      };
-      setPlayState(currentPlayState);
-      setCurrentTime(videoTime);
-      debug('onPlaying [ID: %s]', videoId);
-    }
-    function onWaiting({
-      videoTime
-    }) {
-      currentPlayState = {
-        ...currentPlayState,
-        buffering: true
-      };
-      setPlayState(currentPlayState);
-      setCurrentTime(videoTime);
-      debug('onWaiting [ID: %s]', videoId);
-    }
-    function onTimeChange({
-      videoTime
-    }) {
-      setCurrentTime(videoTime);
-    }
-    function onAdStart() {
-      currentPlayState = {
-        ...currentPlayState,
-        adPlaying: true
-      };
-      setPlayState(currentPlayState);
-      debug('onAdStart [ID: %s]', videoId);
-    }
-    function onAdEnd() {
-      currentPlayState = {
-        ...currentPlayState,
-        adPlaying: false
-      };
-      setPlayState(currentPlayState);
-      debug('onAdEnd [ID: %s]', videoId);
-    }
-    player.on(dailymotion.events.PLAYER_CRITICALPATHREADY, onPlaybackReady);
-    player.on(dailymotion.events.VIDEO_DURATIONCHANGE, onDurationChange);
-    player.on(dailymotion.events.PLAYER_VOLUMECHANGE, onVolumeChange);
-    player.on(dailymotion.events.VIDEO_PLAY, onPlay);
-    player.on(dailymotion.events.VIDEO_PAUSE, onPause);
-    player.on(dailymotion.events.VIDEO_END, onEnd);
-    player.on(dailymotion.events.VIDEO_PLAYING, onPlaying);
-    player.on(dailymotion.events.VIDEO_BUFFERING, onWaiting);
-    player.on(dailymotion.events.VIDEO_TIMECHANGE, onTimeChange);
-    player.on(dailymotion.events.AD_START, onAdStart);
-    player.on(dailymotion.events.AD_END, onAdEnd);
-    return () => {
-      player.off(dailymotion.events.PLAYER_CRITICALPATHREADY, onPlaybackReady);
-      player.off(dailymotion.events.VIDEO_DURATIONCHANGE, onDurationChange);
-      player.off(dailymotion.events.PLAYER_VOLUMECHANGE, onVolumeChange);
-      player.off(dailymotion.events.VIDEO_PLAY, onPlay);
-      player.off(dailymotion.events.VIDEO_PAUSE, onPause);
-      player.off(dailymotion.events.VIDEO_END, onEnd);
-      player.off(dailymotion.events.VIDEO_PLAYING, onPlaying);
-      player.off(dailymotion.events.VIDEO_BUFFERING, onWaiting);
-      player.off(dailymotion.events.VIDEO_TIMECHANGE, onTimeChange);
-      player.off(dailymotion.events.AD_START, onAdStart);
-      player.off(dailymotion.events.AD_END, onAdEnd);
-    };
-  }, [playerRef.current, playerReady, videoId, setLoaded, setPlayState, setMetadata, setVolumeState, setMuted]);
-  const play = react.useCallback(() => {
-    const {
-      current: player
-    } = playerRef;
-    return player !== null ? player.play() : Promise.reject(NO_PLAYER_ERROR$3);
-  }, []);
-  const pause = react.useCallback(() => {
-    const {
-      current: player
-    } = playerRef;
-    return player !== null ? player.pause() : Promise.reject(NO_PLAYER_ERROR$3);
-  }, []);
-  const setVolume = react.useCallback(newVolume => {
-    const {
-      current: player
-    } = playerRef;
-    return player !== null ? player.setVolume(newVolume) : Promise.reject(NO_PLAYER_ERROR$3);
-  }, []);
-  const mute = react.useCallback(() => {
-    const {
-      current: player
-    } = playerRef;
-    return player !== null ? player.setMute(true) : Promise.reject(NO_PLAYER_ERROR$3);
-  }, []);
-  const unmute = react.useCallback(() => {
-    const {
-      current: player
-    } = playerRef;
-    return player !== null ? player.setMute(false) : Promise.reject(NO_PLAYER_ERROR$3);
-  }, []);
-  const seek = react.useCallback(time => {
-    const {
-      current: player
-    } = playerRef;
-    return player !== null ? player.seek(time) : Promise.reject(NO_PLAYER_ERROR$3);
-  }, []);
-  react.useEffect(() => {
-    if (customOnTimeUpdate !== null) {
-      customOnTimeUpdate(currentTime);
-    }
-  }, [currentTime, customOnTimeUpdate]);
-  return {
-    ref: elementRef,
-    player: playerRef.current,
-    ready,
-    play,
-    pause,
-    mute,
-    unmute,
-    setVolume,
-    seek,
-    currentTime,
-    loaded,
-    muted,
-    volume,
-    ...metadata,
-    ...playState
-  };
-}
-
-const eventsManager$1 = typeof document !== 'undefined' ? new EventsManager(document) : null;
-function useDocumentEvent(event, callback) {
-  react.useEffect(() => {
-    if (eventsManager$1 !== null && callback !== null) {
-      eventsManager$1.subscribe(event, callback);
-    }
-    return () => {
-      if (eventsManager$1 !== null && callback !== null) {
-        eventsManager$1.unsubscribe(event, callback);
-      }
-    };
-  }, [event, callback]);
-}
-
-const observersCache = new Map();
-function getOptionsKey({
-  root = null,
-  rootMargin,
-  threshold = null
-}) {
-  return `root_${root}_rootMargin_${rootMargin || null}_threshold_${threshold}`;
-}
-function createObserver(Observer, options = {}) {
-  let subscribers = [];
-  const addSubscriber = (element, callback) => {
-    const currentSubscriber = subscribers.find(it => it.element === element) || null;
-    if (currentSubscriber !== null) {
-      return subscribers.map(it => it.element === element && it.callbacks.indexOf(callback) === -1 ? {
-        ...it,
-        callbacks: [...it.callbacks, callback]
-      } : it).filter(it => it.callbacks.length > 0);
-    }
-    return [...subscribers, {
-      element,
-      callbacks: [callback]
-    }];
-  };
-  const removeSubscriber = (element, callback) => subscribers.map(it => it.element === element ? {
-    ...it,
-    callbacks: it.callbacks.filter(subCallback => subCallback !== callback)
-  } : it).filter(it => it.callbacks.length > 0);
-  const onUpdate = entries => {
-    entries.forEach(entry => {
-      subscribers.forEach(({
-        element,
-        callbacks
-      }) => {
-        if (element === entry.target) {
-          callbacks.forEach(callback => {
-            callback(entry);
-          });
-        }
-      });
-    });
-  };
-  const observer = new Observer(onUpdate, options);
-  const unsubscribe = (element, callback = null) => {
-    subscribers = removeSubscriber(element, callback);
-    if (typeof observer.unobserve === 'undefined') {
-      observer.disconnect();
-      subscribers.forEach(subscriber => {
-        observer.observe(subscriber.element);
-      });
-      return;
-    }
-    const currentSubscriber = subscribers.find(it => it.element === element) || null;
-    if (currentSubscriber === null) {
-      observer.unobserve(element);
-    }
-  };
-  const subscribe = (element, callback) => {
-    const currentSubscriber = subscribers.find(it => it.element === element) || null;
-    subscribers = addSubscriber(element, callback);
-    if (currentSubscriber === null) {
-      observer.observe(element);
-    }
-  };
-  return {
-    subscribe,
-    unsubscribe,
-    observer
-  };
-}
-function getObserver(Observer = null, options = {}) {
-  if (Observer === null) {
-    return {
-      observer: null,
-      subscribe: () => {},
-      unsubscribe: () => {}
-    };
-  }
-  const observerKey = getOptionsKey(options);
-  if (!observersCache.has(Observer)) {
-    observersCache.set(Observer, {});
-  }
-  const observers = observersCache.get(Observer);
-  if (typeof observers[observerKey] === 'undefined') {
-    observers[observerKey] = createObserver(Observer, options);
-    observersCache.set(Observer, observers);
-  }
-  return observers[observerKey];
-}
-function useObserver(Observer, opts = {}, initialEntry = {}) {
-  const {
-    root = null,
-    rootMargin = null,
-    threshold: defaultThreshold = null,
-    disabled = false
-  } = opts;
-  const [entry, setEntry] = react.useState(initialEntry);
-  const threshold = react.useMemo(() => defaultThreshold, [defaultThreshold]);
-  const nodeRef = react.useRef(null);
-  const currentElement = react.useRef(null);
-  const elementChanged = nodeRef.current !== currentElement.current;
-  react.useEffect(() => {
-    if (disabled) {
-      return () => {};
-    }
-    const {
-      current: nodeElement
-    } = nodeRef;
-    const callback = newEntry => setEntry(newEntry);
-    let unsubscribe = null;
-    if (nodeElement !== null) {
-      const newOpts = {};
-      if (root !== null) {
-        newOpts.root = root;
-      }
-      if (rootMargin !== null) {
-        newOpts.rootMargin = rootMargin;
-      }
-      if (threshold !== null) {
-        newOpts.threshold = threshold;
-      }
-      const {
-        subscribe,
-        unsubscribe: localUnsubscribe
-      } = getObserver(Observer, newOpts);
-      unsubscribe = localUnsubscribe;
-      subscribe(nodeElement, callback);
-    }
-    currentElement.current = nodeElement;
-    return () => {
-      if (unsubscribe !== null) {
-        unsubscribe(nodeElement, callback);
-      }
-    };
-  }, [Observer, elementChanged, disabled, root, rootMargin, threshold]);
-  return {
-    ref: nodeRef,
-    entry
-  };
-}
-
-/**
- * Intersection Observer
- */
-const defaultThreshold = [0, 1.0];
-const intersectionObserverInitialEntry = {
-  target: null,
-  time: null,
-  isVisible: false,
-  isIntersecting: false,
-  intersectionRatio: 0,
-  intersectionRect: null,
-  boundingClientRect: null,
-  rootBounds: null
-};
-function useIntersectionObserver({
-  root = null,
-  rootMargin = '0px',
-  threshold = defaultThreshold,
-  disabled = false
-} = {}) {
-  return useObserver(typeof IntersectionObserver !== 'undefined' ? IntersectionObserver : null, {
-    root,
-    rootMargin,
-    threshold,
-    disabled
-  }, intersectionObserverInitialEntry);
-}
-
-/**
- * Resize Observer
- */
-const resizeObserverInitialEntry = {
-  target: null,
-  contentRect: null,
-  contentBoxSize: null,
-  borderBoxSize: null
-};
-function useResizeObserver({
-  disabled = false
-} = {}) {
-  return useObserver(typeof ResizeObserver !== 'undefined' ? ResizeObserver : null, {
-    disabled
-  }, resizeObserverInitialEntry);
-}
-
-function useIsVisible({
-  persist = false,
-  ...opts
-} = {}) {
-  const {
-    ref,
-    entry: {
-      isIntersecting
-    }
-  } = useIntersectionObserver(opts);
-  const wasIntersecting = react.useRef(isIntersecting);
-  if (isIntersecting && !wasIntersecting.current) {
-    wasIntersecting.current = isIntersecting;
-  }
-  const isVisible = !persist && isIntersecting || persist && wasIntersecting.current;
-  return {
-    ref: !persist || !isVisible ? ref : {
-      current: null
-    },
-    visible: isVisible
-  };
-}
-
-const eventsManager = typeof window !== 'undefined' ? new EventsManager(window) : null;
-function useWindowEvent(event, callback) {
-  react.useEffect(() => {
-    if (eventsManager !== null && callback !== null) {
-      eventsManager.subscribe(event, callback);
-    }
-    return () => {
-      if (eventsManager !== null && callback !== null) {
-        eventsManager.unsubscribe(event, callback);
-      }
-    };
-  }, [event, callback]);
-}
-
-function useKeyboard(keyMap = null) {
-  const onKeyDown = react.useCallback(event => {
-    const {
-      key
-    } = event;
-    let callback = null;
-    if (typeof keyMap === 'function') {
-      callback = keyMap;
-    } else if (typeof keyMap[key] !== 'undefined') {
-      callback = typeof keyMap[key] === 'function' ? keyMap[key] : (keyMap[key] || {}).down || null;
-    }
-    if (callback !== null) {
-      callback(event);
-    }
-  }, [keyMap]);
-  const onKeyUp = react.useCallback(event => {
-    const {
-      key
-    } = event;
-    let callback = null;
-    if (typeof keyMap === 'function') {
-      callback = keyMap;
-    } else if (typeof keyMap[key] !== 'undefined') {
-      callback = typeof keyMap[key] === 'function' ? keyMap[key] : (keyMap[key] || {}).up || null;
-    }
-    if (callback !== null) {
-      callback(event);
-    }
-  }, [keyMap]);
-  useWindowEvent('keydown', keyMap !== null ? onKeyDown : null);
-  useWindowEvent('keyup', keyMap !== null ? onKeyUp : null);
-}
-
-const useItemsPaginated = (loader, {
-  page = null,
-  count = 10,
-  pages: initialPages = null,
-  getPageFromResponse = ({
-    pagination: {
-      page: currentPage,
-      last_page: lastPage,
-      total
-    },
-    data: items
-  }) => ({
-    page: parseInt(currentPage, 10),
-    lastPage: parseInt(lastPage, 10),
-    total: parseInt(total, 10),
-    items
-  }),
-  onLoaded = null,
-  onError = null,
-  query = null
-} = {}) => {
-  const lastState = react.useRef(null);
-  const initialState = react.useMemo(() => {
-    const finalInitialPages = initialPages !== null ? initialPages.map(it => getPageFromResponse(it)) : null;
-    const finalLastPage = finalInitialPages !== null ? finalInitialPages.reduce((currentLastPage, {
-      lastPage: initialLastPage
-    }) => initialLastPage > currentLastPage ? initialLastPage : currentLastPage, -1) : -1;
-    return {
-      lastPage: finalLastPage,
-      total: finalInitialPages !== null ? finalInitialPages[0].total : 0,
-      loaded: finalLastPage !== -1 && finalInitialPages !== null && finalInitialPages.length === finalLastPage,
-      loading: false,
-      pages: finalInitialPages !== null ? finalInitialPages : null
-    };
-  }, [initialPages]);
-  const currentPagesRef = react.useRef(initialState.pages);
-  const [state, setState] = react.useState(initialState);
-  const {
-    lastPage,
-    loaded,
-    loading,
-    pages,
-    total
-  } = state;
-  const items = pages !== null ? pages.reduce((pagesItems, {
-    items: pageItems
-  }) => pagesItems.concat(pageItems), []) : null;
-  const updateState = update => setState({
-    ...state,
-    ...update
-  });
-  const updateFromResponse = (response, error = null, reset = false) => {
-    if (error !== null) {
-      updateState({
-        loaded: false,
-        loading: false
-      });
-      throw error;
-    }
-    const newPage = getPageFromResponse(response);
-    const currentPages = currentPagesRef.current || [];
-    const newPages = (reset ? [newPage] : [...currentPages.filter(it => it.page !== newPage.page), newPage]).sort((a, b) => {
-      const {
-        page: aPage = null
-      } = a;
-      const {
-        page: bPage = null
-      } = b;
-      const hasObject = aPage !== null && bPage !== null;
-      if (hasObject) {
-        if (aPage === bPage) {
-          return 0;
-        }
-        return aPage > bPage ? 1 : -1;
-      }
-      if (isNumber(a) && isNumber(b)) {
-        if (a === b) {
-          return 0;
-        }
-        return a > b ? 1 : -1;
-      }
-      return 0;
-    });
-    currentPagesRef.current = newPages;
-    updateState({
-      loaded: true,
-      loading: false,
-      lastPage: newPage.lastPage,
-      total: newPage.total,
-      pages: newPages
-    });
-    return newPage;
-  };
-  const getNextPage = () => {
-    const allPages = lastPage !== -1 ? Array.call(null, ...Array(lastPage)).map((it, index) => index + 1) : [];
-    const currentPages = currentPagesRef.current || [];
-    const remainingPages = allPages.filter(pageNumber => currentPages.findIndex(it => it.page === pageNumber) === -1);
-    const firstItem = remainingPages.length > 0 ? remainingPages.shift() : null;
-    return firstItem !== null ? firstItem : null;
-  };
-  const loadItems = requestPage => {
-    updateState({
-      loading: true
-    });
-    return cancelablePromise.cancelable(loader(requestPage, count)).then(response => updateFromResponse(response)).catch(error => updateFromResponse(null, error)).then(response => {
-      if (onLoaded !== null) {
-        onLoaded(response);
-      }
-      return response;
-    }).catch(error => {
-      if (onError !== null) {
-        onError(error);
-      }
-    });
-  };
-  const loadPage = pageToLoad => {
-    if (loading) {
-      return Promise.reject();
-    }
-    const currentPages = currentPagesRef.current || [];
-    const foundPage = currentPages.find(it => it.page === pageToLoad) || null;
-    if (foundPage !== null) {
-      return Promise.resolve(foundPage);
-    }
-    return loadItems(pageToLoad);
-  };
-  const loadNextPage = () => {
-    if (loading) {
-      return Promise.reject();
-    }
-    const nextPage = getNextPage();
-    return nextPage !== null ? loadItems(nextPage) : Promise.resolve();
-  };
-
-  // Reset all on query change
-  react.useEffect(() => {
-    const hadState = lastState.current !== null;
-    if (hadState) {
-      currentPagesRef.current = null;
-      updateState({
-        loaded: true,
-        loading: false,
-        lastPage: null,
-        total: 0,
-        pages: []
-      });
-    }
-  }, [query]);
-  react.useEffect(() => {
-    const hadState = lastState.current !== null;
-    lastState.current = initialState;
-    if (hadState) {
-      currentPagesRef.current = initialState.pages;
-      setState(initialState);
-    }
-  }, [initialState]);
-  react.useEffect(() => {
-    if (loader === null) {
-      return () => {};
-    }
-    let loadPromise = null;
-    const pageToLoad = initialPages === null && page === null ? 1 : page;
-    if (pageToLoad !== null) {
-      loadPromise = loadItems(pageToLoad);
-    }
-    return () => {
-      if (loadPromise !== null) {
-        loadPromise.cancel();
-      }
-    };
-  }, [loader, page]);
-  const currentPage = pages !== null ? pages.find(({
-    page: pageNumber
-  }) => parseInt(pageNumber, 10) === parseInt(page, 10)) || null : null;
-  return {
-    items,
-    pages,
-    currentPage,
-    pageItems: currentPage !== null ? currentPage.items : null,
-    total,
-    lastPage,
-    loaded,
-    allLoaded: lastPage !== -1 && pages.length === lastPage,
-    loading,
-    loadNextPage,
-    loadPage
-  };
-};
-
-function usePlayerCurrentTime(player, {
-  id = null,
-  disabled = false,
-  updateInterval = 1000,
-  onUpdate: customOnUpdate = null,
-  getCurrentTime = p => p.currentTime
-} = {}) {
-  const [currentTime, setCurrentTime] = react.useState(0);
-  const realCurrentTime = react.useRef(currentTime);
-  const lastIdRef = react.useRef(id);
-  const idChanged = lastIdRef.current !== id;
-  if (idChanged) {
-    realCurrentTime.current = 0;
-    lastIdRef.current = id;
-  }
-
-  // Check time update
-  react.useEffect(() => {
-    if (disabled || player === null) {
-      return () => {};
-    }
-    let canceled = false;
-    const updateTime = time => {
-      if (canceled) {
-        return;
-      }
-      realCurrentTime.current = time;
-      setCurrentTime(time);
-      if (customOnUpdate !== null) {
-        customOnUpdate(time);
-      }
-    };
-    const interval = setInterval(() => {
-      const time = getCurrentTime(player);
-      if (typeof time.then !== 'undefined') {
-        time.then(updateTime);
-      } else {
-        updateTime(time);
-      }
-    }, updateInterval);
-    return () => {
-      canceled = true;
-      clearInterval(interval);
-    };
-  }, [id, player, setCurrentTime, disabled, updateInterval, getCurrentTime]);
-  return realCurrentTime.current;
-}
-
-const NO_PLAYER_ERROR$2 = new Error('No player');
-function useNativeVideoPlayer(url, {
-  width = 0,
-  height = 0,
-  duration = 0,
-  muted: providedMuted = false,
-  initialMuted = false,
-  timeUpdateInterval = 1000,
-  onTimeUpdate: customOnTimeUpdate = null
-} = {}) {
-  const debug = react.useMemo(() => createDebug('folklore:video:native'), []);
-  const elementRef = react.useRef(null);
-  const [loaded, setLoaded] = react.useState(false);
-  const [muted, setMuted] = react.useState(initialMuted || providedMuted);
-  const [playState, setPlayState] = react.useState({
-    playing: false,
-    paused: false,
-    ended: false,
-    buffering: false
-  });
-  const [metadata, setMetadata] = react.useState({
-    width,
-    height,
-    duration
-  });
-  const play = react.useCallback(() => {
-    const {
-      current: player
-    } = elementRef;
-    return player !== null ? player.play() : Promise.reject(NO_PLAYER_ERROR$2);
-  }, []);
-  const pause = react.useCallback(() => {
-    const {
-      current: player
-    } = elementRef;
-    return player !== null ? player.pause() : Promise.reject(NO_PLAYER_ERROR$2);
-  }, []);
-  const setVolume = react.useCallback(newVolume => {
-    const {
-      current: player
-    } = elementRef;
-    if (player !== null) {
-      player.volume = newVolume;
-      return Promise.resolve(newVolume);
-    }
-    return Promise.reject(NO_PLAYER_ERROR$2);
-  }, []);
-  const mute = react.useCallback(() => {
-    const {
-      current: player
-    } = elementRef;
-    if (player !== null) {
-      player.muted = true;
-      return Promise.resolve(true);
-    }
-    return Promise.reject(NO_PLAYER_ERROR$2);
-  }, []);
-  const unmute = react.useCallback(() => {
-    const {
-      current: player
-    } = elementRef;
-    if (player !== null) {
-      player.muted = false;
-      return Promise.resolve(false);
-    }
-    return Promise.reject(NO_PLAYER_ERROR$2);
-  }, []);
-  const seek = react.useCallback(newTime => {
-    const {
-      current: player
-    } = elementRef;
-    if (player !== null) {
-      player.currentTime = newTime;
-      return Promise.resolve(newTime);
-    }
-    return Promise.reject(NO_PLAYER_ERROR$2);
-  }, []);
-  const setLoop = react.useCallback(newLoop => {
-    const {
-      current: player
-    } = elementRef;
-    if (player !== null) {
-      player.loop = newLoop;
-      return Promise.resolve(newLoop);
-    }
-    return Promise.reject(NO_PLAYER_ERROR$2);
-  }, []);
-
-  // Bind player events
-  react.useEffect(() => {
-    const {
-      current: player
-    } = elementRef;
-    if (player === null) {
-      return () => {};
-    }
-    const onCanPlay = () => {
-      setLoaded(true);
-      const newMetadata = {
-        duration: player.duration,
-        width: player.videoWidth,
-        height: player.videoHeight
-      };
-      setMetadata(newMetadata);
-      debug('onCanPlay [URL: %s]', url);
-    };
-    const onMetadataLoaded = () => {
-      const newMetadata = {
-        duration: player.duration,
-        width: player.videoWidth,
-        height: player.videoHeight
-      };
-      setMetadata(newMetadata);
-      debug('onMetadataLoaded [URL: %s]', url);
-    };
-    const onPlay = () => {
-      setPlayState({
-        playing: true,
-        paused: false,
-        ended: false,
-        buffering: false
-      });
-      debug('onPlay [URL: %s]', url);
-    };
-    const onPause = () => {
-      setPlayState({
-        playing: false,
-        paused: true,
-        ended: false,
-        buffering: false
-      });
-      debug('onPause [URL: %s]', url);
-    };
-    const onVolumeChange = () => {
-      setMuted(player.muted);
-      debug('onVolumeChange [URL: %s]', url);
-    };
-    const onEnded = () => {
-      setPlayState({
-        playing: false,
-        paused: false,
-        ended: true,
-        buffering: false
-      });
-      debug('onEnded [URL: %s]', url);
-    };
-    debug('Bind events [URL: %s]', url);
-    player.addEventListener('canplay', onCanPlay);
-    player.addEventListener('metadataloaded', onMetadataLoaded);
-    player.addEventListener('play', onPlay);
-    player.addEventListener('volumechange', onVolumeChange);
-    player.addEventListener('pause', onPause);
-    player.addEventListener('ended', onEnded);
-    return () => {
-      debug('Unbind events [URL: %s]', url);
-      player.removeEventListener('canplay', onCanPlay);
-      player.removeEventListener('metadataloaded', onMetadataLoaded);
-      player.removeEventListener('play', onPlay);
-      player.removeEventListener('volumechange', onVolumeChange);
-      player.removeEventListener('pause', onPause);
-      player.removeEventListener('ended', onEnded);
-    };
-  }, [url, setPlayState, setMetadata, setMuted, setLoaded]);
-  const {
-    playing
-  } = playState;
-  const currentTime = usePlayerCurrentTime(elementRef.current, {
-    id: url,
-    disabled: !playing || timeUpdateInterval === null,
-    updateInterval: timeUpdateInterval,
-    onUpdate: customOnTimeUpdate
-  });
-  return {
-    ref: elementRef,
-    player: elementRef.current,
-    play,
-    pause,
-    mute,
-    unmute,
-    setVolume,
-    seek,
-    setLoop,
-    ready: true,
-    currentTime,
-    loaded,
-    muted,
-    ...metadata,
-    ...playState
-  };
-}
-
-const getWindowSize = () => ({
-  width: typeof window !== 'undefined' ? window.innerWidth || 0 : 0,
-  height: typeof window !== 'undefined' ? window.innerHeight || 0 : 0
-});
-let currentSize = null;
-function useWindowSize({
-  onChange = null,
-  onMount = false,
-  memo = false
-} = {}) {
-  const [size, setSize] = react.useState(() => onMount ? getWindowSize() : {
-    width: 0,
-    height: 0
-  });
-  const sizeRef = react.useRef(size);
-  if (currentSize === null && memo) {
-    currentSize = size;
-  }
-  const updateSize = react.useCallback(() => {
-    const newSize = getWindowSize();
-    if (memo && (currentSize.width !== newSize.width || currentSize.height !== newSize.height)) {
-      currentSize = newSize;
-    }
-    if (sizeRef.current.width !== newSize.width || sizeRef.current.height !== newSize.height) {
-      sizeRef.current = newSize;
-      setSize(newSize);
-      return newSize;
-    }
-    return null;
-  }, [setSize, memo]);
-  const onResize = react.useCallback(() => {
-    const newSize = updateSize();
-    if (newSize !== null && onChange !== null) {
-      onChange(newSize);
-    }
-  }, [onChange, updateSize]);
-  useWindowEvent('resize', onResize);
-  react.useEffect(() => {
-    onResize();
-  }, []);
-  return size;
-}
-
-function useScrollTrigger({
-  disabled = false,
-  triggers = [0.1, 0.25, 0.5, 0.75, 0.9, 1.0],
-  useElementScroll = false,
-  onTrigger = null
-} = {}) {
-  const triggersCompletedRef = react.useRef([]);
-  const {
-    height
-  } = useWindowSize();
-  const {
-    ref,
-    entry: {
-      contentRect = null
-    }
-  } = useResizeObserver({
-    disabled: !useElementScroll
-  });
-  const {
-    top: elementTop = 0,
-    height: elementHeight = null
-  } = contentRect || {};
-  const elementScrollHeight = elementHeight !== null ? elementHeight + elementTop : 0;
-  react.useEffect(() => {
-    if (eventsManager === null || disabled) {
-      return () => {};
-    }
-    function onScroll() {
-      const scrollY = useElementScroll ? ref.current.scrollTop : window.scrollY;
-      let scrollHeight = 0;
-      if (useElementScroll) {
-        scrollHeight = ref.current.scrollHeight - ref.current.clientHeight;
-      } else if (ref.current !== null && elementScrollHeight > 0) {
-        scrollHeight = elementScrollHeight - height;
-      } else {
-        scrollHeight = document.documentElement.scrollHeight - height;
-      }
-      const progress = Math.min(Math.max(scrollY / scrollHeight, 0), 1);
-      const newTriggersCompleted = triggers.filter(step => progress >= step && triggersCompletedRef.current.indexOf(step) === -1);
-      newTriggersCompleted.forEach(step => {
-        if (onTrigger != null) {
-          onTrigger(step);
-        }
-      });
-      if (newTriggersCompleted.length > 0) {
-        triggersCompletedRef.current = [...triggersCompletedRef.current, ...newTriggersCompleted];
-      }
-    }
-    if (useElementScroll) {
-      ref.current.addEventListener('scroll', onScroll);
-    } else {
-      eventsManager.subscribe('scroll', onScroll);
-    }
-    onScroll();
-    return () => {
-      if (useElementScroll) {
-        ref.current.removeEventListener('scroll', onScroll);
-      } else {
-        eventsManager.unsubscribe('scroll', onScroll);
-      }
-    };
-  }, [triggers, disabled, onTrigger, height, elementScrollHeight, useElementScroll]);
-  return {
-    ref
-  };
-}
-
-function checkWebpSupport() {
-  return new Promise(resolve => {
-    const img = document.createElement('img');
-    img.onload = () => {
-      resolve(img.width > 0 && img.height > 0);
-    };
-    img.onerror = () => {
-      resolve(false);
-    };
-    img.src = 'data:image/webp;base64,UklGRiQAAABXRUJQVlA4IBgAAAAwAQCdASoCAAEAAQAcJaQAA3AA/v3AgAA=';
-  });
-}
-function useSupportsWebp(defaultValue = true) {
-  const [supportsWebp, setSupportsWebp] = react.useState(defaultValue);
-  react.useEffect(() => {
-    let canceled = false;
-    checkWebpSupport().then(newSupport => {
-      if (!canceled && newSupport !== supportsWebp) {
-        setSupportsWebp(newSupport);
-      }
-    });
-    return () => {
-      canceled = true;
-    };
-  }, []);
-  return supportsWebp;
-}
-
-const NO_PLAYER_ERROR$1 = new Error('No player');
-function useVimeoPlayer(id, {
-  width = 0,
-  height = 0,
-  duration = 0,
-  autoplay = false,
-  autopause = true,
-  byline = false,
-  controls = false,
-  muted: providedMuted = false,
-  initialMuted = false,
-  timeUpdateInterval = 1000,
-  onTimeUpdate: customOnTimeUpdate = null,
-  getVideoId = url => {
-    if (url === null || url.match(/^[0-9]+$/) !== null) {
-      return url;
-    }
-    const match = url.match(/\/[0-9]+/);
-    return match !== null ? match[1] : null;
-  }
-} = {}) {
-  const debug = react.useMemo(() => createDebug('folklore:video:vimeo'), []);
-  const [apiLoaded, setApiLoaded] = react.useState(false);
-  const apiRef = react.useRef(null);
-  const elementRef = react.useRef(null);
-  const playerRef = react.useRef(null);
-  const playerElementRef = react.useRef(elementRef.current);
-  const elementHasChanged = elementRef.current !== playerElementRef.current;
-  const videoId = react.useMemo(() => getVideoId(id), [id]);
-  const [ready, setReady] = react.useState(false);
-  const [loaded, setLoaded] = react.useState(false);
-  const [volume, setVolumeState] = react.useState(initialMuted || providedMuted ? 0 : 1);
-  const [playState, setPlayState] = react.useState({
-    playing: false,
-    paused: false,
-    ended: false,
-    buffering: false
-  });
-  const [metadata, setMetadata] = react.useState({
-    width,
-    height,
-    duration
-  });
-
-  // Load SDK
-  react.useEffect(() => {
-    let canceled = false;
-    if (!apiLoaded && id !== null) {
-      debug('Load API');
-      services.loadVimeo().then(api => {
-        if (!canceled) {
-          apiRef.current = api;
-          setApiLoaded(true);
-          debug('API Loaded');
-        }
-      });
-    }
-    return () => {
-      canceled = true;
-    };
-  }, [id]);
-  const play = react.useCallback(() => {
-    const {
-      current: player
-    } = playerRef;
-    return player !== null ? player.play() : Promise.reject(NO_PLAYER_ERROR$1);
-  }, []);
-  const pause = react.useCallback(() => {
-    const {
-      current: player
-    } = playerRef;
-    return player !== null ? player.pause() : Promise.reject(NO_PLAYER_ERROR$1);
-  }, []);
-  const setVolume = react.useCallback(newVolume => {
-    const {
-      current: player
-    } = playerRef;
-    return player !== null ? player.setVolume(newVolume) : Promise.reject(NO_PLAYER_ERROR$1);
-  }, []);
-  const mute = react.useCallback(() => {
-    const {
-      current: player
-    } = playerRef;
-    return player !== null ? player.setVolume(0) : Promise.reject(NO_PLAYER_ERROR$1);
-  }, []);
-  const unmute = react.useCallback(() => {
-    const {
-      current: player
-    } = playerRef;
-    return player !== null ? player.setVolume(1) : Promise.reject(NO_PLAYER_ERROR$1);
-  }, []);
-  const seek = react.useCallback(time => {
-    const {
-      current: player
-    } = playerRef;
-    return player !== null ? player.setCurrentTime(time) : Promise.reject(NO_PLAYER_ERROR$1);
-  }, []);
-  const setLoop = react.useCallback(loop => {
-    const {
-      current: player
-    } = playerRef;
-    return player !== null ? player.setLoop(loop) : Promise.reject(NO_PLAYER_ERROR$1);
-  }, []);
-  const destroyVideo = react.useCallback(() => {
-    const {
-      current: player
-    } = playerRef;
-    if (player !== null) {
-      debug('Unload video');
-      player.unload();
-    }
-    if (player !== null) {
-      debug('Unset video');
-      playerRef.current = null;
-    }
-  }, []);
-  react.useEffect(() => {
-    const {
-      current: currentPlayer
-    } = playerRef;
-    if (playerElementRef.current !== elementRef.current && currentPlayer !== null) {
-      debug('iFrame switched');
-      destroyVideo();
-    }
-  }, [elementHasChanged]);
-
-  // Create player
-  react.useEffect(() => {
-    const {
-      current: Player = null
-    } = apiRef;
-    const {
-      current: currentPlayer = null
-    } = playerRef;
-    const {
-      current: element = null
-    } = elementRef;
-    if (!apiLoaded || videoId === null || element === null) {
-      destroyVideo();
-      return;
-    }
-    let player = currentPlayer;
-    if (player === null) {
-      debug('Create player [ID: %s]', videoId);
-      player = new Player(element, {
-        id: videoId,
-        autoplay,
-        autopause,
-        byline,
-        controls,
-        muted: initialMuted,
-        background: !controls
-      });
-      player.ready().then(() => setReady(true)).catch(e => {
-        debug('ERROR: %o', e);
-      });
-    } else {
-      debug('Load video [ID: %s]', videoId);
-      player.loadVideo(videoId).catch(e => {
-        debug('ERROR: %o', e);
-      });
-    }
-    playerRef.current = player;
-    playerElementRef.current = element;
-  }, [apiLoaded, videoId, elementHasChanged, setReady, destroyVideo, setLoaded]);
-
-  // Bind player events
-  react.useEffect(() => {
-    const {
-      current: player
-    } = playerRef;
-    if (player === null) {
-      return () => {};
-    }
-    let canceled = false;
-    const onLoaded = () => {
-      Promise.all([player.getDuration(), player.getVideoWidth(), player.getVideoHeight(), player.getMuted()]).then(([newDuration, newWidth, newHeight, newMuted]) => {
-        if (canceled) {
-          return;
-        }
-        const newMetadata = {
-          duration: newDuration,
-          width: newWidth,
-          height: newHeight
-        };
-        setMetadata(newMetadata);
-        if (newMuted) {
-          setVolumeState(0);
-        }
-        setLoaded(true);
-      });
-      debug('onLoaded [ID: %s]', videoId);
-    };
-    const onPlay = () => {
-      setPlayState({
-        playing: true,
-        paused: false,
-        ended: false,
-        buffering: false
-      });
-      debug('onPlay [ID: %s]', videoId);
-      player.getMuted().then(newMuted => {
-        if (!canceled && newMuted) {
-          setVolumeState(0);
-        }
-      }).catch(() => {});
-    };
-    const onPause = () => {
-      setPlayState({
-        playing: false,
-        paused: true,
-        ended: false,
-        buffering: false
-      });
-      debug('onPause [ID: %s]', videoId);
-    };
-    const onVolumeChange = ({
-      volume: newVolume
-    }) => {
-      setVolumeState(newVolume);
-      debug('onVolumeChange [ID: %s]', videoId);
-    };
-    const onEnded = () => {
-      setPlayState({
-        playing: false,
-        paused: false,
-        ended: true,
-        buffering: false
-      });
-      debug('onEnded [ID: %s]', videoId);
-    };
-    const onBufferStart = () => {
-      setPlayState({
-        playing: true,
-        paused: false,
-        ended: false,
-        buffering: true
-      });
-      debug('onBufferStart [ID: %s]', videoId);
-    };
-    const onBufferEnded = () => {
-      setPlayState({
-        playing: true,
-        paused: false,
-        ended: false,
-        buffering: false
-      });
-      debug('onBufferStart [ID: %s]', videoId);
-    };
-    debug('Bind events [ID: %s]', videoId);
-    player.on('loaded', onLoaded);
-    player.on('play', onPlay);
-    player.on('pause', onPause);
-    player.on('volumechange', onVolumeChange);
-    player.on('ended', onEnded);
-    player.on('bufferstart', onBufferStart);
-    player.on('bufferend', onBufferEnded);
-    return () => {
-      canceled = true;
-      debug('Unbind events [ID: %s]', videoId);
-      player.off('loaded', onLoaded);
-      player.off('play', onPlay);
-      player.off('pause', onPause);
-      player.off('volumechange', onVolumeChange);
-      player.off('ended', onEnded);
-      player.off('bufferstart', onBufferStart);
-      player.off('bufferend', onBufferEnded);
-    };
-  }, [videoId, playerRef.current, setPlayState, setMetadata, setVolumeState, setLoaded]);
-  const {
-    playing
-  } = playState;
-  const getCurrentTime = react.useCallback(p => p.getCurrentTime(), []);
-  const currentTime = usePlayerCurrentTime(playerRef.current, {
-    id: videoId,
-    disabled: !playing || timeUpdateInterval === null,
-    updateInterval: timeUpdateInterval,
-    onUpdate: customOnTimeUpdate,
-    getCurrentTime
-  });
-  return {
-    ref: elementRef,
-    player: playerRef.current,
-    play,
-    pause,
-    mute,
-    unmute,
-    setVolume,
-    seek,
-    setLoop,
-    ready,
-    currentTime,
-    loaded,
-    muted: volume === 0,
-    volume,
-    ...metadata,
-    ...playState
-  };
-}
-
-const NO_PLAYER_ERROR = new Error('No player');
-function useYouTubePlayer(id, {
-  width = 0,
-  height = 0,
-  duration = 0,
-  autoplay = false,
-  controls = true,
-  timeUpdateInterval = 1000,
-  muted: providedMuted = false,
-  initialMuted = false,
-  onVolumeChange: customOnVolumeChange = null,
-  onTimeUpdate: customOnTimeUpdate = null,
-  getVideoId = url => {
-    if (url === null || url.match(/^https?:/) === null) {
-      return url;
-    }
-    const regExp = /^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\?))\??v?=?([^#&?]*).*/;
-    const match = url.match(regExp);
-    return match !== null ? match[7] : null;
-  }
-} = {}) {
-  const debug = react.useMemo(() => createDebug('folklore:video:youtube'), []);
-  const [apiLoaded, setApiLoaded] = react.useState(typeof window !== 'undefined' && typeof window.YT !== 'undefined');
-  const apiRef = react.useRef(typeof window !== 'undefined' && typeof window.YT !== 'undefined' ? window.YT : null);
-  const elementRef = react.useRef(null);
-  const playerRef = react.useRef(null);
-  const playerElementRef = react.useRef(elementRef.current);
-  if (elementRef.current !== null && playerElementRef.current === null) {
-    playerElementRef.current = elementRef.current;
-  }
-  const elementHasChanged = elementRef.current !== playerElementRef.current;
-  const videoId = react.useMemo(() => getVideoId(id), [id]);
-  const [ready, setReady] = react.useState(false);
-  const [muted, setMuted] = react.useState(initialMuted || providedMuted);
-  const [playState, setPlayState] = react.useState({
-    playing: false,
-    paused: false,
-    ended: false,
-    buffering: false
-  });
-  const [metadata, setMetadata] = react.useState({
-    width,
-    height,
-    duration
-  });
-  react.useEffect(() => {
-    let canceled = false;
-    if (!apiLoaded && videoId !== null) {
-      debug('Load API');
-      services.loadYouTube().then(api => {
-        if (!canceled) {
-          apiRef.current = api;
-          setApiLoaded(true);
-          debug('API Loaded');
-        }
-      });
-    }
-    return () => {
-      canceled = true;
-    };
-  }, [apiLoaded, videoId, setApiLoaded]);
-  const play = react.useCallback(() => {
-    const {
-      current: player
-    } = playerRef;
-    return player !== null && typeof player.playVideo !== 'undefined' ? Promise.resolve(player.playVideo()) : Promise.reject(NO_PLAYER_ERROR);
-  }, []);
-  const pause = react.useCallback(() => {
-    const {
-      current: player
-    } = playerRef;
-    return player !== null && typeof player.pauseVideo !== 'undefined' ? Promise.resolve(player.pauseVideo()) : Promise.reject(NO_PLAYER_ERROR);
-  }, []);
-  const setVolume = react.useCallback(volume => {
-    const {
-      current: player
-    } = playerRef;
-    const promise = player !== null && typeof player.setVolume !== 'undefined' ? Promise.resolve(player.setVolume(volume * 100)) : Promise.reject(NO_PLAYER_ERROR);
-    if (customOnVolumeChange) {
-      customOnVolumeChange(volume);
-    }
-    return promise;
-  }, [customOnVolumeChange]);
-  const mute = react.useCallback(() => {
-    const {
-      current: player
-    } = playerRef;
-    return (player !== null && typeof player.mute !== 'undefined' ? Promise.resolve(player.mute()) : Promise.reject(NO_PLAYER_ERROR)).then(() => setMuted(true));
-  }, [setMuted]);
-  const unmute = react.useCallback(() => {
-    const {
-      current: player
-    } = playerRef;
-    return (player !== null && typeof player.unMute !== 'undefined' ? Promise.resolve(player.unMute()) : Promise.reject(NO_PLAYER_ERROR)).then(() => setMuted(false));
-  }, []);
-  const seek = react.useCallback(time => {
-    const {
-      current: player
-    } = playerRef;
-    return player !== null && typeof player.seekTo !== 'undefined' ? Promise.resolve(player.seekTo(time)) : Promise.reject(NO_PLAYER_ERROR);
-  }, []);
-  const setLoop = react.useCallback(loop => {
-    const {
-      current: player
-    } = playerRef;
-    return player !== null && typeof player.setLoop !== 'undefined' ? Promise.resolve(player.setLoop(loop)) : Promise.reject(NO_PLAYER_ERROR);
-  }, []);
-  const destroyPlayer = react.useCallback(() => {
-    if (playerRef.current !== null) {
-      debug('Unset player');
-      playerRef.current = null;
-    }
-  }, []);
-
-  // Detect iframe switch and destroy player
-
-  react.useEffect(() => {
-    const {
-      current: currentPlayer
-    } = playerRef;
-    if (playerElementRef.current !== elementRef.current && currentPlayer !== null) {
-      debug('iFrame switched');
-      destroyPlayer();
-    }
-  }, [elementHasChanged]);
-
-  // Create player
-  react.useEffect(() => {
-    const {
-      current: YT = null
-    } = apiRef;
-    const {
-      current: currentPlayer = null
-    } = playerRef;
-    const {
-      current: element = null
-    } = elementRef;
-    if (!apiLoaded || videoId === null || element === null) {
-      destroyPlayer();
-      return;
-    }
-    let player = currentPlayer;
-    if (player !== null && typeof player.loadVideoById !== 'undefined') {
-      debug('Switch video [ID: %s]', videoId);
-      player.loadVideoById(videoId);
-    } else {
-      debug('Create player [ID: %s]', videoId);
-      const onReady = ({
-        target
-      }) => {
-        player = target;
-        playerRef.current = target;
-        setReady(true);
-        const newDuration = target.getDuration();
-        if (newDuration !== metadata.duration) {
-          setMetadata({
-            ...metadata,
-            duration: newDuration
-          });
-        }
-        debug('onReady [ID: %s]', videoId);
-        if (muted) {
-          player.mute();
-        }
-      };
-      const onStateChange = ({
-        data: state
-      }) => {
-        const newState = {
-          playing: state === YT.PlayerState.PLAYING,
-          paused: state === YT.PlayerState.PAUSED,
-          ended: state === YT.PlayerState.ENDED,
-          buffering: state === YT.PlayerState.BUFFERING
-        };
-        setPlayState(newState);
-        let stateLabel = null;
-        if (newState.playing) {
-          stateLabel = 'playing';
-        } else if (newState.paused) {
-          stateLabel = 'paused';
-        } else if (newState.ended) {
-          stateLabel = 'ended';
-        } else if (newState.buffering) {
-          stateLabel = 'buffering';
-        } else if (state === -1) {
-          stateLabel = 'not started';
-        } else if (state === 0) {
-          stateLabel = 'stopped';
-        }
-        debug('onStateChange %s [ID: %s]', stateLabel, videoId);
-      };
-      player = new YT.Player(element, {
-        videoId,
-        playerVars: {
-          controls,
-          autoplay: autoplay ? 1 : 0,
-          mute: initialMuted,
-          playsinline: true,
-          rel: 0,
-          showinfo: 0,
-          modestbranding: 1
-        },
-        events: {
-          onReady,
-          onStateChange
-        }
-      });
-    }
-    playerRef.current = player;
-    playerElementRef.current = element;
-  }, [apiLoaded, videoId, elementHasChanged, setPlayState, setReady, setMetadata, destroyPlayer]);
-  const {
-    playing
-  } = playState;
-  const getCurrentTime = react.useCallback(p => p.getCurrentTime(), []);
-  const currentTime = usePlayerCurrentTime(playerRef.current, {
-    id: videoId,
-    disabled: !playing || timeUpdateInterval === null,
-    updateInterval: timeUpdateInterval,
-    onUpdate: customOnTimeUpdate,
-    getCurrentTime
-  });
-  return {
-    ref: elementRef,
-    player: playerRef.current,
-    play,
-    pause,
-    mute,
-    unmute,
-    setVolume,
-    seek,
-    setLoop,
-    ready,
-    currentTime,
-    muted,
-    loaded: ready,
-    ...metadata,
-    ...playState
-  };
-}
-
-function useVideoPlayer(params) {
-  const {
-    service = null,
-    videoId = null,
-    url = null,
-    onLoaded: customOnLoaded = null,
-    onPlay: customOnPlay = null,
-    onPause: customOnPause = null,
-    onEnd: customOnEnd = null,
-    onMetadataChange: customOnMetadataChange = null,
-    onBufferStart: customOnBufferStart = null,
-    onBufferEnded: customOnBufferEnded = null
-  } = params || {};
-  const dailymotionPlayer = useDailymotionPlayer(service === 'dailymotion' ? videoId || url : null, params);
-  const youtubePlayer = useYouTubePlayer(service === 'youtube' ? videoId || url : null, params);
-  const vimeoPlayer = useVimeoPlayer(service === 'vimeo' ? videoId || url : null, params);
-  const nativePlayer = useNativeVideoPlayer(url, params);
-  let player = null;
-  if (service === 'dailymotion') {
-    player = dailymotionPlayer;
-  } else if (service === 'youtube') {
-    player = youtubePlayer;
-  } else if (service === 'vimeo') {
-    player = vimeoPlayer;
-  } else {
-    player = nativePlayer;
-  }
-  const {
-    playing = false,
-    paused = false,
-    buffering = false,
-    ended = false,
-    ready = false,
-    width: metaWidth = null,
-    height: metaHeight = null,
-    duration: metaDuration = null
-  } = player || {};
-  react.useEffect(() => {
-    if (ready && customOnLoaded !== null) {
-      customOnLoaded();
-    }
-  }, [ready, customOnLoaded]);
-  react.useEffect(() => {
-    if (playing && customOnPlay !== null) {
-      customOnPlay();
-    }
-  }, [playing /* , customOnPlay */]);
-  react.useEffect(() => {
-    if (paused && customOnPause !== null) {
-      customOnPause();
-    }
-  }, [paused /* , customOnPause */]);
-  react.useEffect(() => {
-    if (buffering && customOnBufferStart !== null) {
-      customOnBufferStart();
-    } else if (!buffering && customOnBufferEnded !== null) {
-      customOnBufferEnded();
-    }
-  }, [buffering /* , customOnBufferStart, customOnBufferEnded */]);
-  react.useEffect(() => {
-    if (ended && customOnEnd !== null) {
-      customOnEnd();
-    }
-  }, [ended /* , customOnEnd */]);
-  react.useEffect(() => {
-    const hasMetadata = metaWidth !== null || metaHeight !== null || metaDuration !== null;
-    if (hasMetadata && customOnMetadataChange !== null) {
-      customOnMetadataChange({
-        width: metaWidth,
-        height: metaHeight,
-        duration: metaDuration
-      });
-    }
-  }, [metaWidth, metaHeight, metaDuration, customOnMetadataChange]);
-  return player;
-}
-
-function useVisualViewport() {
-  const {
-    width: windowWidth,
-    height: windowHeight
-  } = useWindowSize();
-  const [{
-    width: viewportWidth,
-    height: viewportHeight,
-    ...viewport
-  }, setViewport] = react.useState({
-    width: windowWidth,
-    height: windowHeight
-  });
-  const updateViewport = react.useCallback((viewPort = null) => {
-    const {
-      width: newWidth = 0,
-      height: newHeight = 0,
-      offsetTop: newOffsetTop = 0,
-      offsetLeft: newOffsetLeft = 0,
-      pageLeft: newPageLeft = 0,
-      pageTop: newPageTop = 0
-    } = viewPort || window.visualViewport || {};
-    setViewport({
-      width: newWidth,
-      height: newHeight,
-      offsetTop: newOffsetTop,
-      offsetLeft: newOffsetLeft,
-      pageLeft: newPageLeft,
-      pageTop: newPageTop
-    });
-  }, [setViewport]);
-  react.useEffect(() => {
-    if (typeof window.visualViewport === 'undefined') {
-      return () => {};
-    }
-    const onUpdate = e => {
-      updateViewport(e.target);
-    };
-    updateViewport();
-    window.visualViewport.addEventListener('resize', onUpdate);
-    window.visualViewport.addEventListener('scroll', onUpdate);
-    return () => {
-      window.visualViewport.removeEventListener('resize', onUpdate);
-      window.visualViewport.removeEventListener('scroll', onUpdate);
-    };
-  }, [updateViewport]);
-  return {
-    width: viewportWidth || windowWidth,
-    height: viewportHeight || windowHeight,
-    ...viewport,
-    updateViewport
-  };
-}
-
-const getWindowScroll = () => ({
-  x: typeof window !== 'undefined' ? window.scrollX || 0 : 0,
-  y: typeof window !== 'undefined' ? window.scrollY || 0 : 0
-});
-let currentScroll = null;
-function useWindowScroll({
-  onChange = null,
-  onMount = false,
-  memo = false
-} = {}) {
-  const [scroll, setScroll] = react.useState(() => onMount ? getWindowScroll() : {
-    x: 0,
-    y: 0
-  });
-  const scrollRef = react.useRef(scroll);
-  if (currentScroll === null && memo) {
-    currentScroll = scroll;
-  }
-  const updateScroll = react.useCallback(() => {
-    const newScroll = getWindowScroll();
-    const {
-      x: currentX,
-      y: currentY
-    } = currentScroll || {};
-    if (memo && (currentX !== newScroll.x || currentY !== newScroll.y)) {
-      currentScroll = newScroll;
-    }
-    if (scrollRef.current.x !== newScroll.x || scrollRef.current.y !== newScroll.y) {
-      scrollRef.current = newScroll;
-      setScroll(newScroll);
-      return newScroll;
-    }
-    return null;
-  }, [setScroll, memo]);
-  const onScroll = react.useCallback(() => {
-    const newScroll = updateScroll();
-    if (newScroll !== null && onChange !== null) {
-      onChange(newScroll);
-    }
-  }, [updateScroll, onChange]);
-  useWindowEvent('scroll', onScroll);
-  react.useEffect(() => {
-    onScroll();
-  }, []);
-  return scroll;
-}
-
-exports.documentEventsManager = eventsManager$1;
-exports.getObserver = getObserver;
-exports.useCounter = useCounter;
-exports.useDailymotionPlayer = useDailymotionPlayer;
-exports.useDocumentEvent = useDocumentEvent;
-exports.useIntersectionObserver = useIntersectionObserver;
-exports.useIsVisible = useIsVisible;
-exports.useItemsPaginated = useItemsPaginated;
-exports.useKeyboard = useKeyboard;
-exports.useNativeVideoPlayer = useNativeVideoPlayer;
-exports.useObserver = useObserver;
-exports.usePlayerCurrentTime = usePlayerCurrentTime;
-exports.useResizeObserver = useResizeObserver;
-exports.useScrollTrigger = useScrollTrigger;
-exports.useSupportsWebp = useSupportsWebp;
-exports.useVideoPlayer = useVideoPlayer;
-exports.useVimeoPlayer = useVimeoPlayer;
-exports.useVisualViewport = useVisualViewport;
-exports.useVisualViewportSize = useVisualViewport;
-exports.useWindowEvent = useWindowEvent;
-exports.useWindowScroll = useWindowScroll;
-exports.useWindowSize = useWindowSize;
-exports.useYouTubePlayer = useYouTubePlayer;
-exports.windowEventsManager = eventsManager;