WIP - add extractor, generate snippet_data

node_modules/gatsby/cache-dir/commonjs/api-runner-browser-plugins.js

@@ -0,0 +1,15 @@
+"use strict";
+
+// During bootstrap, we write requires at top of this file which looks
+// basically like:
+// module.exports = [
+//   {
+//     plugin: require("/path/to/plugin1/gatsby-browser.js"),
+//     options: { ... },
+//   },
+//   {
+//     plugin: require("/path/to/plugin2/gatsby-browser.js"),
+//     options: { ... },
+//   },
+// ]
+module.exports = [];

node_modules/gatsby/cache-dir/commonjs/api-runner-browser.js

@@ -0,0 +1,61 @@
+"use strict";
+
+const plugins = require(`./api-runner-browser-plugins`);
+
+const {
+  getResourcesForPathname,
+  getResourcesForPathnameSync,
+  getResourceURLsForPathname,
+  loadPage,
+  loadPageSync
+} = require(`./loader`).publicLoader;
+
+exports.apiRunner = (api, args = {}, defaultReturn, argTransform) => {
+  // Hooks for gatsby-cypress's API handler
+  if (process.env.CYPRESS_SUPPORT) {
+    if (window.___apiHandler) {
+      window.___apiHandler(api);
+    } else if (window.___resolvedAPIs) {
+      window.___resolvedAPIs.push(api);
+    } else {
+      window.___resolvedAPIs = [api];
+    }
+  }
+
+  let results = plugins.map(plugin => {
+    if (!plugin.plugin[api]) {
+      return undefined;
+    } // Deprecated April 2019. Use `loadPageSync` instead
+
+
+    args.getResourcesForPathnameSync = getResourcesForPathnameSync; // Deprecated April 2019. Use `loadPage` instead
+
+    args.getResourcesForPathname = getResourcesForPathname;
+    args.getResourceURLsForPathname = getResourceURLsForPathname;
+    args.loadPage = loadPage;
+    args.loadPageSync = loadPageSync;
+    const result = plugin.plugin[api](args, plugin.options);
+
+    if (result && argTransform) {
+      args = argTransform({
+        args,
+        result,
+        plugin
+      });
+    }
+
+    return result;
+  }); // Filter out undefined results.
+
+  results = results.filter(result => typeof result !== `undefined`);
+
+  if (results.length > 0) {
+    return results;
+  } else if (defaultReturn) {
+    return [defaultReturn];
+  } else {
+    return [];
+  }
+};
+
+exports.apiRunnerAsync = (api, args, defaultReturn) => plugins.reduce((previous, next) => next.plugin[api] ? previous.then(() => next.plugin[api](args, next.options)) : previous, Promise.resolve());

node_modules/gatsby/cache-dir/commonjs/api-runner-ssr.js

@@ -0,0 +1,48 @@
+"use strict";
+
+// During bootstrap, we write requires at top of this file which looks like:
+// var plugins = [
+//   {
+//     plugin: require("/path/to/plugin1/gatsby-ssr.js"),
+//     options: { ... },
+//   },
+//   {
+//     plugin: require("/path/to/plugin2/gatsby-ssr.js"),
+//     options: { ... },
+//   },
+// ]
+const apis = require(`./api-ssr-docs`); // Run the specified API in any plugins that have implemented it
+
+
+module.exports = (api, args, defaultReturn, argTransform) => {
+  if (!apis[api]) {
+    console.log(`This API doesn't exist`, api);
+  } // Run each plugin in series.
+  // eslint-disable-next-line no-undef
+
+
+  let results = plugins.map(plugin => {
+    if (!plugin.plugin[api]) {
+      return undefined;
+    }
+
+    const result = plugin.plugin[api](args, plugin.options);
+
+    if (result && argTransform) {
+      args = argTransform({
+        args,
+        result
+      });
+    }
+
+    return result;
+  }); // Filter out undefined results.
+
+  results = results.filter(result => typeof result !== `undefined`);
+
+  if (results.length > 0) {
+    return results;
+  } else {
+    return [defaultReturn];
+  }
+};

node_modules/gatsby/cache-dir/commonjs/api-ssr-docs.js

@@ -0,0 +1,194 @@
+"use strict";
+
+/**
+ * Object containing options defined in `gatsby-config.js`
+ * @typedef {object} pluginOptions
+ */
+
+/**
+ * Replace the default server renderer. This is useful for integration with
+ * Redux, css-in-js libraries, etc. that need custom setups for server
+ * rendering.
+ * @param {object} $0
+ * @param {string} $0.pathname The pathname of the page currently being rendered.
+ * @param {function} $0.replaceBodyHTMLString Call this with the HTML string
+ * you render. **WARNING** if multiple plugins implement this API it's the
+ * last plugin that "wins". TODO implement an automated warning against this.
+ * @param {function} $0.setHeadComponents Takes an array of components as its
+ * first argument which are added to the `headComponents` array which is passed
+ * to the `html.js` component.
+ * @param {function} $0.setHtmlAttributes Takes an object of props which will
+ * spread into the `<html>` component.
+ * @param {function} $0.setBodyAttributes Takes an object of props which will
+ * spread into the `<body>` component.
+ * @param {function} $0.setPreBodyComponents Takes an array of components as its
+ * first argument which are added to the `preBodyComponents` array which is passed
+ * to the `html.js` component.
+ * @param {function} $0.setPostBodyComponents Takes an array of components as its
+ * first argument which are added to the `postBodyComponents` array which is passed
+ * to the `html.js` component.
+ * @param {function} $0.setBodyProps Takes an object of data which
+ * is merged with other body props and passed to `html.js` as `bodyProps`.
+ * @param {pluginOptions} pluginOptions
+ * @example
+ * // From gatsby-plugin-glamor
+ * const { renderToString } = require("react-dom/server")
+ * const inline = require("glamor-inline")
+ *
+ * exports.replaceRenderer = ({ bodyComponent, replaceBodyHTMLString }) => {
+ *   const bodyHTML = renderToString(bodyComponent)
+ *   const inlinedHTML = inline(bodyHTML)
+ *
+ *   replaceBodyHTMLString(inlinedHTML)
+ * }
+ */
+exports.replaceRenderer = true;
+/**
+ * Called after every page Gatsby server renders while building HTML so you can
+ * set head and body components to be rendered in your `html.js`.
+ *
+ * Gatsby does a two-pass render for HTML. It loops through your pages first
+ * rendering only the body and then takes the result body HTML string and
+ * passes it as the `body` prop to your `html.js` to complete the render.
+ *
+ * It's often handy to be able to send custom components to your `html.js`.
+ * For example, it's a very common pattern for React.js libraries that
+ * support server rendering to pull out data generated during the render to
+ * add to your HTML.
+ *
+ * Using this API over [`replaceRenderer`](#replaceRenderer) is preferable as
+ * multiple plugins can implement this API where only one plugin can take
+ * over server rendering. However, if your plugin requires taking over server
+ * rendering then that's the one to
+ * use
+ * @param {object} $0
+ * @param {string} $0.pathname The pathname of the page currently being rendered.
+ * @param {function} $0.setHeadComponents Takes an array of components as its
+ * first argument which are added to the `headComponents` array which is passed
+ * to the `html.js` component.
+ * @param {function} $0.setHtmlAttributes Takes an object of props which will
+ * spread into the `<html>` component.
+ * @param {function} $0.setBodyAttributes Takes an object of props which will
+ * spread into the `<body>` component.
+ * @param {function} $0.setPreBodyComponents Takes an array of components as its
+ * first argument which are added to the `preBodyComponents` array which is passed
+ * to the `html.js` component.
+ * @param {function} $0.setPostBodyComponents Takes an array of components as its
+ * first argument which are added to the `postBodyComponents` array which is passed
+ * to the `html.js` component.
+ * @param {function} $0.setBodyProps Takes an object of data which
+ * is merged with other body props and passed to `html.js` as `bodyProps`.
+ * @param {pluginOptions} pluginOptions
+ * @example
+ * const { Helmet } = require("react-helmet")
+ *
+ * exports.onRenderBody = (
+ *   { setHeadComponents, setHtmlAttributes, setBodyAttributes },
+ *   pluginOptions
+ * ) => {
+ *   const helmet = Helmet.renderStatic()
+ *   setHtmlAttributes(helmet.htmlAttributes.toComponent())
+ *   setBodyAttributes(helmet.bodyAttributes.toComponent())
+ *   setHeadComponents([
+ *     helmet.title.toComponent(),
+ *     helmet.link.toComponent(),
+ *     helmet.meta.toComponent(),
+ *     helmet.noscript.toComponent(),
+ *     helmet.script.toComponent(),
+ *     helmet.style.toComponent(),
+ *   ])
+ * }
+ */
+
+exports.onRenderBody = true;
+/**
+ * Called after every page Gatsby server renders while building HTML so you can
+ * replace head components to be rendered in your `html.js`. This is useful if
+ * you need to reorder scripts or styles added by other plugins.
+ * @param {object} $0
+ * @param {string} $0.pathname The pathname of the page currently being rendered.
+ * @param {Array<ReactNode>} $0.getHeadComponents Returns the current `headComponents` array.
+ * @param {function} $0.replaceHeadComponents Takes an array of components as its
+ * first argument which replace the `headComponents` array which is passed
+ * to the `html.js` component. **WARNING** if multiple plugins implement this
+ * API it's the last plugin that "wins".
+ * @param {Array<ReactNode>} $0.getPreBodyComponents Returns the current `preBodyComponents` array.
+ *  @param {function} $0.replacePreBodyComponents Takes an array of components as its
+ * first argument which replace the `preBodyComponents` array which is passed
+ * to the `html.js` component. **WARNING** if multiple plugins implement this
+ * API it's the last plugin that "wins".
+ * @param {Array<ReactNode>} $0.getPostBodyComponents Returns the current `postBodyComponents` array.
+ *  @param {function} $0.replacePostBodyComponents Takes an array of components as its
+ * first argument which replace the `postBodyComponents` array which is passed
+ * to the `html.js` component. **WARNING** if multiple plugins implement this
+ * API it's the last plugin that "wins".
+ * @param {pluginOptions} pluginOptions
+ * @example
+ * // Move Typography.js styles to the top of the head section so they're loaded first.
+ * exports.onPreRenderHTML = ({ getHeadComponents, replaceHeadComponents }) => {
+ *   const headComponents = getHeadComponents()
+ *   headComponents.sort((x, y) => {
+ *     if (x.key === 'TypographyStyle') {
+ *       return -1
+ *     } else if (y.key === 'TypographyStyle') {
+ *       return 1
+ *     }
+ *     return 0
+ *   })
+ *   replaceHeadComponents(headComponents)
+ * }
+ */
+
+exports.onPreRenderHTML = true;
+/**
+ * Allow a plugin to wrap the page element.
+ *
+ * This is useful for setting wrapper component around pages that won't get
+ * unmounted on page change. For setting Provider components use [wrapRootElement](#wrapRootElement).
+ *
+ * _Note:_ [There is equivalent hook in Browser API](/docs/browser-apis/#wrapPageElement)
+ * @param {object} $0
+ * @param {ReactNode} $0.element The "Page" React Element built by Gatsby.
+ * @param {object} $0.props Props object used by page.
+ * @param {pluginOptions} pluginOptions
+ * @returns {ReactNode} Wrapped element
+ * @example
+ * const React = require("react")
+ * const Layout = require("./src/components/layout").default
+ *
+ * exports.wrapPageElement = ({ element, props }) => {
+ *   // props provide same data to Layout as Page element will get
+ *   // including location, data, etc - you don't need to pass it
+ *   return <Layout {...props}>{element}</Layout>
+ * }
+ */
+
+exports.wrapPageElement = true;
+/**
+ * Allow a plugin to wrap the root element.
+ *
+ * This is useful to setup any Providers component that will wrap your application.
+ * For setting persistent UI elements around pages use [wrapPageElement](#wrapPageElement).
+ *
+ * _Note:_ [There is equivalent hook in Browser API](/docs/browser-apis/#wrapRootElement)
+ * @param {object} $0
+ * @param {ReactNode} $0.element The "Root" React Element built by Gatsby.
+ * @param {pluginOptions} pluginOptions
+ * @returns {ReactNode} Wrapped element
+ * @example
+ * const React = require("react")
+ * const { Provider } = require("react-redux")
+ *
+ * const createStore = require("./src/state/createStore")
+ * const store = createStore()
+ *
+ * exports.wrapRootElement = ({ element }) => {
+ *   return (
+ *     <Provider store={store}>
+ *       {element}
+ *     </Provider>
+ *   )
+ * }
+ */
+
+exports.wrapRootElement = true;

