gatsby 3.14.0-drupal-next.70 → 3.14.0-drupal-next.78

package/apis.json

@@ -0,0 +1,63 @@
+{
+  "ssr": {
+    "replaceRenderer": {},
+    "onRenderBody": {},
+    "onPreRenderHTML": {},
+    "wrapPageElement": {},
+    "wrapRootElement": {}
+  },
+  "browser": {
+    "onClientEntry": {},
+    "onInitialClientRender": {},
+    "onPreRouteUpdate": {},
+    "onRouteUpdateDelayed": {},
+    "onRouteUpdate": {},
+    "shouldUpdateScroll": {},
+    "registerServiceWorker": {},
+    "wrapPageElement": {},
+    "wrapRootElement": {},
+    "onPrefetchPathname": {},
+    "onPostPrefetchPathname": {},
+    "disableCorePrefetching": {},
+    "replaceHydrateFunction": {},
+    "onServiceWorkerInstalled": {},
+    "onServiceWorkerUpdateFound": {},
+    "onServiceWorkerUpdateReady": {},
+    "onServiceWorkerActive": {},
+    "onServiceWorkerRedundant": {}
+  },
+  "node": {
+    "resolvableExtensions": {},
+    "createPages": {},
+    "createPagesStatefully": {},
+    "sourceNodes": {},
+    "onCreateNode": {},
+    "unstable_shouldOnCreateNode": {
+      "version": "2.24.80"
+    },
+    "onCreatePage": {},
+    "setFieldsOnGraphQLNodeType": {},
+    "createSchemaCustomization": {
+      "version": "2.12.0"
+    },
+    "createResolvers": {
+      "version": "2.2.0"
+    },
+    "preprocessSource": {},
+    "onCreateBabelConfig": {},
+    "onCreateWebpackConfig": {},
+    "onPreInit": {},
+    "unstable_onPluginInit": {
+      "version": "3.9.0"
+    },
+    "onPreBootstrap": {},
+    "onPostBootstrap": {},
+    "onPreBuild": {},
+    "onPostBuild": {},
+    "onPreExtractQueries": {},
+    "onCreateDevServer": {},
+    "pluginOptionsSchema": {
+      "version": "2.25.0"
+    }
+  }
+}

package/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 = [];

package/cache-dir/commonjs/api-runner-browser.js

@@ -0,0 +1,55 @@
+"use strict";
+
+const plugins = require(`./api-runner-browser-plugins`);
+
+const {
+  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;
+    }
+
+    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());

package/cache-dir/commonjs/api-runner-ssr.js

@@ -0,0 +1,101 @@
+"use strict";
+
+exports.__esModule = true;
+exports.apiRunner = apiRunner;
+exports.apiRunnerAsync = apiRunnerAsync;
+
+/* global plugins */
+// 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`);
+
+function augmentErrorWithPlugin(plugin, err) {
+  if (plugin.name !== `default-site-plugin`) {
+    // default-site-plugin is user code and will print proper stack trace,
+    // so no point in annotating error message pointing out which plugin is root of the problem
+    err.message += ` (from plugin: ${plugin.name})`;
+  }
+
+  throw err;
+}
+
+function apiRunner(api, args, defaultReturn, argTransform) {
+  if (!apis[api]) {
+    console.log(`This API doesn't exist`, api);
+  }
+
+  const results = [];
+  plugins.forEach(plugin => {
+    const apiFn = plugin.plugin[api];
+
+    if (!apiFn) {
+      return;
+    }
+
+    try {
+      const result = apiFn(args, plugin.options);
+
+      if (result && argTransform) {
+        args = argTransform({
+          args,
+          result
+        });
+      } // This if case keeps behaviour as before, we should allow undefined here as the api is defined
+      // TODO V4
+
+
+      if (typeof result !== `undefined`) {
+        results.push(result);
+      }
+    } catch (e) {
+      augmentErrorWithPlugin(plugin, e);
+    }
+  });
+  return results.length ? results : [defaultReturn];
+}
+
+async function apiRunnerAsync(api, args, defaultReturn, argTransform) {
+  if (!apis[api]) {
+    console.log(`This API doesn't exist`, api);
+  }
+
+  const results = [];
+
+  for (const plugin of plugins) {
+    const apiFn = plugin.plugin[api];
+
+    if (!apiFn) {
+      continue;
+    }
+
+    try {
+      const result = await apiFn(args, plugin.options);
+
+      if (result && argTransform) {
+        args = argTransform({
+          args,
+          result
+        });
+      } // This if case keeps behaviour as before, we should allow undefined here as the api is defined
+      // TODO V4
+
+
+      if (typeof result !== `undefined`) {
+        results.push(result);
+      }
+    } catch (e) {
+      augmentErrorWithPlugin(plugin, e);
+    }
+  }
+
+  return results.length ? results : [defaultReturn];
+}

package/cache-dir/commonjs/api-ssr-docs.js

