Improve syntax highlighting

Author: DannyDelott

docs/API.md

@@ -53,15 +53,15 @@ Alias for `children`.
 ##### `history`
 The history the router should listen to. Typically `browserHistory` or `hashHistory`.
 
-```jsx
+```js
 import { browserHistory } from 'react-router'
 ReactDOM.render(<Router history={browserHistory} />, el)
 ```
 
 ##### `createElement(Component, props)`
 When the router is ready to render a branch of route components, it will use this function to create the elements. You may want to take control of creating the elements when you're using some sort of data abstraction, like setting up subscriptions to stores, or passing in some sort of application module to each component via props.
 
-```jsx
+```js
 <Router createElement={createElement} />
 
 // default behavior
@@ -140,7 +140,7 @@ You can also pass props you'd like to be on the `<a>` such as a `title`, `id`, `
 #### Example
 Given a route like `<Route path="/users/:userId" />`:
 
-```jsx
+```js
 <Link to={`/users/${user.id}`} activeClassName="active">{user.name}</Link>
 // becomes one of these depending on your History and if the route is
 // active
@@ -167,7 +167,7 @@ You can explicit specify `router` as a prop to the wrapper component to override
 ##### `withRef`
 If `true`, the wrapper component attaches a ref to the wrapped component, which can then be accessed via `getWrappedInstance`.
 
-```jsx
+```js
 const WrapperComponent = withRouter(MyComponent, { withRef: true })
 
 // Given a `wrapperInstance` that is of type `WrapperComponent`:
@@ -186,7 +186,7 @@ Contains data and methods relevant to routing. Most useful for imperatively tran
 ##### `push(pathOrLoc)`
 Transitions to a new URL, adding a new entry in the browser history.
 
-```jsx
+```js
 router.push('/users/12')
 
 // or with a location descriptor object
@@ -256,7 +256,7 @@ If left undefined, the router will try to match the child routes.
 A single component to be rendered when the route matches the URL. It can
 be rendered by the parent route component with `this.props.children`.
 