node_modules/gatsby/cache-dir/commonjs/app.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactDom = _interopRequireDefault(require("react-dom"));
+
+var _domready = _interopRequireDefault(require("@mikaelkristiansson/domready"));
+
+var _socketIo = _interopRequireDefault(require("./socketIo"));
+
+var _emitter = _interopRequireDefault(require("./emitter"));
+
+var _apiRunnerBrowser = require("./api-runner-browser");
+
+var _loader = require("./loader");
+
+var _devLoader = _interopRequireDefault(require("./dev-loader"));
+
+var _syncRequires = _interopRequireDefault(require("./sync-requires"));
+
+var _matchPaths = _interopRequireDefault(require("./match-paths.json"));
+
+// Generated during bootstrap
+window.___emitter = _emitter.default;
+const loader = new _devLoader.default(_syncRequires.default, _matchPaths.default);
+(0, _loader.setLoader)(loader);
+loader.setApiRunner(_apiRunnerBrowser.apiRunner);
+window.___loader = _loader.publicLoader; // Let the site/plugins run code very early.
+
+(0, _apiRunnerBrowser.apiRunnerAsync)(`onClientEntry`).then(() => {
+  // Hook up the client to socket.io on server
+  const socket = (0, _socketIo.default)();
+
+  if (socket) {
+    socket.on(`reload`, () => {
+      window.location.reload();
+    });
+  }
+  /**
+   * Service Workers are persistent by nature. They stick around,
+   * serving a cached version of the site if they aren't removed.
+   * This is especially frustrating when you need to test the
+   * production build on your local machine.
+   *
+   * Let's warn if we find service workers in development.
+   */
+
+
+  if (`serviceWorker` in navigator) {
+    navigator.serviceWorker.getRegistrations().then(registrations => {
+      if (registrations.length > 0) console.warn(`Warning: found one or more service workers present.`, `If your site isn't behaving as expected, you might want to remove these.`, registrations);
+    });
+  }
+
+  const rootElement = document.getElementById(`___gatsby`);
+  const renderer = (0, _apiRunnerBrowser.apiRunner)(`replaceHydrateFunction`, undefined, _reactDom.default.render)[0];
+  Promise.all([loader.loadPage(`/dev-404-page/`), loader.loadPage(`/404.html`), loader.loadPage(window.location.pathname)]).then(() => {
+    const preferDefault = m => m && m.default || m;
+
+    let Root = preferDefault(require(`./root`));
+    (0, _domready.default)(() => {
+      renderer(_react.default.createElement(Root, null), rootElement, () => {
+        (0, _apiRunnerBrowser.apiRunner)(`onInitialClientRender`);
+      });
+    });
+  });
+});

node_modules/gatsby/cache-dir/commonjs/create-react-context.js

@@ -0,0 +1,11 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _default = _react.default.createContext;
+exports.default = _default;

node_modules/gatsby/cache-dir/commonjs/default-html.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = HTML;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+function HTML(props) {
+  return _react.default.createElement("html", props.htmlAttributes, _react.default.createElement("head", null, _react.default.createElement("meta", {
+    charSet: "utf-8"
+  }), _react.default.createElement("meta", {
+    httpEquiv: "x-ua-compatible",
+    content: "ie=edge"
+  }), _react.default.createElement("meta", {
+    name: "viewport",
+    content: "width=device-width, initial-scale=1, shrink-to-fit=no"
+  }), props.headComponents), _react.default.createElement("body", props.bodyAttributes, props.preBodyComponents, _react.default.createElement("noscript", {
+    key: "noscript",
+    id: "gatsby-noscript"
+  }, "This app works best with JavaScript enabled."), _react.default.createElement("div", {
+    key: `body`,
+    id: "___gatsby",
+    dangerouslySetInnerHTML: {
+      __html: props.body
+    }
+  }), props.postBodyComponents));
+}
+
+HTML.propTypes = {
+  htmlAttributes: _propTypes.default.object,
+  headComponents: _propTypes.default.array,
+  bodyAttributes: _propTypes.default.object,
+  preBodyComponents: _propTypes.default.array,
+  body: _propTypes.default.string,
+  postBodyComponents: _propTypes.default.array
+};

node_modules/gatsby/cache-dir/commonjs/dev-loader.js

@@ -0,0 +1,45 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _loader = require("./loader");
+
+var _findPath = require("./find-path");
+
+class DevLoader extends _loader.BaseLoader {
+  constructor(syncRequires, matchPaths) {
+    const loadComponent = chunkName => Promise.resolve(syncRequires.components[chunkName]);
+
+    super(loadComponent, matchPaths);
+  }
+
+  loadPage(pagePath) {
+    const realPath = (0, _findPath.cleanPath)(pagePath);
+    return super.loadPage(realPath).then(result => {
+      require(`./socketIo`).getPageData(realPath);
+
+      return result;
+    });
+  }
+
+  loadPageDataJson(rawPath) {
+    return super.loadPageDataJson(rawPath).then(data => {
+      // when we can't find a proper 404.html we fallback to dev-404-page
+      // we need to make sure to mark it as not found.
+      if (data.status === `failure`) {
+        return this.loadPageDataJson(`/dev-404-page/`).then(result => Object.assign({}, data, result));
+      }
+
+      return data;
+    });
+  }
+
+  doPrefetch(pagePath) {
+    return Promise.resolve(require(`./socketIo`).getPageData(pagePath));
+  }
+
+}
+
+var _default = DevLoader;
+exports.default = _default;

node_modules/gatsby/cache-dir/commonjs/develop-static-entry.js

@@ -0,0 +1,135 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _server = require("react-dom/server");
+
+var _lodash = require("lodash");
+
+var _apiRunnerSsr = _interopRequireDefault(require("./api-runner-ssr"));
+
+// import testRequireError from "./test-require-error"
+// For some extremely mysterious reason, webpack adds the above module *after*
+// this module so that when this code runs, testRequireError is undefined.
+// So in the meantime, we'll just inline it.
+const testRequireError = (moduleName, err) => {
+  const regex = new RegExp(`Error: Cannot find module\\s.${moduleName}`);
+  const firstLine = err.toString().split(`\n`)[0];
+  return regex.test(firstLine);
+};
+
+let Html;
+
+try {
+  Html = require(`../src/html`);
+} catch (err) {
+  if (testRequireError(`../src/html`, err)) {
+    Html = require(`./default-html`);
+  } else {
+    console.log(`There was an error requiring "src/html.js"\n\n`, err, `\n\n`);
+    process.exit();
+  }
+}
+
+Html = Html && Html.__esModule ? Html.default : Html;
+
+var _default = (pagePath, callback) => {
+  let headComponents = [_react.default.createElement("meta", {
+    key: "environment",
+    name: "note",
+    content: "environment=development"
+  })];
+  let htmlAttributes = {};
+  let bodyAttributes = {};
+  let preBodyComponents = [];
+  let postBodyComponents = [];
+  let bodyProps = {};
+  let htmlStr;
+
+  const setHeadComponents = components => {
+    headComponents = headComponents.concat(components);
+  };
+
+  const setHtmlAttributes = attributes => {
+    htmlAttributes = (0, _lodash.merge)(htmlAttributes, attributes);
+  };
+
+  const setBodyAttributes = attributes => {
+    bodyAttributes = (0, _lodash.merge)(bodyAttributes, attributes);
+  };
+
+  const setPreBodyComponents = components => {
+    preBodyComponents = preBodyComponents.concat(components);
+  };
+
+  const setPostBodyComponents = components => {
+    postBodyComponents = postBodyComponents.concat(components);
+  };
+
+  const setBodyProps = props => {
+    bodyProps = (0, _lodash.merge)({}, bodyProps, props);
+  };
+
+  const getHeadComponents = () => headComponents;
+
+  const replaceHeadComponents = components => {
+    headComponents = components;
+  };
+
+  const getPreBodyComponents = () => preBodyComponents;
+
+  const replacePreBodyComponents = components => {
+    preBodyComponents = components;
+  };
+
+  const getPostBodyComponents = () => postBodyComponents;
+
+  const replacePostBodyComponents = components => {
+    postBodyComponents = components;
+  };
+
+  (0, _apiRunnerSsr.default)(`onRenderBody`, {
+    setHeadComponents,
+    setHtmlAttributes,
+    setBodyAttributes,
+    setPreBodyComponents,
+    setPostBodyComponents,
+    setBodyProps,
+    pathname: pagePath
+  });
+  (0, _apiRunnerSsr.default)(`onPreRenderHTML`, {
+    getHeadComponents,
+    replaceHeadComponents,
+    getPreBodyComponents,
+    replacePreBodyComponents,
+    getPostBodyComponents,
+    replacePostBodyComponents,
+    pathname: pagePath
+  });
+
+  const htmlElement = _react.default.createElement(Html, Object.assign({}, bodyProps, {
+    body: ``,
+    headComponents: headComponents.concat([_react.default.createElement("script", {
+      key: `io`,
+      src: "/socket.io/socket.io.js"
+    })]),
+    htmlAttributes,
+    bodyAttributes,
+    preBodyComponents,
+    postBodyComponents: postBodyComponents.concat([_react.default.createElement("script", {
+      key: `commons`,
+      src: "/commons.js"
+    })])
+  }));
+
+  htmlStr = (0, _server.renderToStaticMarkup)(htmlElement);
+  htmlStr = `<!DOCTYPE html>${htmlStr}`;
+  callback(null, htmlStr);
+};
+
+exports.default = _default;

node_modules/gatsby/cache-dir/commonjs/emitter.js

@@ -0,0 +1,12 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _mitt = _interopRequireDefault(require("mitt"));
+
+const emitter = (0, _mitt.default)();
+var _default = emitter;
+exports.default = _default;

node_modules/gatsby/cache-dir/commonjs/ensure-resources.js