@@ -0,0 +1,207 @@
+"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 {ReactNode} $0.bodyComponent The React element to be rendered as the page body
+ * @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
+ * // Import React so that you can use JSX in HeadComponents
+ * const React = require("react")
+ *
+ * const HtmlAttributes = {
+ *   lang: "en"
+ * }
+ *
+ * const HeadComponents = [
+ *   <script key="my-script" src="https://gatsby.dev/my-script" />
+ * ]
+ *
+ * const BodyAttributes = {
+ *   "data-theme": "dark"
+ * }
+ *
+ * exports.onRenderBody = ({
+ *   setHeadComponents,
+ *   setHtmlAttributes,
+ *   setBodyAttributes
+ * }, pluginOptions) => {
+ *   setHtmlAttributes(HtmlAttributes)
+ *   setHeadComponents(HeadComponents)
+ *   setBodyAttributes(BodyAttributes)
+ * }
+ */
+
+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 components around pages that won't get
+ * unmounted on page changes. For setting Provider components, use [wrapRootElement](#wrapRootElement).
+ *
+ * _Note:_
+ * There is an equivalent hook in Gatsby's [Browser API](/docs/browser-apis/#wrapPageElement).
+ * It is recommended to use both APIs together.
+ * For example usage, check out [Using i18n](https://github.com/gatsbyjs/gatsby/tree/master/examples/using-i18n).
+ * @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 set up any Provider components that will wrap your application.
+ * For setting persistent UI elements around pages use [wrapPageElement](#wrapPageElement).
+ *
+ * _Note:_
+ * There is an equivalent hook in Gatsby's [Browser API](/docs/browser-apis/#wrapRootElement).
+ * It is recommended to use both APIs together.
+ * For example usage, check out [Using redux](https://github.com/gatsbyjs/gatsby/tree/master/examples/using-redux).
+ * @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;

package/cache-dir/commonjs/app.js

@@ -0,0 +1,217 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.notCalledFunction = notCalledFunction;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactDom = _interopRequireDefault(require("react-dom"));
+
+var _socket = _interopRequireDefault(require("socket.io-client"));
+
+var _socketIo = _interopRequireDefault(require("./socketIo"));
+
+var _emitter = _interopRequireDefault(require("./emitter"));
+
+var _apiRunnerBrowser = require("./api-runner-browser");
+
+var _loader = require("./loader");
+
+var _indicator = require("./loading-indicator/indicator");
+
+var _devLoader = _interopRequireDefault(require("./dev-loader"));
+
+var _asyncRequires = _interopRequireDefault(require("$virtual/async-requires"));
+
+var _matchPaths = _interopRequireDefault(require("$virtual/match-paths.json"));
+
+var _loadingIndicator = require("./loading-indicator");
+
+var _root = _interopRequireDefault(require("./root"));
+
+var _navigation = require("./navigation");
+
+require("./blank.css");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+// Enable fast-refresh for virtual sync-requires, gatsby-browser & navigation
+// To ensure that our <Root /> component can hot reload in case anything below doesn't
+// satisfy fast-refresh constraints
+module.hot.accept([`$virtual/async-requires`, `./api-runner-browser`, `./navigation`], () => {
+  // asyncRequires should be automatically updated here (due to ESM import and webpack HMR spec),
+  // but loader doesn't know that and needs to be manually nudged
+  loader.updateAsyncRequires(_asyncRequires.default);
+});
+window.___emitter = _emitter.default;
+const loader = new _devLoader.default(_asyncRequires.default, _matchPaths.default);
+(0, _loader.setLoader)(loader);
+loader.setApiRunner(_apiRunnerBrowser.apiRunner);
+window.___loader = _loader.publicLoader; // Do dummy dynamic import so the jsonp __webpack_require__.e is added to the commons.js
+// bundle. This ensures hot reloading doesn't break when someone first adds
+// a dynamic import.
+//
+// Without this, the runtime breaks with a
+// "TypeError: __webpack_require__.e is not a function"
+// error.
+
+function notCalledFunction() {
+  return Promise.resolve().then(() => _interopRequireWildcard(require(`./dummy`)));
+} // 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();
+    });
+  }
+
+  fetch(`/___services`).then(res => res.json()).then(services => {
+    if (services.developstatusserver) {
+      let isRestarting = false;
+      const parentSocket = (0, _socket.default)(`${window.location.protocol}//${window.location.hostname}:${services.developstatusserver.port}`);
+      parentSocket.on(`structured-log`, msg => {
+        if (!isRestarting && msg.type === `LOG_ACTION` && msg.action.type === `DEVELOP` && msg.action.payload === `RESTART_REQUIRED` && window.confirm(`The develop process needs to be restarted for the changes to ${msg.action.dirtyFile} to be applied.\nDo you want to restart the develop process now?`)) {
+          isRestarting = true;
+          parentSocket.emit(`develop:restart`, () => {
+            window.location.reload();
+          });
+        }
+
+        if (isRestarting && msg.type === `LOG_ACTION` && msg.action.type === `SET_STATUS` && msg.action.payload === `SUCCESS`) {
+          isRestarting = false;
+          window.location.reload();
+        }
+      }); // Prevents certain browsers spamming XHR 'ERR_CONNECTION_REFUSED'
+      // errors within the console, such as when exiting the develop process.
+
+      parentSocket.on(`disconnect`, () => {
+        console.warn(`[socket.io] Disconnected. Unable to perform health-check.`);
+        parentSocket.close();
+      });
+    }
+  });
+  /**
+   * 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 focusEl = document.getElementById(`gatsby-focus-wrapper`); // Client only pages have any empty body so we just do a normal
+  // render to avoid React complaining about hydration mis-matches.
+
+  let defaultRenderer = _reactDom.default.render;
+
+  if (focusEl && focusEl.children.length) {
+    if (_reactDom.default.hydrateRoot) {
+      defaultRenderer = _reactDom.default.hydrateRoot;
+    } else {
+      defaultRenderer = _reactDom.default.hydrate;
+    }
+  }
+
+  const renderer = (0, _apiRunnerBrowser.apiRunner)(`replaceHydrateFunction`, undefined, defaultRenderer)[0];
+  let dismissLoadingIndicator;
+
+  if (process.env.GATSBY_EXPERIMENTAL_QUERY_ON_DEMAND && process.env.GATSBY_QUERY_ON_DEMAND_LOADING_INDICATOR === `true`) {
+    let indicatorMountElement;
+    const showIndicatorTimeout = setTimeout(() => {
+      indicatorMountElement = document.createElement(`first-render-loading-indicator`);
+      document.body.append(indicatorMountElement);
+
+      _reactDom.default.render( /*#__PURE__*/_react.default.createElement(_indicator.Indicator, null), indicatorMountElement);
+    }, 1000);
+
+    dismissLoadingIndicator = () => {
+      clearTimeout(showIndicatorTimeout);
+
+      if (indicatorMountElement) {
+        _reactDom.default.unmountComponentAtNode(indicatorMountElement);
+
+        indicatorMountElement.remove();
+      }
+    };
+  }
+
+  Promise.all([loader.loadPage(`/dev-404-page/`), loader.loadPage(`/404.html`), loader.loadPage(window.location.pathname)]).then(() => {
+    (0, _navigation.init)();
+
+    function onHydrated() {
+      (0, _apiRunnerBrowser.apiRunner)(`onInitialClientRender`); // Render query on demand overlay
+
+      if (process.env.GATSBY_QUERY_ON_DEMAND_LOADING_INDICATOR && process.env.GATSBY_QUERY_ON_DEMAND_LOADING_INDICATOR === `true`) {
+        const indicatorMountElement = document.createElement(`div`);
+        indicatorMountElement.setAttribute(`id`, `query-on-demand-indicator-element`);
+        document.body.append(indicatorMountElement);
+
+        if (renderer === _reactDom.default.hydrateRoot) {
+          _reactDom.default.createRoot(indicatorMountElement).render( /*#__PURE__*/_react.default.createElement(_loadingIndicator.LoadingIndicatorEventHandler, null));
+        } else {
+          _reactDom.default.render( /*#__PURE__*/_react.default.createElement(_loadingIndicator.LoadingIndicatorEventHandler, null), indicatorMountElement);
+        }
+      }
+    }
+
+    function App() {
+      const onClientEntryRanRef = _react.default.useRef(false);
+
+      _react.default.useEffect(() => {
+        if (!onClientEntryRanRef.current) {
+          onClientEntryRanRef.current = true;
+          onHydrated();
+        }
+      }, []);
+
+      return /*#__PURE__*/_react.default.createElement(_root.default, null);
+    }
+
+    function runRender() {
+      if (dismissLoadingIndicator) {
+        dismissLoadingIndicator();
+      }
+
+      if (renderer === _reactDom.default.hydrateRoot) {
+        renderer(rootElement, /*#__PURE__*/_react.default.createElement(App, null));
+      } else {
+        renderer( /*#__PURE__*/_react.default.createElement(App, null), rootElement);
+      }
+    } // https://github.com/madrobby/zepto/blob/b5ed8d607f67724788ec9ff492be297f64d47dfc/src/zepto.js#L439-L450
+    // TODO remove IE 10 support
+
+
+    const doc = document;
+
+    if (doc.readyState === `complete` || doc.readyState !== `loading` && !doc.documentElement.doScroll) {
+      setTimeout(function () {
+        runRender();
+      }, 0);
+    } else {
+      const handler = function () {
+        doc.removeEventListener(`DOMContentLoaded`, handler, false);
+        window.removeEventListener(`load`, handler, false);
+        runRender();
+      };
+
+      doc.addEventListener(`DOMContentLoaded`, handler, false);
+      window.addEventListener(`load`, handler, false);
+    }
+  });
+});

package/cache-dir/commonjs/css-to-object.js

@@ -0,0 +1,21 @@
+"use strict";
+
+exports.__esModule = true;
+exports.css = css;
+
+/**
+ * Converts a string of CSS into object syntax
+ * @param strings
+ * @param keys
+ * @returns {Object} CSS in object syntax
+ * @example
+ * const output = css`
+ *  html {
+ *    color: rebeccapurple;
+ *  }
+ * `
+ */
+function css(strings, ...keys) {
+  const lastIndex = strings.length - 1;
+  return strings.slice(0, lastIndex).reduce((p, s, i) => p + s + keys[i], ``) + strings[lastIndex];
+}