export default function(paths: PathConfigs<BrowserState> = [], history: History = createBrowserHistory()) {
  let currentPath = locationToPathConfigAndMatch(paths, history.location).path;

  function syncToBrowser(s: BrowserState, push: boolean = true): void {
    (push ? history.push : history.replace)(serializeBrowserState(paths, s));
  }

  function onBrowserChange(callback: (s: BrowserState, action: Action) => void): void {
    history.listen((location, action) => {
      currentPath = locationToPathConfigAndMatch(paths, location).path;
      callback(parseBrowserState(paths, location), action);
    });
    callback(parseBrowserState(paths, history.location), 'PUSH');
  }

  function dryRunBrowserTransition<S extends BrowserState>(s: S): S {
    return cleanupPathParams(s, currentPath, browserStateToPathConfig(paths, s)) as S;
  }

  return { syncToBrowser, onBrowserChange, dryRunBrowserTransition };
}

import createHistory from "history/createBrowserHistory";
import { withProps } from "recompose";

export default withProps({ history: createHistory() });

import { createStore, combineReducers, applyMiddleware } from 'redux';
import { routerReducer, routerMiddleware, RouterState } from 'react-router-redux';
import { default as createSagaMiddleware } from 'redux-saga';
import { mainReducer, MainState } from '../reducers/Main';
import { fbScenarioReducer, FBScenarioState } from '../reducers/FBScenario';
import { logger } from '../middleware/logger';
import createBrowserHistory from 'history/createBrowserHistory';
import { rootSaga } from '../middleware/postScenario';

export const history = createBrowserHistory();
const router = routerMiddleware(history);
const sagaMiddleware = createSagaMiddleware();

export default createStore(
  combineReducers({
    main: mainReducer,
    scenario: fbScenarioReducer,
    router: routerReducer,
  }),
  applyMiddleware(logger, router, sagaMiddleware),
);

sagaMiddleware.run(rootSaga);

export type ReduxState = {
  main: MainState;
  scenario: FBScenarioState;
  router: RouterState;
};

import createHistory from 'history/createBrowserHistory';
const history = createHistory({
    basename: ''
});

export default history;

ifOnlyWeHadTopLevelAwaitAndNotSyncModules(tiles).then(() => {
  const history = createHistory()

  const sagaMiddleware = createSagaMiddleware();

  const store = createStore<State, Action, any, any>(
    reduce,
    (window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose)(
      applyMiddleware(
        thunk,
        sagaMiddleware,
        routerMiddleware(history)
      )
    )
  );

  sagaMiddleware.run(sagas)

  main(store, history);
});

// tslint:disable
import createHistory from 'history/createBrowserHistory';

// Using browser history (the modern one, without `#`) as `react-router-redux`'s history.
export const history = createHistory();

import { routerMiddleware } from 'react-router-redux'
import { applyMiddleware, compose, createStore } from 'redux'
import { createLogger } from 'redux-logger'
import createHistory from 'history/createBrowserHistory'
import createSagasMiddleware from 'redux-saga'

import { createAnalyticsMiddleware } from '@dapps/modules/analytics/middleware'
import { createStorageMiddleware } from '@dapps/modules/storage/middleware'

import { rootReducer } from './reducer'
import { rootSaga } from './sagas'

const composeEnhancers =
  (window as any).__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose

const history = createHistory()

const historyMiddleware = routerMiddleware(history)
const sagasMiddleware = createSagasMiddleware()
const loggerMiddleware = createLogger({
  collapsed: () => true,
  predicate: (_: any, action) =>
    env.isDevelopment() || action.type.includes('Failure')
})
const analyticsMiddleware = createAnalyticsMiddleware(
  env.get('REACT_APP_SEGMENT_API_KEY')
)
const { storageMiddleware, loadStorageMiddleware } = createStorageMiddleware({
  storageKey: env.get('REACT_APP_LOCAL_STORAGE_KEY', 'decentraland-agora')
})

import createHistory from 'history/createBrowserHistory';
export const firekylinHistory = createHistory({
    basename: process.env.basename
});