@@ -0,0 +1,92 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _loader = _interopRequireDefault(require("./loader"));
+
+var _shallowCompare = _interopRequireDefault(require("shallow-compare"));
+
+class EnsureResources extends _react.default.Component {
+  constructor(props) {
+    super();
+    const {
+      location,
+      pageResources
+    } = props;
+    this.state = {
+      location: Object.assign({}, location),
+      pageResources: pageResources || _loader.default.loadPageSync(location.pathname)
+    };
+  }
+
+  static getDerivedStateFromProps({
+    location
+  }, prevState) {
+    if (prevState.location.href !== location.href) {
+      const pageResources = _loader.default.loadPageSync(location.pathname);
+
+      return {
+        pageResources,
+        location: Object.assign({}, location)
+      };
+    }
+
+    return null;
+  }
+
+  loadResources(rawPath) {
+    _loader.default.loadPage(rawPath).then(pageResources => {
+      if (pageResources && pageResources.status !== `error`) {
+        this.setState({
+          location: Object.assign({}, window.location),
+          pageResources
+        });
+      } else {
+        window.history.replaceState({}, ``, location.href);
+        window.location = rawPath;
+      }
+    });
+  }
+
+  shouldComponentUpdate(nextProps, nextState) {
+    // Always return false if we're missing resources.
+    if (!nextState.pageResources) {
+      this.loadResources(nextProps.location.pathname);
+      return false;
+    } // Check if the component or json have changed.
+
+
+    if (this.state.pageResources !== nextState.pageResources) {
+      return true;
+    }
+
+    if (this.state.pageResources.component !== nextState.pageResources.component) {
+      return true;
+    }
+
+    if (this.state.pageResources.json !== nextState.pageResources.json) {
+      return true;
+    } // Check if location has changed on a page using internal routing
+    // via matchPath configuration.
+
+
+    if (this.state.location.key !== nextState.location.key && nextState.pageResources.page && (nextState.pageResources.page.matchPath || nextState.pageResources.page.path)) {
+      return true;
+    }
+
+    return (0, _shallowCompare.default)(this, nextProps, nextState);
+  }
+
+  render() {
+    return this.props.children(this.state);
+  }
+
+}
+
+var _default = EnsureResources;
+exports.default = _default;

node_modules/gatsby/cache-dir/commonjs/error-overlay-handler.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+exports.__esModule = true;
+exports.errorMap = exports.reportError = exports.clearError = void 0;
+
+var ErrorOverlay = _interopRequireWildcard(require("react-error-overlay"));
+
+// Report runtime errors
+ErrorOverlay.startReportingRuntimeErrors({
+  onError: () => {},
+  filename: `/commons.js`
+});
+ErrorOverlay.setEditorHandler(errorLocation => window.fetch(`/__open-stack-frame-in-editor?fileName=` + window.encodeURIComponent(errorLocation.fileName) + `&lineNumber=` + window.encodeURIComponent(errorLocation.lineNumber || 1)));
+const errorMap = {};
+exports.errorMap = errorMap;
+
+const handleErrorOverlay = () => {
+  const errors = Object.values(errorMap);
+
+  if (errors.length > 0) {
+    const errorMsg = errors.join(`\n\n`);
+    ErrorOverlay.reportBuildError(errorMsg);
+  } else {
+    ErrorOverlay.dismissBuildError();
+  }
+};
+
+const clearError = errorID => {
+  delete errorMap[errorID];
+  handleErrorOverlay();
+};
+
+exports.clearError = clearError;
+
+const reportError = (errorID, error) => {
+  if (error) {
+    errorMap[errorID] = error;
+  }
+
+  handleErrorOverlay();
+};
+
+exports.reportError = reportError;

node_modules/gatsby/cache-dir/commonjs/find-path.js

@@ -0,0 +1,85 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.cleanPath = exports.findMatchPath = exports.setMatchPaths = void 0;
+
+var _utils = require("@reach/router/lib/utils");
+
+var _stripPrefix = _interopRequireDefault(require("./strip-prefix"));
+
+var _normalizePagePath = _interopRequireDefault(require("./normalize-page-path"));
+
+let matchPaths = [];
+
+const trimPathname = rawPathname => {
+  let pathname = decodeURIComponent(rawPathname); // Remove the pathPrefix from the pathname.
+
+  let trimmedPathname = (0, _stripPrefix.default)(pathname, __BASE_PATH__) // Remove any hashfragment
+  .split(`#`)[0] // Remove search query
+  .split(`?`)[0];
+  return trimmedPathname;
+};
+/**
+ * Set list of matchPaths
+ *
+ * @param {Array<{path: string, matchPath: string}>} value collection of matchPaths
+ */
+
+
+const setMatchPaths = value => {
+  matchPaths = value;
+};
+/**
+ * Return a matchpath url
+ * if `match-paths.json` contains `{ "/foo*": "/page1", ...}`, then
+ * `/foo?bar=far` => `/page1`
+ *
+ * @param {string} rawPathname A raw pathname
+ * @return {string|null}
+ */
+
+
+exports.setMatchPaths = setMatchPaths;
+
+const findMatchPath = rawPathname => {
+  const trimmedPathname = cleanPath(rawPathname);
+
+  for (const _ref of matchPaths) {
+    const {
+      matchPath,
+      path
+    } = _ref;
+
+    if ((0, _utils.match)(matchPath, trimmedPathname)) {
+      return (0, _normalizePagePath.default)(path);
+    }
+  }
+
+  return null;
+};
+/**
+ * Clean a url and converts /index.html => /
+ * E.g `/foo?bar=far` => `/foo`
+ *
+ * @param {string} rawPathname A raw pathname
+ * @return {string}
+ */
+
+
+exports.findMatchPath = findMatchPath;
+
+const cleanPath = rawPathname => {
+  const trimmedPathname = trimPathname(rawPathname);
+  let foundPath = trimmedPathname;
+
+  if (foundPath === `/index.html`) {
+    foundPath = `/`;
+  }
+
+  foundPath = (0, _normalizePagePath.default)(foundPath);
+  return foundPath;
+};
+
+exports.cleanPath = cleanPath;

node_modules/gatsby/cache-dir/commonjs/gatsby-browser-entry.js

@@ -0,0 +1,90 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.graphql = graphql;
+exports.prefetchPathname = exports.useStaticQuery = exports.StaticQuery = exports.StaticQueryContext = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _gatsbyLink = _interopRequireWildcard(require("gatsby-link"));
+
+exports.Link = _gatsbyLink.default;
+exports.withPrefix = _gatsbyLink.withPrefix;
+exports.withAssetPrefix = _gatsbyLink.withAssetPrefix;
+exports.navigate = _gatsbyLink.navigate;
+exports.push = _gatsbyLink.push;
+exports.replace = _gatsbyLink.replace;
+exports.navigateTo = _gatsbyLink.navigateTo;
+exports.parsePath = _gatsbyLink.parsePath;
+
+var _publicPageRenderer = _interopRequireDefault(require("./public-page-renderer"));
+
+exports.PageRenderer = _publicPageRenderer.default;
+
+var _loader = _interopRequireDefault(require("./loader"));
+
+const prefetchPathname = _loader.default.enqueue;
+exports.prefetchPathname = prefetchPathname;
+
+const StaticQueryContext = _react.default.createContext({});
+
+exports.StaticQueryContext = StaticQueryContext;
+
+function StaticQueryDataRenderer({
+  staticQueryData,
+  data,
+  query,
+  render
+}) {
+  const finalData = data ? data.data : staticQueryData[query] && staticQueryData[query].data;
+  return _react.default.createElement(_react.default.Fragment, null, finalData && render(finalData), !finalData && _react.default.createElement("div", null, "Loading (StaticQuery)"));
+}
+
+const StaticQuery = props => {
+  const {
+    data,
+    query,
+    render,
+    children
+  } = props;
+  return _react.default.createElement(StaticQueryContext.Consumer, null, staticQueryData => _react.default.createElement(StaticQueryDataRenderer, {
+    data: data,
+    query: query,
+    render: render || children,
+    staticQueryData: staticQueryData
+  }));
+};
+
+exports.StaticQuery = StaticQuery;
+
+const useStaticQuery = query => {
+  if (typeof _react.default.useContext !== `function` && process.env.NODE_ENV === `development`) {
+    throw new Error(`You're likely using a version of React that doesn't support Hooks\n` + `Please update React and ReactDOM to 16.8.0 or later to use the useStaticQuery hook.`);
+  }
+
+  const context = _react.default.useContext(StaticQueryContext);
+
+  if (context[query] && context[query].data) {
+    return context[query].data;
+  } else {
+    throw new Error(`The result of this StaticQuery could not be fetched.\n\n` + `This is likely a bug in Gatsby and if refreshing the page does not fix it, ` + `please open an issue in https://github.com/gatsbyjs/gatsby/issues`);
+  }
+};
+
+exports.useStaticQuery = useStaticQuery;
+StaticQuery.propTypes = {
+  data: _propTypes.default.object,
+  query: _propTypes.default.string.isRequired,
+  render: _propTypes.default.func,
+  children: _propTypes.default.func
+};
+
+function graphql() {
+  throw new Error(`It appears like Gatsby is misconfigured. Gatsby related \`graphql\` calls ` + `are supposed to only be evaluated at compile time, and then compiled away. ` + `Unfortunately, something went wrong and the query was left in the compiled code.\n\n` + `Unless your site has a complex or custom babel/Gatsby configuration this is likely a bug in Gatsby.`);
+}

node_modules/gatsby/cache-dir/commonjs/json-store.js

@@ -0,0 +1,93 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _pageRenderer = _interopRequireDefault(require("./page-renderer"));
+
+var _normalizePagePath = _interopRequireDefault(require("./normalize-page-path"));
+
+var _gatsby = require("gatsby");
+
+var _socketIo = require("./socketIo");
+
+if (process.env.NODE_ENV === `production`) {
+  throw new Error(`It appears like Gatsby is misconfigured. JSONStore is Gatsby internal ` + `development-only component and should never be used in production.\n\n` + `Unless your site has a complex or custom webpack/Gatsby ` + `configuration this is likely a bug in Gatsby. ` + `Please report this at https://github.com/gatsbyjs/gatsby/issues ` + `with steps to reproduce this error.`);
+}
+
+const getPathFromProps = props => props.pageResources && props.pageResources.page ? (0, _normalizePagePath.default)(props.pageResources.page.path) : undefined;
+
+class JSONStore extends _react.default.Component {
+  constructor(props) {
+    super(props);
+    (0, _defineProperty2.default)(this, "handleMittEvent", (type, event) => {
+      this.setState({
+        staticQueryData: (0, _socketIo.getStaticQueryData)(),
+        pageQueryData: (0, _socketIo.getPageQueryData)()
+      });
+    });
+    this.state = {
+      staticQueryData: (0, _socketIo.getStaticQueryData)(),
+      pageQueryData: (0, _socketIo.getPageQueryData)(),
+      path: null
+    };
+  }
+
+  componentDidMount() {
+    (0, _socketIo.registerPath)(getPathFromProps(this.props));
+
+    ___emitter.on(`*`, this.handleMittEvent);
+  }
+
+  componentWillUnmount() {
+    (0, _socketIo.unregisterPath)(this.state.path);
+
+    ___emitter.off(`*`, this.handleMittEvent);
+  }
+
+  static getDerivedStateFromProps(props, state) {
+    const newPath = getPathFromProps(props);
+
+    if (newPath !== state.path) {
+      (0, _socketIo.unregisterPath)(state.path);
+      (0, _socketIo.registerPath)(newPath);
+      return {
+        path: newPath
+      };
+    }
+
+    return null;
+  }
+
+  shouldComponentUpdate(nextProps, nextState) {
+    // We want to update this component when:
+    // - location changed
+    // - page data for path changed
+    // - static query results changed
+    return this.props.location !== nextProps.location || this.state.path !== nextState.path || this.state.pageQueryData[(0, _normalizePagePath.default)(nextState.path)] !== nextState.pageQueryData[(0, _normalizePagePath.default)(nextState.path)] || this.state.staticQueryData !== nextState.staticQueryData;
+  }
+
+  render() {
+    const data = this.state.pageQueryData[getPathFromProps(this.props)]; // eslint-disable-next-line
+
+    if (!data) {
+      return _react.default.createElement("div", null);
+    }
+
+    return _react.default.createElement(_gatsby.StaticQueryContext.Provider, {
+      value: this.state.staticQueryData
+    }, _react.default.createElement(_pageRenderer.default, (0, _extends2.default)({}, this.props, data)));
+  }
+
+}
+
+var _default = JSONStore;
+exports.default = _default;

