bring headers back one

Author: ryanflorence

docs/ConfirmingNavigation.md

@@ -1,4 +1,4 @@
-## Confirming Navigation
+# Confirming Navigation
 
 React Router provides a [`routerWillLeave` lifecycle hook](Glossary.md#routehook) that React [component](Glossary.md#component)s may use to prevent a transition from happening or to prompt the user before leaving a [route](Glossary.md#route). `routerWillLeave` may either 1) `return false` to cancel the transition or 2) `return` a prompt message that will prompt the user for confirmation before leaving the route.
 
@@ -12,7 +12,7 @@ var Home = React.createClass({
   // Assuming Home is a route component, it may use the
   // Lifecycle mixin to get a routerWillLeave method.
   mixins: [ Lifecycle ],
-  
+
   routerWillLeave(nextLocation) {
     if (!this.state.isSaved)
       return 'Your work is not saved! Are you sure you want to leave?';

docs/DynamicRouting.md

@@ -1,4 +1,4 @@
-## Dynamic Routing
+# Dynamic Routing
 
 React Router is great for small sites like [React.js Training](https://reactjs-training.com) ("React Router brought to you by ...") but it's built with websites like [Facebook](https://www.facebook.com/) and [Twitter](https://twitter.com/) in mind, too.
 

docs/Glossary.md

@@ -1,8 +1,8 @@
-## Glossary
+# Glossary
 
 This is a glossary of common terms used in the React Router codebase and documentation listed in alphabetical order, along with their [type signatures](http://flowtype.org/docs/quick-reference.html).
 
-### Action
+## Action
 
     type Action = 'PUSH' | 'REPLACE' | 'POP';
 
@@ -12,13 +12,13 @@ An *action* describes the type of change to a URL. Possible values are:
   - `REPLACE` – indicates the current item in history was altered
   - `POP` – indicates there is a new current item, i.e. the "current pointer" changed
 
-### Component
+## Component
 
     type Component = ReactClass | string;
 
 A *component* is a React component class or a string (e.g. "div"). Basically, it's anything that can be used as the first argument to [`React.createElement`](https://facebook.github.io/react/docs/top-level-api.html#react.createelement).
 
-### EnterHook
+## EnterHook
 
     type EnterHook = (nextState: RouterState, redirectTo: RedirectFunction, callback?: Function) => any;
 
@@ -28,13 +28,13 @@ If an enter hook needs to execute asynchronously, it may list a 3rd `callback` a
 
 **Caution:** Using the `callback` in an enter hook causes the transition to wait until it is called. **This can lead to a non-responsive UI if you don't call it very quickly**.
 
-### LeaveHook
+## LeaveHook
 
     type LeaveHook = () => any;
 
 A *leave hook* is a user-defined function that is called when a route is about to be unmounted.
 
-### Location
+## Location
 
     type Location = {
       pathname: Pathname;
@@ -52,13 +52,13 @@ A *location* answers two important (philosophical) questions:
 
 New locations are typically created each time the URL changes. You can read more about locations in [the `history` docs](https://github.com/rackt/history/blob/master/docs/Location.md).
 
-### LocationKey
+## LocationKey
 
     type LocationKey = string;
 
 A *location key* is a string that is unique to a particular [`location`](#location). It is the one piece of data that most accurately answers the question "Where am I?".
 
-### LocationState
+## LocationState
 
     type LocationState = ?Object;
 
@@ -69,43 +69,43 @@ This type gets its name from the first argument to HTML5's [`pushState`][pushSta
 [pushState]: https://developer.mozilla.org/en-US/docs/Web/API/History_API#The_pushState()_method
 [replaceState]: https://developer.mozilla.org/en-US/docs/Web/API/History_API#The_replaceState()_method
 
-### Path
+## Path
 
     type Path = Pathname + QueryString;
 
 A *path* represents a URL path.
 
-### Pathname
+## Pathname
 
     type Pathname = string;
 
 A *pathname* is the portion of a URL that describes a hierarchical path, including the preceeding `/`. For example, in `http://example.com/the/path?the=query`, `/the/path` is the pathname. It is synonymous with `window.location.pathname` in web browsers.
 
-### QueryString
+## QueryString
 
     type QueryString = string;
 
 A *query string* is the portion of the URL that follows the [pathname](#pathname), including any preceeding `?`. For example, in `http://example.com/the/path?the=query`, `?the=query` is the query string. It is synonymous with `window.location.search` in web browsers.
 
-### Query
+## Query
 
     type Query = Object;
 
 A *query* is the parsed version of a [query string](#querystring).
 
-### Params
+## Params
 
     type Params = Object;
 
 The word *params* refers to an object of key/value pairs that were parsed out of the original URL's [pathname](#pathname). The values of this object are typically strings, unless there is more than one param with the same name in which case the value is an array.
 
-### RedirectFunction
+## RedirectFunction
 
     type RedirectFunction = (pathname: Pathname | Path, query: ?Query, state: ?LocationState) => void;
 
 A *redirect function* is used in [`onEnter` hooks](#enterhook) to trigger a transition to a new URL.
 
-### Route
+## Route
 
     type Route = {
       component: RouteComponent;
@@ -118,7 +118,7 @@ A *route* specifies a [component](#component) that is part of the user interface
 
 It may help to think of a route as an "entry point" into your UI. You don't need a route for every component in your component hierarchy, only for those places where your UI differs based on the URL.
 
-### RouteComponent
+## RouteComponent
 
     type RouteComponent = Component;
 
@@ -130,19 +130,19 @@ The term *route component* refers to a [component](#component) that is directly
   - `route` – The [route](#route) that declared this component
   - `routeParams` – A subset of the [params](#params) that were specified in the route's [`path`](#routepattern)
 
-### RouteConfig
+## RouteConfig
 
     type RouteConfig = Array<Route>;
 
 A *route config* is an array of [route](#route)s that specifies the order in which routes should be tried when the router attempts to match a URL.
 
-### RouteHook
+## RouteHook
 
     type RouteHook = (nextLocation?: Location) => any;
 
 A *route hook* is a function that is used to prevent the user from leaving a route. On normal transitions, it receives the next [location](#location) as an argument and must either `return false` to cancel the transition or `return` a prompt message to show the user. When invoked during the `beforeunload` event in web browsers, it does not receive any arguments and must `return` a prompt message to cancel the transition.
 
-### RoutePattern
+## RoutePattern
 
     type RoutePattern = string;
 
@@ -154,7 +154,7 @@ A *route pattern* (or "path") is a string that describes a portion of a URL. Pat
 
 Route patterns are relative to the pattern of the parent route unless they begin with a `/`, in which case they begin matching at the beginning of the URL.
 
-### Router
+## Router
 
     type Router = {
       transitionTo: (location: Location) => void;
@@ -172,13 +172,13 @@ There are two primary interfaces for computing a router's next [state](#routerst
 - `history.listen` is to be used in stateful environments (such as web browsers) that need to update the UI over a period of time. This method immediately invokes its `listener` argument once and returns a function that must be called to stop listening for changes
 - `history.match` is a pure asynchronous function that does not update the history's internal state. This makes it ideal for server-side environments where many requests must be handled concurrently
 
-### RouterListener
+## RouterListener
 
     type RouterListener = (error: ?Error, nextState: RouterState) => void;
 
 A *router listener* is a function that is used to listen for changes to a [router](#router)'s [state](#routerstate).
 
-### RouterState
+## RouterState
 
     type RouterState = {
       location: Location;

docs/Introduction.md

@@ -1,8 +1,8 @@
-## Introduction
+# Introduction
 
 To illustrate the problems React Router is going to solve for you, let's build a small application without it.
 
-### Without React Router
+## Without React Router
 
 ```js
 var About = React.createClass({/*...*/});
@@ -92,7 +92,7 @@ path: /inbox
 
 We'd have to make our URL parsing a lot smarter, and we would end up with a lot of code to figure out which branch of nested components to be rendered at any given URL: `App -> About`, `App -> Inbox -> Messages -> Message`, `App -> Inbox -> Messages -> Stats`, etc.
 
-### With React Router
+## With React Router
 
 Let's refactor our app to use React Router.
 
@@ -150,7 +150,7 @@ var routes = {
 React.render(<Router routes={routes} />, document.body);
 ```
 
-### Adding More UI
+## Adding More UI
 
 Alright, now we're ready to nest the inbox messages inside the inbox UI.
 
@@ -189,7 +189,7 @@ React.render((
 
 Now visits to URLs like `inbox/messages/Jkei3c32` will match the new route and nest the UI branch of `App -> Inbox -> Message`.
 
-### Getting URL Parameters
+## Getting URL Parameters
 
 We're going to need to know something about the message in order to fetch it from the server. Route components get some useful properties injected into them when you render, particularly the parameters from the dynamic segment of your path. In our case, `:id`.
 

docs/Link.md

@@ -1,41 +1,41 @@
-## Link
+# Link
 
 The primary way to allow users to navigate around your application.
 `Link` will render a fully accesible anchor tag with the proper href.
 
 A `Link` also knows when the route it links to is active and automatically
 applies its `activeClassName` and/or `activeStyle` when it is.
 
-### Props
+## Props
 
 ### `to`
 
 The path to link to, e.g., `/users/123`.
 
-#### `query`
+### `query`
 
 An object of key:value pairs to be stringified.
 
-#### `state`
+### `state`
 
 State to persist to the `location`.
 
-#### `activeClassName`
+### `activeClassName`
 
 The className a `Link` receives when its route is active. Defaults to `active`.
 
-#### `activeStyle`
+### `activeStyle`
 
 The styles to apply to the link element when its route is active.
 
-#### `onClick`
+### `onClick`
 
 A custom handler for the click event. Works just like a handler on an `<a>`
 tag - calling `e.preventDefault()` or returning `false` will prevent the
 transition from firing, while `e.stopPropagation()` will prevent the event
 from bubbling.
 
-#### *others*
+### *others*
 
 You can also pass props you'd like to be on the `<a>` such as a title, id, className, etc.
 

docs/Plain Route.md

@@ -1,27 +1,27 @@
-## Plain Route
+# Plain Route
 
 A plain JavaScript object route definition. `Router` turns JSX
 `<Route/>`s into these objects, but you can use them directly if you
 prefer. All of the props are the same as `<Route/>` props, except
 those listed here.
 
-### Props
+## Props
 
-#### `childRoutes`
+### `childRoutes`
 
 An array of child routes, same as `children` in JSX route configs.
 
-#### `getChildRoutes(location, callback)`
+### `getChildRoutes(location, callback)`
 
 Same as `childRoutes` but asynchronous and receives the `location`.
 Useful for code-splitting and dynamic route matching (given some state
 or session data to return a different set of child routes).
 
-##### `callback` signature
+#### `callback` signature
 
 `cb(err, routesArray)`
 
-### Examples
+## Examples
 
 ```js
 let myRoute = {

docs/README.md

@@ -1,4 +1,4 @@
-## Table of Contents
+# Table of Contents
 
 - [Glossary](Glossary.md)
 - Guides

docs/Redirect.md

@@ -1,24 +1,24 @@
-## Redirect
+# Redirect
 
 A `Redirect` sets up a redirect to another route in your application to
 maintain old URLs.
 
-### Props
+## Props
 
-#### `from`
+### `from`
 
 The path you want to redirect from, including dynamic segments.
 
-#### `to`
+### `to`
 
 The path you want to redirect to.
 
-#### `query`
+### `query`
 
 By default, the query parameters will just pass through but you can
 specify them if you need to.
 
-### Example
+## Example
 
 ```js
 // lets say we want to change from `/profile/123` to `/about/123`