text: 'use strict';
  
  var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
  
  import warning from 'warning';
  import { canUseDOM } from './ExecutionEnvironment';
  import { parsePath } from './PathUtils';
  import runTransitionHook from './runTransitionHook';
  import deprecate from './deprecate';
  
  function useBasename(createHistory) {
    return function () {
      var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
  
      var history = createHistory(options);
  
      var basename = options.basename;
  
      var checkedBaseHref = false;
  
      function checkBaseHref() {
        if (checkedBaseHref) {
          return;
        }
  
        // Automatically use the value of <base href> in HTML
        // documents as basename if it's not explicitly given.
        if (basename == null && canUseDOM) {
          var base = document.getElementsByTagName('base')[0];
          var baseHref = base && base.getAttribute('href');
  
          if (baseHref != null) {
            basename = baseHref;
  
            process.env.NODE_ENV !== 'production' ? warning(false, 'Automatically setting basename using <base href> is deprecated and will ' + 'be removed in the next major release. The semantics of <base href> are ' + 'subtly different from basename. Please pass the basename explicitly in ' + 'the options to createHistory') : undefined;
          }
        }
  
        checkedBaseHref = true;
      }
  
      function addBasename(location) {
        checkBaseHref();
  
        if (basename && location.basename == null) {
          if (location.pathname.indexOf(basename) === 0) {
            location.pathname = location.pathname.substring(basename.length);
            location.basename = basename;
  
            if (location.pathname === '') location.pathname = '/';
          } else {
            location.basename = '';
          }
        }
  
        return location;
      }
  
      function prependBasename(location) {
        checkBaseHref();
  
        if (!basename) return location;
  
        if (typeof location === 'string') location = parsePath(location);
  
        var pname = location.pathname;
        var normalizedBasename = basename.slice(-1) === '/' ? basename : basename + '/';
        var normalizedPathname = pname.charAt(0) === '/' ? pname.slice(1) : pname;
        var pathname = normalizedBasename + normalizedPathname;
  
        return _extends({}, location, {
          pathname: pathname
        });
      }
  
      // Override all read methods with basename-aware versions.
      function listenBefore(hook) {
        return history.listenBefore(function (location, callback) {
          runTransitionHook(hook, addBasename(location), callback);
        });
      }
  
      function listen(listener) {
        return history.listen(function (location) {
          listener(addBasename(location));
        });
      }
  
      // Override all write methods with basename-aware versions.
      function push(location) {
        history.push(prependBasename(location));
      }
  
      function replace(location) {
        history.replace(prependBasename(location));
      }
  
      function createPath(location) {
        return history.createPath(prependBasename(location));
      }
  
      function createHref(location) {
        return history.createHref(prependBasename(location));
      }
  
      function createLocation(location) {
        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
          args[_key - 1] = arguments[_key];
        }
  
        return addBasename(history.createLocation.apply(history, [prependBasename(location)].concat(args)));
      }
  
      // deprecated
      function pushState(state, path) {
        if (typeof path === 'string') path = parsePath(path);
  
        push(_extends({ state: state }, path));
      }
  
      // deprecated
      function replaceState(state, path) {
        if (typeof path === 'string') path = parsePath(path);
  
        replace(_extends({ state: state }, path));
      }
  
      return _extends({}, history, {
        listenBefore: listenBefore,
        listen: listen,
        push: push,
        replace: replace,
        createPath: createPath,
        createHref: createHref,
        createLocation: createLocation,
  
        pushState: deprecate(pushState, 'pushState is deprecated; use push instead'),
        replaceState: deprecate(replaceState, 'replaceState is deprecated; use replace instead')
      });
    };
  }
  
  export default useBasename;