node_modules/gatsby/cache-dir/commonjs/loader.js

@@ -0,0 +1,417 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = exports.publicLoader = exports.setLoader = exports.ProdLoader = exports.BaseLoader = void 0;
+
+var _prefetch = _interopRequireDefault(require("./prefetch"));
+
+var _emitter = _interopRequireDefault(require("./emitter"));
+
+var _findPath = require("./find-path");
+
+const preferDefault = m => m && m.default || m;
+
+const stripSurroundingSlashes = s => {
+  s = s[0] === `/` ? s.slice(1) : s;
+  s = s.endsWith(`/`) ? s.slice(0, -1) : s;
+  return s;
+};
+
+const createPageDataUrl = path => {
+  const fixedPath = path === `/` ? `index` : stripSurroundingSlashes(path);
+  return `${__PATH_PREFIX__}/page-data/${fixedPath}/page-data.json`;
+};
+
+const doFetch = (url, method = `GET`) => new Promise((resolve, reject) => {
+  const req = new XMLHttpRequest();
+  req.open(method, url, true);
+
+  req.onreadystatechange = () => {
+    if (req.readyState == 4) {
+      resolve(req);
+    }
+  };
+
+  req.send(null);
+});
+
+const loadPageDataJson = loadObj => {
+  const {
+    pagePath,
+    retries = 0
+  } = loadObj;
+  const url = createPageDataUrl(pagePath);
+  return doFetch(url).then(req => {
+    const {
+      status,
+      responseText
+    } = req; // Handle 200
+
+    if (status === 200) {
+      try {
+        const jsonPayload = JSON.parse(responseText);
+
+        if (jsonPayload.webpackCompilationHash === undefined) {
+          throw new Error(`not a valid pageData response`);
+        }
+
+        return Object.assign(loadObj, {
+          status: `success`,
+          payload: jsonPayload
+        });
+      } catch (err) {// continue regardless of error
+      }
+    } // Handle 404
+
+
+    if (status === 404 || status === 200) {
+      // If the request was for a 404 page and it doesn't exist, we're done
+      if (pagePath === `/404.html`) {
+        return Object.assign(loadObj, {
+          status: `failure`
+        });
+      } // Need some code here to cache the 404 request. In case
+      // multiple loadPageDataJsons result in 404s
+
+
+      return loadPageDataJson(Object.assign(loadObj, {
+        pagePath: `/404.html`,
+        notFound: true
+      }));
+    } // handle 500 response (Unrecoverable)
+
+
+    if (status === 500) {
+      return Object.assign(loadObj, {
+        status: `error`
+      });
+    } // Handle everything else, including status === 0, and 503s. Should retry
+
+
+    if (retries < 3) {
+      return loadPageDataJson(Object.assign(loadObj, {
+        retries: retries + 1
+      }));
+    } // Retried 3 times already, result is a failure.
+
+
+    return Object.assign(loadObj, {
+      status: `error`
+    });
+  });
+};
+
+const doesConnectionSupportPrefetch = () => {
+  if (`connection` in navigator && typeof navigator.connection !== `undefined`) {
+    if ((navigator.connection.effectiveType || ``).includes(`2g`)) {
+      return false;
+    }
+
+    if (navigator.connection.saveData) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+const toPageResources = (pageData, component = null) => {
+  const page = {
+    componentChunkName: pageData.componentChunkName,
+    path: pageData.path,
+    webpackCompilationHash: pageData.webpackCompilationHash,
+    matchPath: pageData.matchPath
+  };
+  return {
+    component,
+    json: pageData.result,
+    page
+  };
+};
+
+class BaseLoader {
+  constructor(loadComponent, matchPaths) {
+    // Map of pagePath -> Page. Where Page is an object with: {
+    //   status: `success` || `error`,
+    //   payload: PageResources, // undefined if `error`
+    // }
+    // PageResources is {
+    //   component,
+    //   json: pageData.result,
+    //   page: {
+    //     componentChunkName,
+    //     path,
+    //     webpackCompilationHash,
+    //   }
+    // }
+    this.pageDb = new Map();
+    this.inFlightDb = new Map();
+    this.pageDataDb = new Map();
+    this.prefetchTriggered = new Set();
+    this.prefetchCompleted = new Set();
+    this.loadComponent = loadComponent;
+    (0, _findPath.setMatchPaths)(matchPaths);
+  }
+
+  setApiRunner(apiRunner) {
+    this.apiRunner = apiRunner;
+    this.prefetchDisabled = apiRunner(`disableCorePrefetching`).some(a => a);
+  }
+
+  loadPageDataJson(rawPath) {
+    const pagePath = (0, _findPath.cleanPath)(rawPath);
+
+    if (this.pageDataDb.has(pagePath)) {
+      return Promise.resolve(this.pageDataDb.get(pagePath));
+    }
+
+    return loadPageDataJson({
+      pagePath
+    }).then(pageData => {
+      this.pageDataDb.set(pagePath, pageData);
+      return pageData;
+    });
+  }
+
+  findMatchPath(rawPath) {
+    return (0, _findPath.findMatchPath)(rawPath);
+  } // TODO check all uses of this and whether they use undefined for page resources not exist
+
+
+  loadPage(rawPath) {
+    const pagePath = (0, _findPath.cleanPath)(rawPath);
+
+    if (this.pageDb.has(pagePath)) {
+      const page = this.pageDb.get(pagePath);
+      return Promise.resolve(page.payload);
+    }
+
+    if (this.inFlightDb.has(pagePath)) {
+      return this.inFlightDb.get(pagePath);
+    }
+
+    const inFlight = this.loadPageDataJson(pagePath).then(result => {
+      if (result.notFound) {
+        // if request was a 404, we should fallback to findMatchPath.
+        let foundMatchPatch = (0, _findPath.findMatchPath)(pagePath);
+
+        if (foundMatchPatch && foundMatchPatch !== pagePath) {
+          return this.loadPage(foundMatchPatch).then(pageResources => {
+            this.pageDb.set(pagePath, this.pageDb.get(foundMatchPatch));
+            return pageResources;
+          });
+        }
+      }
+
+      if (result.status === `error`) {
+        return {
+          status: `error`
+        };
+      }
+
+      if (result.status === `failure`) {
+        // throw an error so error trackers can pick this up
+        throw new Error(`404 page could not be found. Checkout https://www.gatsbyjs.org/docs/add-404-page/`);
+      }
+
+      const pageData = result.payload;
+      const {
+        componentChunkName
+      } = pageData;
+      return this.loadComponent(componentChunkName).then(component => {
+        const finalResult = {
+          createdAt: new Date()
+        };
+        let pageResources;
+
+        if (!component) {
+          finalResult.status = `error`;
+        } else {
+          finalResult.status = `success`;
+
+          if (result.notFound === true) {
+            finalResult.notFound = true;
+          }
+
+          pageResources = toPageResources(pageData, component);
+          finalResult.payload = pageResources;
+
+          _emitter.default.emit(`onPostLoadPageResources`, {
+            page: pageResources,
+            pageResources
+          });
+        }
+
+        this.pageDb.set(pagePath, finalResult); // undefined if final result is an error
+
+        return pageResources;
+      });
+    }) // prefer duplication with then + catch over .finally to prevent problems in ie11 + firefox
+    .then(response => {
+      this.inFlightDb.delete(pagePath);
+      return response;
+    }).catch(err => {
+      this.inFlightDb.delete(pagePath);
+      throw err;
+    });
+    this.inFlightDb.set(pagePath, inFlight);
+    return inFlight;
+  } // returns undefined if loading page ran into errors
+
+
+  loadPageSync(rawPath) {
+    const pagePath = (0, _findPath.cleanPath)(rawPath);
+
+    if (this.pageDb.has(pagePath)) {
+      return this.pageDb.get(pagePath).payload;
+    }
+
+    return undefined;
+  }
+
+  shouldPrefetch(pagePath) {
+    // Skip prefetching if we know user is on slow or constrained connection
+    if (!doesConnectionSupportPrefetch()) {
+      return false;
+    } // Check if the page exists.
+
+
+    if (this.pageDb.has(pagePath)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  prefetch(pagePath) {
+    if (!this.shouldPrefetch(pagePath)) {
+      return false;
+    } // Tell plugins with custom prefetching logic that they should start
+    // prefetching this path.
+
+
+    if (!this.prefetchTriggered.has(pagePath)) {
+      this.apiRunner(`onPrefetchPathname`, {
+        pathname: pagePath
+      });
+      this.prefetchTriggered.add(pagePath);
+    } // If a plugin has disabled core prefetching, stop now.
+
+
+    if (this.prefetchDisabled) {
+      return false;
+    }
+
+    const realPath = (0, _findPath.cleanPath)(pagePath); // Todo make doPrefetch logic cacheable
+    // eslint-disable-next-line consistent-return
+
+    this.doPrefetch(realPath).then(pageData => {
+      if (!pageData) {
+        const matchPath = (0, _findPath.findMatchPath)(realPath);
+
+        if (matchPath && matchPath !== realPath) {
+          return this.prefetch(matchPath);
+        }
+      }
+
+      if (!this.prefetchCompleted.has(pagePath)) {
+        this.apiRunner(`onPostPrefetchPathname`, {
+          pathname: pagePath
+        });
+        this.prefetchCompleted.add(pagePath);
+      }
+    });
+    return true;
+  }
+
+  doPrefetch(pagePath) {
+    throw new Error(`doPrefetch not implemented`);
+  }
+
+  hovering(rawPath) {
+    this.loadPage(rawPath);
+  }
+
+  getResourceURLsForPathname(rawPath) {
+    const pagePath = (0, _findPath.cleanPath)(rawPath);
+    const page = this.pageDataDb.get(pagePath);
+
+    if (page) {
+      const pageResources = toPageResources(page.payload);
+      return [...createComponentUrls(pageResources.page.componentChunkName), createPageDataUrl(pagePath)];
+    } else {
+      return null;
+    }
+  }
+
+  isPageNotFound(rawPath) {
+    const pagePath = (0, _findPath.cleanPath)(rawPath);
+    const page = this.pageDb.get(pagePath);
+    return page && page.notFound === true;
+  }
+
+}
+
+exports.BaseLoader = BaseLoader;
+
+const createComponentUrls = componentChunkName => window.___chunkMapping[componentChunkName].map(chunk => __PATH_PREFIX__ + chunk);
+
+class ProdLoader extends BaseLoader {
+  constructor(asyncRequires, matchPaths) {
+    const loadComponent = chunkName => asyncRequires.components[chunkName]().then(preferDefault);
+
+    super(loadComponent, matchPaths);
+  }
+
+  doPrefetch(pagePath) {
+    const pageDataUrl = createPageDataUrl(pagePath);
+    return (0, _prefetch.default)(pageDataUrl).then(() => // This was just prefetched, so will return a response from
+    // the cache instead of making another request to the server
+    this.loadPageDataJson(pagePath)).then(result => {
+      if (result.status !== `success`) {
+        return Promise.resolve();
+      }
+
+      const pageData = result.payload;
+      const chunkName = pageData.componentChunkName;
+      const componentUrls = createComponentUrls(chunkName);
+      return Promise.all(componentUrls.map(_prefetch.default)).then(() => pageData);
+    });
+  }
+
+}
+
+exports.ProdLoader = ProdLoader;
+let instance;
+
+const setLoader = _loader => {
+  instance = _loader;
+};
+
+exports.setLoader = setLoader;
+const publicLoader = {
+  // Deprecated methods. As far as we're aware, these are only used by
+  // core gatsby and the offline plugin, however there's a very small
+  // chance they're called by others.
+  getResourcesForPathname: rawPath => {
+    console.warn(`Warning: getResourcesForPathname is deprecated. Use loadPage instead`);
+    return instance.i.loadPage(rawPath);
+  },
+  getResourcesForPathnameSync: rawPath => {
+    console.warn(`Warning: getResourcesForPathnameSync is deprecated. Use loadPageSync instead`);
+    return instance.i.loadPageSync(rawPath);
+  },
+  enqueue: rawPath => instance.prefetch(rawPath),
+  // Real methods
+  getResourceURLsForPathname: rawPath => instance.getResourceURLsForPathname(rawPath),
+  loadPage: rawPath => instance.loadPage(rawPath),
+  loadPageSync: rawPath => instance.loadPageSync(rawPath),
+  prefetch: rawPath => instance.prefetch(rawPath),
+  isPageNotFound: rawPath => instance.isPageNotFound(rawPath),
+  hovering: rawPath => instance.hovering(rawPath)
+};
+exports.publicLoader = publicLoader;
+var _default = publicLoader;
+exports.default = _default;

node_modules/gatsby/cache-dir/commonjs/navigation.js

@@ -0,0 +1,234 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.init = init;
+exports.shouldUpdateScroll = shouldUpdateScroll;
+exports.RouteUpdates = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _loader = _interopRequireDefault(require("./loader"));
+
+var _redirects = _interopRequireDefault(require("./redirects.json"));
+
+var _apiRunnerBrowser = require("./api-runner-browser");
+
+var _emitter = _interopRequireDefault(require("./emitter"));
+
+var _router = require("@reach/router");
+
+var _gatsbyLink = require("gatsby-link");
+
+// Convert to a map for faster lookup in maybeRedirect()
+const redirectMap = _redirects.default.reduce((map, redirect) => {
+  map[redirect.fromPath] = redirect;
+  return map;
+}, {});
+
+function maybeRedirect(pathname) {
+  const redirect = redirectMap[pathname];
+
+  if (redirect != null) {
+    if (process.env.NODE_ENV !== `production`) {
+      const pageResources = _loader.default.loadPageSync(pathname);
+
+      if (pageResources != null) {
+        console.error(`The route "${pathname}" matches both a page and a redirect; this is probably not intentional.`);
+      }
+    }
+
+    window.___replace(redirect.toPath);
+
+    return true;
+  } else {
+    return false;
+  }
+}
+
+const onPreRouteUpdate = (location, prevLocation) => {
+  if (!maybeRedirect(location.pathname)) {
+    (0, _apiRunnerBrowser.apiRunner)(`onPreRouteUpdate`, {
+      location,
+      prevLocation
+    });
+  }
+};
+
+const onRouteUpdate = (location, prevLocation) => {
+  if (!maybeRedirect(location.pathname)) {
+    (0, _apiRunnerBrowser.apiRunner)(`onRouteUpdate`, {
+      location,
+      prevLocation
+    }); // Temp hack while awaiting https://github.com/reach/router/issues/119
+
+    window.__navigatingToLink = false;
+  }
+};
+
+const navigate = (to, options = {}) => {
+  // Temp hack while awaiting https://github.com/reach/router/issues/119
+  if (!options.replace) {
+    window.__navigatingToLink = true;
+  }
+
+  let {
+    pathname
+  } = (0, _gatsbyLink.parsePath)(to);
+  const redirect = redirectMap[pathname]; // If we're redirecting, just replace the passed in pathname
+  // to the one we want to redirect to.
+
+  if (redirect) {
+    to = redirect.toPath;
+    pathname = (0, _gatsbyLink.parsePath)(to).pathname;
+  } // If we had a service worker update, no matter the path, reload window and
+  // reset the pathname whitelist
+
+
+  if (window.___swUpdated) {
+    window.location = pathname;
+    return;
+  } // Start a timer to wait for a second before transitioning and showing a
+  // loader in case resources aren't around yet.
+
+
+  const timeoutId = setTimeout(() => {
+    _emitter.default.emit(`onDelayedLoadPageResources`, {
+      pathname
+    });
+
+    (0, _apiRunnerBrowser.apiRunner)(`onRouteUpdateDelayed`, {
+      location: window.location
+    });
+  }, 1000);
+
+  _loader.default.loadPage(pathname).then(pageResources => {
+    // If no page resources, then refresh the page
+    // Do this, rather than simply `window.location.reload()`, so that
+    // pressing the back/forward buttons work - otherwise when pressing
+    // back, the browser will just change the URL and expect JS to handle
+    // the change, which won't always work since it might not be a Gatsby
+    // page.
+    if (!pageResources || pageResources.status === `error`) {
+      window.history.replaceState({}, ``, location.href);
+      window.location = pathname;
+    } // If the loaded page has a different compilation hash to the
+    // window, then a rebuild has occurred on the server. Reload.
+
+
+    if (process.env.NODE_ENV === `production` && pageResources) {
+      if (pageResources.page.webpackCompilationHash !== window.___webpackCompilationHash) {
+        // Purge plugin-offline cache
+        if (`serviceWorker` in navigator && navigator.serviceWorker.controller !== null && navigator.serviceWorker.controller.state === `activated`) {
+          navigator.serviceWorker.controller.postMessage({
+            gatsbyApi: `resetWhitelist`
+          });
+        }
+
+        console.log(`Site has changed on server. Reloading browser`);
+        window.location = pathname;
+      }
+    }
+
+    (0, _router.navigate)(to, options);
+    clearTimeout(timeoutId);
+  });
+};
+
+function shouldUpdateScroll(prevRouterProps, {
+  location
+}) {
+  const {
+    pathname,
+    hash
+  } = location;
+  const results = (0, _apiRunnerBrowser.apiRunner)(`shouldUpdateScroll`, {
+    prevRouterProps,
+    // `pathname` for backwards compatibility
+    pathname,
+    routerProps: {
+      location
+    },
+    getSavedScrollPosition: args => this._stateStorage.read(args)
+  });
+
+  if (results.length > 0) {
+    // Use the latest registered shouldUpdateScroll result, this allows users to override plugin's configuration
+    // @see https://github.com/gatsbyjs/gatsby/issues/12038
+    return results[results.length - 1];
+  }
+
+  if (prevRouterProps) {
+    const {
+      location: {
+        pathname: oldPathname
+      }
+    } = prevRouterProps;
+
+    if (oldPathname === pathname) {
+      // Scroll to element if it exists, if it doesn't, or no hash is provided,
+      // scroll to top.
+      return hash ? hash.slice(1) : [0, 0];
+    }
+  }
+
+  return true;
+}
+
+function init() {
+  // Temp hack while awaiting https://github.com/reach/router/issues/119
+  window.__navigatingToLink = false;
+
+  window.___push = to => navigate(to, {
+    replace: false
+  });
+
+  window.___replace = to => navigate(to, {
+    replace: true
+  });
+
+  window.___navigate = (to, options) => navigate(to, options); // Check for initial page-load redirect
+
+
+  maybeRedirect(window.location.pathname);
+} // Fire on(Pre)RouteUpdate APIs
+
+
+class RouteUpdates extends _react.default.Component {
+  constructor(props) {
+    super(props);
+    onPreRouteUpdate(props.location, null);
+  }
+
+  componentDidMount() {
+    onRouteUpdate(this.props.location, null);
+  }
+
+  componentDidUpdate(prevProps, prevState, shouldFireRouteUpdate) {
+    if (shouldFireRouteUpdate) {
+      onRouteUpdate(this.props.location, prevProps.location);
+    }
+  }
+
+  getSnapshotBeforeUpdate(prevProps) {
+    if (this.props.location.pathname !== prevProps.location.pathname) {
+      onPreRouteUpdate(this.props.location, prevProps.location);
+      return true;
+    }
+
+    return false;
+  }
+
+  render() {
+    return this.props.children;
+  }
+
+}
+
+exports.RouteUpdates = RouteUpdates;
+RouteUpdates.propTypes = {
+  location: _propTypes.default.object.isRequired
+};

node_modules/gatsby/cache-dir/commonjs/normalize-page-path.js

@@ -0,0 +1,22 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _default = path => {
+  if (path === undefined) {
+    return path;
+  }
+
+  if (path === `/`) {
+    return `/`;
+  }
+
+  if (path.charAt(path.length - 1) === `/`) {
+    return path.slice(0, -1);
+  }
+
+  return path;
+};
+
+exports.default = _default;

node_modules/gatsby/cache-dir/commonjs/page-renderer.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _loader = require("./loader");
+
+var _apiRunnerBrowser = require("./api-runner-browser");
+
+// Renders page
+class PageRenderer extends _react.default.Component {
+  render() {
+    const props = Object.assign({}, this.props, {
+      pathContext: this.props.pageContext
+    });
+    const [replacementElement] = (0, _apiRunnerBrowser.apiRunner)(`replaceComponentRenderer`, {
+      props: this.props,
+      loader: _loader.publicLoader
+    });
+    const pageElement = replacementElement || (0, _react.createElement)(this.props.pageResources.component, Object.assign({}, props, {
+      key: this.props.path || this.props.pageResources.page.path
+    }));
+    const wrappedPage = (0, _apiRunnerBrowser.apiRunner)(`wrapPageElement`, {
+      element: pageElement,
+      props
+    }, pageElement, ({
+      result
+    }) => {
+      return {
+        element: result,
+        props
+      };
+    }).pop();
+    return wrappedPage;
+  }
+
+}
+
+PageRenderer.propTypes = {
+  location: _propTypes.default.object.isRequired,
+  pageResources: _propTypes.default.object.isRequired,
+  data: _propTypes.default.object,
+  pageContext: _propTypes.default.object.isRequired
+};
+var _default = PageRenderer;
+exports.default = _default;

node_modules/gatsby/cache-dir/commonjs/prefetch.js

@@ -0,0 +1,76 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+const support = function (feature) {
+  if (typeof document === `undefined`) {
+    return false;
+  }
+
+  const fakeLink = document.createElement(`link`);
+
+  try {
+    if (fakeLink.relList && typeof fakeLink.relList.supports === `function`) {
+      return fakeLink.relList.supports(feature);
+    }
+  } catch (err) {
+    return false;
+  }
+
+  return false;
+};
+
+const linkPrefetchStrategy = function (url) {
+  return new Promise((resolve, reject) => {
+    if (typeof document === `undefined`) {
+      reject();
+      return;
+    }
+
+    const link = document.createElement(`link`);
+    link.setAttribute(`rel`, `prefetch`);
+    link.setAttribute(`href`, url);
+    link.onload = resolve;
+    link.onerror = reject;
+    const parentElement = document.getElementsByTagName(`head`)[0] || document.getElementsByName(`script`)[0].parentNode;
+    parentElement.appendChild(link);
+  });
+};
+
+const xhrPrefetchStrategy = function (url) {
+  return new Promise((resolve, reject) => {
+    const req = new XMLHttpRequest();
+    req.open(`GET`, url, true);
+
+    req.onload = () => {
+      if (req.status === 200) {
+        resolve();
+      } else {
+        reject();
+      }
+    };
+
+    req.send(null);
+  });
+};
+
+const supportedPrefetchStrategy = support(`prefetch`) ? linkPrefetchStrategy : xhrPrefetchStrategy;
+const preFetched = {};
+
+const prefetch = function (url) {
+  return new Promise(resolve => {
+    if (preFetched[url]) {
+      resolve();
+      return;
+    }
+
+    supportedPrefetchStrategy(url).then(() => {
+      resolve();
+      preFetched[url] = true;
+    }).catch(() => {}); // 404s are logged to the console anyway
+  });
+};
+
+var _default = prefetch;
+exports.default = _default;

node_modules/gatsby/cache-dir/commonjs/production-app.js

@@ -0,0 +1,138 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _apiRunnerBrowser = require("./api-runner-browser");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactDom = _interopRequireDefault(require("react-dom"));
+
+var _router = require("@reach/router");
+
+var _gatsbyReactRouterScroll = require("gatsby-react-router-scroll");
+
+var _domready = _interopRequireDefault(require("@mikaelkristiansson/domready"));
+
+var _navigation = require("./navigation");
+
+var _emitter = _interopRequireDefault(require("./emitter"));
+
+var _pageRenderer = _interopRequireDefault(require("./page-renderer"));
+
+var _asyncRequires = _interopRequireDefault(require("./async-requires"));
+
+var _loader = require("./loader");
+
+var _ensureResources = _interopRequireDefault(require("./ensure-resources"));
+
+var _stripPrefix = _interopRequireDefault(require("./strip-prefix"));
+
+var _matchPaths = _interopRequireDefault(require("./match-paths.json"));
+
+// Generated during bootstrap
+const loader = new _loader.ProdLoader(_asyncRequires.default, _matchPaths.default);
+(0, _loader.setLoader)(loader);
+loader.setApiRunner(_apiRunnerBrowser.apiRunner);
+window.asyncRequires = _asyncRequires.default;
+window.___emitter = _emitter.default;
+window.___loader = _loader.publicLoader;
+window.___webpackCompilationHash = window.webpackCompilationHash;
+(0, _navigation.init)();
+(0, _apiRunnerBrowser.apiRunnerAsync)(`onClientEntry`).then(() => {
+  // Let plugins register a service worker. The plugin just needs
+  // to return true.
+  if ((0, _apiRunnerBrowser.apiRunner)(`registerServiceWorker`).length > 0) {
+    require(`./register-service-worker`);
+  } // In gatsby v2 if Router is used in page using matchPaths
+  // paths need to contain full path.
+  // For example:
+  //   - page have `/app/*` matchPath
+  //   - inside template user needs to use `/app/xyz` as path
+  // Resetting `basepath`/`baseuri` keeps current behaviour
+  // to not introduce breaking change.
+  // Remove this in v3
+
+
+  const RouteHandler = props => _react.default.createElement(_router.BaseContext.Provider, {
+    value: {
+      baseuri: `/`,
+      basepath: `/`
+    }
+  }, _react.default.createElement(_pageRenderer.default, props));
+
+  class LocationHandler extends _react.default.Component {
+    render() {
+      const {
+        location
+      } = this.props;
+      return _react.default.createElement(_ensureResources.default, {
+        location: location
+      }, ({
+        pageResources,
+        location
+      }) => _react.default.createElement(_navigation.RouteUpdates, {
+        location: location
+      }, _react.default.createElement(_gatsbyReactRouterScroll.ScrollContext, {
+        location: location,
+        shouldUpdateScroll: _navigation.shouldUpdateScroll
+      }, _react.default.createElement(_router.Router, {
+        basepath: __BASE_PATH__,
+        location: location,
+        id: "gatsby-focus-wrapper"
+      }, _react.default.createElement(RouteHandler, (0, _extends2.default)({
+        path: encodeURI(pageResources.page.path === `/404.html` ? (0, _stripPrefix.default)(location.pathname, __BASE_PATH__) : pageResources.page.matchPath || pageResources.page.path)
+      }, this.props, {
+        location: location,
+        pageResources: pageResources
+      }, pageResources.json))))));
+    }
+
+  }
+
+  const {
+    pagePath,
+    location: browserLoc
+  } = window; // Explicitly call navigate if the canonical path (window.pagePath)
+  // is different to the browser path (window.location.pathname). But
+  // only if NONE of the following conditions hold:
+  //
+  // - The url matches a client side route (page.matchPath)
+  // - it's a 404 page
+  // - it's the offline plugin shell (/offline-plugin-app-shell-fallback/)
+
+  if (pagePath && __BASE_PATH__ + pagePath !== browserLoc.pathname && !(loader.findMatchPath((0, _stripPrefix.default)(browserLoc.pathname, __BASE_PATH__)) || pagePath === `/404.html` || pagePath.match(/^\/404\/?$/) || pagePath.match(/^\/offline-plugin-app-shell-fallback\/?$/))) {
+    (0, _router.navigate)(__BASE_PATH__ + pagePath + browserLoc.search + browserLoc.hash, {
+      replace: true
+    });
+  }
+
+  loader.loadPage(browserLoc.pathname).then(page => {
+    if (!page || page.status === `error`) {
+      throw new Error(`page resources for ${browserLoc.pathname} not found. Not rendering React`);
+    }
+
+    const Root = () => _react.default.createElement(_router.Location, null, locationContext => _react.default.createElement(LocationHandler, locationContext));
+
+    const WrappedRoot = (0, _apiRunnerBrowser.apiRunner)(`wrapRootElement`, {
+      element: _react.default.createElement(Root, null)
+    }, _react.default.createElement(Root, null), ({
+      result
+    }) => {
+      return {
+        element: result
+      };
+    }).pop();
+
+    let NewRoot = () => WrappedRoot;
+
+    const renderer = (0, _apiRunnerBrowser.apiRunner)(`replaceHydrateFunction`, undefined, _reactDom.default.hydrate)[0];
+    (0, _domready.default)(() => {
+      renderer(_react.default.createElement(NewRoot, null), typeof window !== `undefined` ? document.getElementById(`___gatsby`) : void 0, () => {
+        (0, _apiRunnerBrowser.apiRunner)(`onInitialClientRender`);
+      });
+    });
+  });
+});

node_modules/gatsby/cache-dir/commonjs/public-page-renderer-dev.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _loader = _interopRequireDefault(require("./loader"));
+
+var _jsonStore = _interopRequireDefault(require("./json-store"));
+
+const DevPageRenderer = ({
+  location
+}) => {
+  const pageResources = _loader.default.loadPageSync(location.pathname);
+
+  return _react.default.createElement(_jsonStore.default, {
+    location,
+    pageResources
+  });
+};
+
+DevPageRenderer.propTypes = {
+  location: _propTypes.default.shape({
+    pathname: _propTypes.default.string.isRequired
+  }).isRequired
+};
+var _default = DevPageRenderer;
+exports.default = _default;

node_modules/gatsby/cache-dir/commonjs/public-page-renderer-prod.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _pageRenderer = _interopRequireDefault(require("./page-renderer"));
+
+const ProdPageRenderer = ({
+  location,
+  pageResources
+}) => {
+  if (!pageResources) {
+    return null;
+  }
+
+  return _react.default.createElement(_pageRenderer.default, Object.assign({
+    location,
+    pageResources
+  }, pageResources.json));
+};
+
+ProdPageRenderer.propTypes = {
+  location: _propTypes.default.shape({
+    pathname: _propTypes.default.string.isRequired
+  }).isRequired
+};
+var _default = ProdPageRenderer;
+exports.default = _default;

node_modules/gatsby/cache-dir/commonjs/public-page-renderer.js

@@ -0,0 +1,11 @@
+"use strict";
+
+const preferDefault = m => m && m.default || m;
+
+if (process.env.BUILD_STAGE === `develop`) {
+  module.exports = preferDefault(require(`./public-page-renderer-dev`));
+} else if (process.env.BUILD_STAGE === `build-javascript`) {
+  module.exports = preferDefault(require(`./public-page-renderer-prod`));
+} else {
+  module.exports = () => null;
+}

node_modules/gatsby/cache-dir/commonjs/react-lifecycles-compat.js

@@ -0,0 +1,3 @@
+"use strict";
+
+exports.polyfill = Component => Component;

node_modules/gatsby/cache-dir/commonjs/register-service-worker.js

@@ -0,0 +1,66 @@
+"use strict";
+
+var _apiRunnerBrowser = require("./api-runner-browser");
+
+if (window.location.protocol !== `https:` && window.location.hostname !== `localhost`) {
+  console.error(`Service workers can only be used over HTTPS, or on localhost for development`);
+} else if (`serviceWorker` in navigator) {
+  navigator.serviceWorker.register(`${__BASE_PATH__}/sw.js`).then(function (reg) {
+    reg.addEventListener(`updatefound`, () => {
+      (0, _apiRunnerBrowser.apiRunner)(`onServiceWorkerUpdateFound`, {
+        serviceWorker: reg
+      }); // The updatefound event implies that reg.installing is set; see
+      // https://w3c.github.io/ServiceWorker/#service-worker-registration-updatefound-event
+
+      const installingWorker = reg.installing;
+      console.log(`installingWorker`, installingWorker);
+      installingWorker.addEventListener(`statechange`, () => {
+        switch (installingWorker.state) {
+          case `installed`:
+            if (navigator.serviceWorker.controller) {
+              // At this point, the old content will have been purged and the fresh content will
+              // have been added to the cache.
+              // We set a flag so Gatsby Link knows to refresh the page on next navigation attempt
+              window.___swUpdated = true; // We call the onServiceWorkerUpdateReady API so users can show update prompts.
+
+              (0, _apiRunnerBrowser.apiRunner)(`onServiceWorkerUpdateReady`, {
+                serviceWorker: reg
+              }); // If resources failed for the current page, reload.
+
+              if (window.___failedResources) {
+                console.log(`resources failed, SW updated - reloading`);
+                window.location.reload();
+              }
+            } else {
+              // At this point, everything has been precached.
+              // It's the perfect time to display a "Content is cached for offline use." message.
+              console.log(`Content is now available offline!`); // Post to service worker that install is complete.
+              // Delay to allow time for the event listener to be added --
+              // otherwise fetch is called too soon and resources aren't cached.
+
+              (0, _apiRunnerBrowser.apiRunner)(`onServiceWorkerInstalled`, {
+                serviceWorker: reg
+              });
+            }
+
+            break;
+
+          case `redundant`:
+            console.error(`The installing service worker became redundant.`);
+            (0, _apiRunnerBrowser.apiRunner)(`onServiceWorkerRedundant`, {
+              serviceWorker: reg
+            });
+            break;
+
+          case `activated`:
+            (0, _apiRunnerBrowser.apiRunner)(`onServiceWorkerActive`, {
+              serviceWorker: reg
+            });
+            break;
+        }
+      });
+    });
+  }).catch(function (e) {
+    console.error(`Error during service worker registration:`, e);
+  });
+}

node_modules/gatsby/cache-dir/commonjs/root.js

@@ -0,0 +1,131 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _router = require("@reach/router");
+
+var _gatsbyReactRouterScroll = require("gatsby-react-router-scroll");
+
+var _navigation = require("./navigation");
+
+var _apiRunnerBrowser = require("./api-runner-browser");
+
+var _loader = _interopRequireDefault(require("./loader"));
+
+var _jsonStore = _interopRequireDefault(require("./json-store"));
+
+var _ensureResources = _interopRequireDefault(require("./ensure-resources"));
+
+var _errorOverlayHandler = require("./error-overlay-handler");
+
+if (window.__webpack_hot_middleware_reporter__ !== undefined) {
+  const overlayErrorID = `webpack`; // Report build errors
+
+  window.__webpack_hot_middleware_reporter__.useCustomOverlay({
+    showProblems(type, obj) {
+      if (type !== `errors`) {
+        (0, _errorOverlayHandler.clearError)(overlayErrorID);
+        return;
+      }
+
+      (0, _errorOverlayHandler.reportError)(overlayErrorID, obj[0]);
+    },
+
+    clear() {
+      (0, _errorOverlayHandler.clearError)(overlayErrorID);
+    }
+
+  });
+}
+
+(0, _navigation.init)(); // In gatsby v2 if Router is used in page using matchPaths
+// paths need to contain full path.
+// For example:
+//   - page have `/app/*` matchPath
+//   - inside template user needs to use `/app/xyz` as path
+// Resetting `basepath`/`baseuri` keeps current behaviour
+// to not introduce breaking change.
+// Remove this in v3
+
+const RouteHandler = props => _react.default.createElement(_router.BaseContext.Provider, {
+  value: {
+    baseuri: `/`,
+    basepath: `/`
+  }
+}, _react.default.createElement(_jsonStore.default, props));
+
+class LocationHandler extends _react.default.Component {
+  render() {
+    let {
+      location
+    } = this.props;
+
+    if (!_loader.default.isPageNotFound(location.pathname)) {
+      return _react.default.createElement(_ensureResources.default, {
+        location: location
+      }, locationAndPageResources => _react.default.createElement(_navigation.RouteUpdates, {
+        location: location
+      }, _react.default.createElement(_gatsbyReactRouterScroll.ScrollContext, {
+        location: location,
+        shouldUpdateScroll: _navigation.shouldUpdateScroll
+      }, _react.default.createElement(_router.Router, {
+        basepath: __BASE_PATH__,
+        location: location,
+        id: "gatsby-focus-wrapper"
+      }, _react.default.createElement(RouteHandler, (0, _extends2.default)({
+        path: encodeURI(locationAndPageResources.pageResources.page.matchPath || locationAndPageResources.pageResources.page.path)
+      }, this.props, locationAndPageResources))))));
+    }
+
+    const dev404PageResources = _loader.default.loadPageSync(`/dev-404-page`);
+
+    const real404PageResources = _loader.default.loadPageSync(`/404.html`);
+
+    let custom404;
+
+    if (real404PageResources) {
+      custom404 = _react.default.createElement(_jsonStore.default, (0, _extends2.default)({}, this.props, {
+        pageResources: real404PageResources
+      }));
+    }
+
+    return _react.default.createElement(_navigation.RouteUpdates, {
+      location: location
+    }, _react.default.createElement(_router.Router, {
+      basepath: __BASE_PATH__,
+      location: location,
+      id: "gatsby-focus-wrapper"
+    }, _react.default.createElement(RouteHandler, {
+      path: location.pathname,
+      location: location,
+      pageResources: dev404PageResources,
+      custom404: custom404
+    })));
+  }
+
+}
+
+const Root = () => _react.default.createElement(_router.Location, null, locationContext => _react.default.createElement(LocationHandler, locationContext)); // Let site, plugins wrap the site e.g. for Redux.
+
+
+const WrappedRoot = (0, _apiRunnerBrowser.apiRunner)(`wrapRootElement`, {
+  element: _react.default.createElement(Root, null)
+}, _react.default.createElement(Root, null), ({
+  result,
+  plugin
+}) => {
+  return {
+    element: result
+  };
+}).pop();
+
+var _default = () => WrappedRoot;
+
+exports.default = _default;

node_modules/gatsby/cache-dir/commonjs/socketIo.js

@@ -0,0 +1,122 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = socketIo;
+exports.getPageData = getPageData;
+exports.registerPath = registerPath;
+exports.unregisterPath = unregisterPath;
+exports.getIsInitialized = exports.getPageQueryData = exports.getStaticQueryData = void 0;
+
+var _errorOverlayHandler = require("./error-overlay-handler");
+
+var _normalizePagePath = _interopRequireDefault(require("./normalize-page-path"));
+
+let socket = null;
+let staticQueryData = {};
+let pageQueryData = {};
+let isInitialized = false;
+
+const getStaticQueryData = () => staticQueryData;
+
+exports.getStaticQueryData = getStaticQueryData;
+
+const getPageQueryData = () => pageQueryData;
+
+exports.getPageQueryData = getPageQueryData;
+
+const getIsInitialized = () => isInitialized;
+
+exports.getIsInitialized = getIsInitialized;
+
+function socketIo() {
+  if (process.env.NODE_ENV !== `production`) {
+    if (!socket) {
+      // Try to initialize web socket if we didn't do it already
+      try {
+        // eslint-disable-next-line no-undef
+        socket = io();
+
+        const didDataChange = (msg, queryData) => {
+          const id = msg.type === `staticQueryResult` ? msg.payload.id : (0, _normalizePagePath.default)(msg.payload.id);
+          return !(id in queryData) || JSON.stringify(msg.payload.result) !== JSON.stringify(queryData[id]);
+        };
+
+        socket.on(`message`, msg => {
+          if (msg.type === `staticQueryResult`) {
+            if (didDataChange(msg, staticQueryData)) {
+              staticQueryData = Object.assign({}, staticQueryData, {
+                [msg.payload.id]: msg.payload.result
+              });
+            }
+          } else if (msg.type === `pageQueryResult`) {
+            if (didDataChange(msg, pageQueryData)) {
+              pageQueryData = Object.assign({}, pageQueryData, {
+                [(0, _normalizePagePath.default)(msg.payload.id)]: msg.payload.result
+              });
+            }
+          } else if (msg.type === `overlayError`) {
+            if (msg.payload.message) {
+              (0, _errorOverlayHandler.reportError)(msg.payload.id, msg.payload.message);
+            } else {
+              (0, _errorOverlayHandler.clearError)(msg.payload.id);
+            }
+          }
+
+          if (msg.type && msg.payload) {
+            ___emitter.emit(msg.type, msg.payload);
+          }
+        });
+      } catch (err) {
+        console.error(`Could not connect to socket.io on dev server.`);
+      }
+    }
+
+    return socket;
+  } else {
+    return null;
+  }
+}
+
+const inFlightGetPageDataPromiseCache = {};
+
+function getPageData(pathname) {
+  pathname = (0, _normalizePagePath.default)(pathname);
+
+  if (inFlightGetPageDataPromiseCache[pathname]) {
+    return inFlightGetPageDataPromiseCache[pathname];
+  } else {
+    inFlightGetPageDataPromiseCache[pathname] = new Promise(resolve => {
+      if (pageQueryData[pathname]) {
+        delete inFlightGetPageDataPromiseCache[pathname];
+        resolve(pageQueryData[pathname]);
+      } else {
+        const onPageDataCallback = msg => {
+          if (msg.type === `pageQueryResult` && (0, _normalizePagePath.default)(msg.payload.id) === pathname) {
+            socket.off(`message`, onPageDataCallback);
+            delete inFlightGetPageDataPromiseCache[pathname];
+            resolve(pageQueryData[pathname]);
+          }
+        };
+
+        socket.on(`message`, onPageDataCallback);
+        socket.emit(`getDataForPath`, pathname);
+      }
+    });
+  }
+
+  return inFlightGetPageDataPromiseCache[pathname];
+} // Tell websocket-manager.js the new path we're on.
+// This will help the backend prioritize queries for this
+// path.
+
+
+function registerPath(path) {
+  socket.emit(`registerPath`, path);
+} // Unregister the former path
+
+
+function unregisterPath(path) {
+  socket.emit(`unregisterPath`, path);
+}

node_modules/gatsby/cache-dir/commonjs/static-entry.js

@@ -0,0 +1,407 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = exports.sanitizeComponents = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+const React = require(`react`);
+
+const fs = require(`fs`);
+
+const {
+  join
+} = require(`path`);
+
+const {
+  renderToString,
+  renderToStaticMarkup
+} = require(`react-dom/server`);
+
+const {
+  ServerLocation,
+  Router,
+  isRedirect
+} = require(`@reach/router`);
+
+const {
+  get,
+  merge,
+  isObject,
+  flatten,
+  uniqBy,
+  flattenDeep,
+  replace
+} = require(`lodash`);
+
+const apiRunner = require(`./api-runner-ssr`);
+
+const syncRequires = require(`./sync-requires`);
+
+const {
+  version: gatsbyVersion
+} = require(`gatsby/package.json`);
+
+const stats = JSON.parse(fs.readFileSync(`${process.cwd()}/public/webpack.stats.json`, `utf-8`));
+const chunkMapping = JSON.parse(fs.readFileSync(`${process.cwd()}/public/chunk-map.json`, `utf-8`)); // const testRequireError = require("./test-require-error")
+// For some extremely mysterious reason, webpack adds the above module *after*
+// this module so that when this code runs, testRequireError is undefined.
+// So in the meantime, we'll just inline it.
+
+const testRequireError = (moduleName, err) => {
+  const regex = new RegExp(`Error: Cannot find module\\s.${moduleName}`);
+  const firstLine = err.toString().split(`\n`)[0];
+  return regex.test(firstLine);
+};
+
+let Html;
+
+try {
+  Html = require(`../src/html`);
+} catch (err) {
+  if (testRequireError(`../src/html`, err)) {
+    Html = require(`./default-html`);
+  } else {
+    throw err;
+  }
+}
+
+Html = Html && Html.__esModule ? Html.default : Html;
+
+const getPageDataPath = path => {
+  const fixedPagePath = path === `/` ? `index` : path;
+  return join(`page-data`, fixedPagePath, `page-data.json`);
+};
+
+const getPageDataUrl = pagePath => {
+  const pageDataPath = getPageDataPath(pagePath);
+  return `${__PATH_PREFIX__}/${pageDataPath}`;
+};
+
+const getPageDataFile = pagePath => {
+  const pageDataPath = getPageDataPath(pagePath);
+  return join(process.cwd(), `public`, pageDataPath);
+};
+
+const loadPageDataSync = pagePath => {
+  const pageDataPath = getPageDataPath(pagePath);
+  const pageDataFile = join(process.cwd(), `public`, pageDataPath);
+
+  try {
+    const pageDataJson = fs.readFileSync(pageDataFile);
+    return JSON.parse(pageDataJson);
+  } catch (error) {
+    // not an error if file is not found. There's just no page data
+    return null;
+  }
+};
+
+const createElement = React.createElement;
+
+const sanitizeComponents = components => {
+  const componentsArray = ensureArray(components);
+  return componentsArray.map(component => {
+    // Ensure manifest is always loaded from content server
+    // And not asset server when an assetPrefix is used
+    if (__ASSET_PREFIX__ && component.props.rel === `manifest`) {
+      return React.cloneElement(component, {
+        href: replace(component.props.href, __ASSET_PREFIX__, ``)
+      });
+    }
+
+    return component;
+  });
+};
+
+exports.sanitizeComponents = sanitizeComponents;
+
+const ensureArray = components => {
+  if (Array.isArray(components)) {
+    // remove falsy items and flatten
+    return flattenDeep(components.filter(val => Array.isArray(val) ? val.length > 0 : val));
+  } else {
+    // we also accept single components, so we need to handle this case as well
+    return components ? [components] : [];
+  }
+};
+
+var _default = (pagePath, callback) => {
+  let bodyHtml = ``;
+  let headComponents = [React.createElement("meta", {
+    name: "generator",
+    content: `Gatsby ${gatsbyVersion}`,
+    key: `generator-${gatsbyVersion}`
+  })];
+  let htmlAttributes = {};
+  let bodyAttributes = {};
+  let preBodyComponents = [];
+  let postBodyComponents = [];
+  let bodyProps = {};
+
+  const replaceBodyHTMLString = body => {
+    bodyHtml = body;
+  };
+
+  const setHeadComponents = components => {
+    headComponents = headComponents.concat(sanitizeComponents(components));
+  };
+
+  const setHtmlAttributes = attributes => {
+    htmlAttributes = merge(htmlAttributes, attributes);
+  };
+
+  const setBodyAttributes = attributes => {
+    bodyAttributes = merge(bodyAttributes, attributes);
+  };
+
+  const setPreBodyComponents = components => {
+    preBodyComponents = preBodyComponents.concat(sanitizeComponents(components));
+  };
+
+  const setPostBodyComponents = components => {
+    postBodyComponents = postBodyComponents.concat(sanitizeComponents(components));
+  };
+
+  const setBodyProps = props => {
+    bodyProps = merge({}, bodyProps, props);
+  };
+
+  const getHeadComponents = () => headComponents;
+
+  const replaceHeadComponents = components => {
+    headComponents = sanitizeComponents(components);
+  };
+
+  const getPreBodyComponents = () => preBodyComponents;
+
+  const replacePreBodyComponents = components => {
+    preBodyComponents = sanitizeComponents(components);
+  };
+
+  const getPostBodyComponents = () => postBodyComponents;
+
+  const replacePostBodyComponents = components => {
+    postBodyComponents = sanitizeComponents(components);
+  };
+
+  const pageDataRaw = fs.readFileSync(getPageDataFile(pagePath));
+  const pageData = JSON.parse(pageDataRaw);
+  const pageDataUrl = getPageDataUrl(pagePath);
+  const {
+    componentChunkName
+  } = pageData;
+
+  class RouteHandler extends React.Component {
+    render() {
+      const props = Object.assign({}, this.props, pageData.result, {
+        // pathContext was deprecated in v2. Renamed to pageContext
+        pathContext: pageData.result ? pageData.result.pageContext : undefined
+      });
+      const pageElement = createElement(syncRequires.components[componentChunkName], props);
+      const wrappedPage = apiRunner(`wrapPageElement`, {
+        element: pageElement,
+        props
+      }, pageElement, ({
+        result
+      }) => {
+        return {
+          element: result,
+          props
+        };
+      }).pop();
+      return wrappedPage;
+    }
+
+  }
+
+  const routerElement = createElement(ServerLocation, {
+    url: `${__BASE_PATH__}${pagePath}`
+  }, createElement(Router, {
+    id: `gatsby-focus-wrapper`,
+    baseuri: `${__BASE_PATH__}`
+  }, createElement(RouteHandler, {
+    path: `/*`
+  })));
+  const bodyComponent = apiRunner(`wrapRootElement`, {
+    element: routerElement,
+    pathname: pagePath
+  }, routerElement, ({
+    result
+  }) => {
+    return {
+      element: result,
+      pathname: pagePath
+    };
+  }).pop(); // Let the site or plugin render the page component.
+
+  apiRunner(`replaceRenderer`, {
+    bodyComponent,
+    replaceBodyHTMLString,
+    setHeadComponents,
+    setHtmlAttributes,
+    setBodyAttributes,
+    setPreBodyComponents,
+    setPostBodyComponents,
+    setBodyProps,
+    pathname: pagePath,
+    pathPrefix: __PATH_PREFIX__
+  }); // If no one stepped up, we'll handle it.
+
+  if (!bodyHtml) {
+    try {
+      bodyHtml = renderToString(bodyComponent);
+    } catch (e) {
+      // ignore @reach/router redirect errors
+      if (!isRedirect(e)) throw e;
+    }
+  } // Create paths to scripts
+
+
+  let scriptsAndStyles = flatten([`app`, componentChunkName].map(s => {
+    const fetchKey = `assetsByChunkName[${s}]`;
+    let chunks = get(stats, fetchKey);
+    let namedChunkGroups = get(stats, `namedChunkGroups`);
+
+    if (!chunks) {
+      return null;
+    }
+
+    chunks = chunks.map(chunk => {
+      if (chunk === `/`) {
+        return null;
+      }
+
+      return {
+        rel: `preload`,
+        name: chunk
+      };
+    });
+    namedChunkGroups[s].assets.forEach(asset => chunks.push({
+      rel: `preload`,
+      name: asset
+    }));
+    const childAssets = namedChunkGroups[s].childAssets;
+
+    for (const rel in childAssets) {
+      chunks = merge(chunks, childAssets[rel].map(chunk => {
+        return {
+          rel,
+          name: chunk
+        };
+      }));
+    }
+
+    return chunks;
+  })).filter(s => isObject(s)).sort((s1, s2) => s1.rel == `preload` ? -1 : 1); // given priority to preload
+
+  scriptsAndStyles = uniqBy(scriptsAndStyles, item => item.name);
+  const scripts = scriptsAndStyles.filter(script => script.name && script.name.endsWith(`.js`));
+  const styles = scriptsAndStyles.filter(style => style.name && style.name.endsWith(`.css`));
+  apiRunner(`onRenderBody`, {
+    setHeadComponents,
+    setHtmlAttributes,
+    setBodyAttributes,
+    setPreBodyComponents,
+    setPostBodyComponents,
+    setBodyProps,
+    pathname: pagePath,
+    loadPageDataSync,
+    bodyHtml,
+    scripts,
+    styles,
+    pathPrefix: __PATH_PREFIX__
+  });
+  scripts.slice(0).reverse().forEach(script => {
+    // Add preload/prefetch <link>s for scripts.
+    headComponents.push(React.createElement("link", {
+      as: "script",
+      rel: script.rel,
+      key: script.name,
+      href: `${__PATH_PREFIX__}/${script.name}`
+    }));
+  });
+
+  if (pageData) {
+    headComponents.push(React.createElement("link", {
+      as: "fetch",
+      rel: "preload",
+      key: pageDataUrl,
+      href: pageDataUrl,
+      crossOrigin: "anonymous"
+    }));
+  }
+
+  styles.slice(0).reverse().forEach(style => {
+    // Add <link>s for styles that should be prefetched
+    // otherwise, inline as a <style> tag
+    if (style.rel === `prefetch`) {
+      headComponents.push(React.createElement("link", {
+        as: "style",
+        rel: style.rel,
+        key: style.name,
+        href: `${__PATH_PREFIX__}/${style.name}`
+      }));
+    } else {
+      headComponents.unshift(React.createElement("style", {
+        "data-href": `${__PATH_PREFIX__}/${style.name}`,
+        dangerouslySetInnerHTML: {
+          __html: fs.readFileSync(join(process.cwd(), `public`, style.name), `utf-8`)
+        }
+      }));
+    }
+  });
+  const webpackCompilationHash = pageData.webpackCompilationHash; // Add page metadata for the current page
+
+  const windowPageData = `/*<![CDATA[*/window.pagePath="${pagePath}";window.webpackCompilationHash="${webpackCompilationHash}";/*]]>*/`;
+  postBodyComponents.push(React.createElement("script", {
+    key: `script-loader`,
+    id: `gatsby-script-loader`,
+    dangerouslySetInnerHTML: {
+      __html: windowPageData
+    }
+  })); // Add chunk mapping metadata
+
+  const scriptChunkMapping = `/*<![CDATA[*/window.___chunkMapping=${JSON.stringify(chunkMapping)};/*]]>*/`;
+  postBodyComponents.push(React.createElement("script", {
+    key: `chunk-mapping`,
+    id: `gatsby-chunk-mapping`,
+    dangerouslySetInnerHTML: {
+      __html: scriptChunkMapping
+    }
+  })); // Filter out prefetched bundles as adding them as a script tag
+  // would force high priority fetching.
+
+  const bodyScripts = scripts.filter(s => s.rel !== `prefetch`).map(s => {
+    const scriptPath = `${__PATH_PREFIX__}/${JSON.stringify(s.name).slice(1, -1)}`;
+    return React.createElement("script", {
+      key: scriptPath,
+      src: scriptPath,
+      async: true
+    });
+  });
+  postBodyComponents.push(...bodyScripts);
+  apiRunner(`onPreRenderHTML`, {
+    getHeadComponents,
+    replaceHeadComponents,
+    getPreBodyComponents,
+    replacePreBodyComponents,
+    getPostBodyComponents,
+    replacePostBodyComponents,
+    pathname: pagePath,
+    pathPrefix: __PATH_PREFIX__
+  });
+  const html = `<!DOCTYPE html>${renderToStaticMarkup(React.createElement(Html, (0, _extends2.default)({}, bodyProps, {
+    headComponents: headComponents,
+    htmlAttributes: htmlAttributes,
+    bodyAttributes: bodyAttributes,
+    preBodyComponents: preBodyComponents,
+    postBodyComponents: postBodyComponents,
+    body: bodyHtml,
+    path: pagePath
+  })))}`;
+  callback(null, html);
+};
+
+exports.default = _default;

node_modules/gatsby/cache-dir/commonjs/strip-prefix.js

@@ -0,0 +1,15 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+/**
+ * Remove a prefix from a string. Return the input string if the given prefix
+ * isn't found.
+ */
+var _default = (str, prefix = ``) => {
+  if (str.substr(0, prefix.length) === prefix) return str.slice(prefix.length);
+  return str;
+};
+
+exports.default = _default;