-```jsx
+```js
 const routes = (
   <Route path="/" component={App}>
     <Route path="groups" component={Groups} />
@@ -279,7 +279,7 @@ class App extends React.Component {
 ##### `components`
 Routes can define one or more named components as an object of `[name]: component` pairs to be rendered when the path matches the URL. They can be rendered by the parent route component with `this.props[name]`.
 
-```jsx
+```js
 // Think of it outside the context of the router - if you had pluggable
 // portions of your `render`, you might do it like this:
 // <App main={<Users />} sidebar={<UsersSidebar />} />
@@ -330,7 +330,7 @@ Same as `component` but asynchronous, useful for code-splitting.
 ###### `callback` signature
 `cb(err, component)`
 
-```jsx
+```js
 <Route path="courses/:courseId" getComponent={(nextState, cb) => {
   // do asynchronous stuff to find the components
   cb(null, Course)
@@ -344,7 +344,7 @@ code-splitting.
 ###### `callback` signature
 `cb(err, components)`
 
-```jsx
+```js
 <Route path="courses/:courseId" getComponents={(nextState, cb) => {
   // do asynchronous stuff to find the components
   cb(null, {sidebar: CourseSidebar, content: Course})
@@ -362,7 +362,7 @@ If `callback` is listed as a 3rd argument, this hook will run asynchronously, an
 ###### `callback` signature
 `cb(err)`
 
-```jsx
+```js
 const userIsInATeam = (nextState, replace, callback) => {
   fetch(...)
     .then(response = response.json())
@@ -403,7 +403,7 @@ Same as `childRoutes` but asynchronous and receives `partialNextState`. Useful f
 ###### `callback` signature
 `cb(err, routesArray)`
 
-```jsx
+```js
 let myRoute = {
   path: 'course/:courseId',
   childRoutes: [
@@ -450,7 +450,7 @@ Same as `indexRoute`, but asynchronous and receives `partialNextState`. As with
 ###### `callback` signature
 `cb(err, route)`
 
-```jsx
+```js
 // For example:
 let myIndexRoute = {
   component: MyIndex
@@ -486,7 +486,7 @@ The path you want to redirect to.
 ##### `query`
 By default, the query parameters will just pass through but you can specify them if you need to.
 
-```jsx
+```js
 // Say we want to change from `/profile/123` to `/about/123`
 // and redirect `/get-in-touch` to `/contact`
 <Route component={App}>
@@ -498,7 +498,7 @@ By default, the query parameters will just pass through but you can specify them
 
 Note that the `<Redirect>` can be placed anywhere in the route hierarchy, though [normal precedence](/docs/guides/RouteMatching.md#precedence) rules apply. If you'd prefer the redirects to be next to their respective routes, the `from` path will match the same as a regular route `path`.
 
-```jsx
+```js
 <Route path="course/:courseId">
   <Route path="dashboard" />
   {/* /course/123/home -> /course/123/dashboard */}
@@ -549,7 +549,7 @@ A subset of `this.props.params` that were directly specified in this component's
 The matched child route element to be rendered. If the route has [named components](/docs/API.md#named-components) then this will be undefined, and the components will instead be available as direct properties on `this.props`.
 
 ##### Example
-```jsx
+```js
 render((
   <Router>
     <Route path="/" component={App}>
@@ -577,7 +577,7 @@ class App extends React.Component {
 When a route has one or more named components, the child elements are available by name on `this.props`. In this case `this.props.children` will be undefined. All route components can participate in the nesting.
 
 #### Example
-```jsx
+```js
 render((
   <Router>
     <Route path="/" component={App}>
@@ -649,7 +649,7 @@ and
 enhancers from `history`
 
 #### Example
-```jsx
+```js
 import createHashHistory from 'history/lib/createHashHistory'
 const history = useRouterHistory(createHashHistory)({ queryKey: false })
 ```

docs/Glossary.md

@@ -27,7 +27,7 @@ This is a glossary of common terms used in the React Router codebase and documen
 
 ## Action
 
-```jsx
+```js
 type Action = 'PUSH' | 'REPLACE' | 'POP';
 ```
 
@@ -39,15 +39,15 @@ An *action* describes the type of change to a URL. Possible values are:
 
 ## Component
 
-```jsx
+```js
 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
 
-```jsx
+```js
 type EnterHook = (nextState: RouterState, replace: RedirectFunction, callback?: Function) => any;
 ```
 
@@ -65,15 +65,15 @@ A *hash* is a string that represents the hash portion of the URL. It is synonymo
 
 ## LeaveHook
 
-```jsx
+```js
 type LeaveHook = (prevState: RouterState) => any;
 ```
 
 A *leave hook* is a user-defined function that is called when a route is about to be unmounted. It receives the previous [router state](#routerstate) as its first argument.
 
 ## Location
 
-```jsx
+```js
 type Location = {
   pathname: Pathname;
   search: QueryString;
@@ -108,15 +108,15 @@ You can read more about location descriptors in [the `history` docs](https://git
 
 ## LocationKey
 
-```jsx
+```js
 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
 
-```jsx
+```js
 type LocationState = ?Object;
 ```
 
@@ -129,55 +129,55 @@ This type gets its name from the first argument to HTML5's [`pushState`][pushSta
 
 ## Params
 
-```jsx
+```js
 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.
 
 ## Path
 
-```jsx
+```js
 type Path = Pathname + QueryString + Hash;
 ```
 
 A *path* represents a URL path.
 
 ## Pathname
 
-```jsx
+```js
 type Pathname = string;
 ```
 
 A *pathname* is the portion of a URL that describes a hierarchical path, including the preceding `/`. 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.
 
 ## Query
 
-```jsx
+```js
 type Query = Object;
 ```
 
 A *query* is the parsed version of a [query string](#querystring).
 
 ## QueryString
 
-```jsx
+```js
 type QueryString = string;
 ```
 
 A *query string* is the portion of the URL that follows the [pathname](#pathname), including any preceding `?`. 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.
 
 ## RedirectFunction
 
-```jsx
+```js
 type RedirectFunction = (state: ?LocationState, pathname: Pathname | Path, query: ?Query) => void;
 ```
 
 A *redirect function* is used in [`onEnter` hooks](#enterhook) to trigger a transition to a new URL.
 
 ## Route
 
-```jsx
+```js
 type Route = {
   component: RouteComponent;
   path: ?RoutePattern;
@@ -192,7 +192,7 @@ It may help to think of a route as an "entry point" into your UI. You don't need
 
 ## RouteComponent
 
-```jsx
+```js
 type RouteComponent = Component;
 ```
 
@@ -208,23 +208,23 @@ Route components should generally be component classes rather than strings. This
 
 ## RouteConfig
 
-```jsx
+```js
 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
 
-```jsx
+```js
 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
 
-```jsx
+```js
 type RoutePattern = string;
 ```
 
@@ -239,7 +239,7 @@ Route patterns are relative to the pattern of the parent route unless they begin
 
 ## Router
 
-```jsx
+```js
 type Router = {
   push(location: LocationDescriptor) => void;
   replace(location: LocationDescriptor) => void;
@@ -255,7 +255,7 @@ A *router* object allows for procedural manipulation of the routing state.
 
 ## RouterState
 
-```jsx
+```js
 type RouterState = {
   location: Location;
   routes: Array<Route>;

docs/Introduction.md

@@ -6,7 +6,7 @@ To illustrate the problems React Router is going to solve for you, let's build a
 
 ### Without React Router
 
-```jsx
+```js
 import React from 'react'
 import { render } from 'react-dom'
 
@@ -101,7 +101,7 @@ We'd have to make our URL parsing a lot smarter, and we would end up with a lot
 
 Let's refactor our app to use React Router.
 
-```jsx
+```js
 import React from 'react'
 import { render } from 'react-dom'
 
@@ -148,7 +148,7 @@ React Router knows how to build nested UI for us, so we don't have to manually f
 
 Internally, the router converts your `<Route>` element hierarchy to a [route config](/docs/Glossary.md#routeconfig). But if you're not digging the JSX you can use plain objects instead:
 
-```jsx
+```js
 const routes = {
   path: '/',
   component: App,
@@ -166,7 +166,7 @@ render(<Router history={history} routes={routes} />, document.body)
 
 Alright, now we're ready to nest the inbox messages inside the inbox UI.
 
-```jsx
+```js
 // Make a new component to render inside of Inbox
 const Message = React.createClass({
   render() {
@@ -228,7 +228,7 @@ And visits to `/inbox` will build this:
 
 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`.
 
-```jsx
+```js
 const Message = React.createClass({
 
   componentDidMount() {