@quilted/quilt 0.5.104 → 0.5.107

package/build/esm/static/index.mjs

@@ -1,270 +1,607 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
+import _regeneratorRuntime from '@babel/runtime/regenerator';
 import { render, Html } from '@quilted/react-html/server';
 import { StaticRenderer, StaticRendererContext } from '@quilted/react-router/static';
 import { renderApp } from './render.mjs';
 import { jsx } from 'react/jsx-runtime';
 
-const BASE_URL = 'http://localhost:3000';
-async function renderStatic(App, {
-  assets,
-  routes: startingRoutes,
-  onRender,
-  crawl = true,
-  baseUrl = BASE_URL,
-  prettify = true
-}) {
-  const routesToHandle = startingRoutes.map(route => ({
-    route: removePostfixSlash(new URL(route, baseUrl).pathname),
-    fallback: false
-  }));
-  const seenRoutes = [...routesToHandle];
-  const seenRouteIds = new Set(seenRoutes.map(({
-    route
-  }) => route));
-  let renderableRoute;
-
-  while (renderableRoute = routesToHandle.shift()) {
-    const {
-      route,
-      fallback
-    } = renderableRoute;
-    const url = new URL(route, baseUrl);
-    const {
-      html,
-      http,
-      routes
-    } = await renderUrl(url, {
-      fallback
-    });
-
-    if (crawl) {
-      for (const {
-        routes: routeDefinitions,
-        fallback = false,
-        consumedPath,
-        prefix
-      } of routes) {
-        const basePathname = joinPath(prefix, consumedPath);
-        const baseId = basePathname === '/' ? basePathname : `__QUILT_BASE_${basePathname}__`;
-
-        for (const routeDefinition of routeDefinitions) {
-          await recordRouteDefinition(routeDefinition, {
-            baseId,
-            basePathname,
-            addFallbacks: fallback
-          });
-        }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-        if (fallback && routeDefinitions[routeDefinitions.length - 1]?.match != null) {
-          await recordRouteDefinition({}, {
-            baseId,
-            basePathname,
-            addFallbacks: fallback
-          });
-        }
-      }
-    }
-
-    await onRender({
-      route,
-      content: html,
-      http,
-      fallback,
-      hasChildren: !fallback && seenRoutes.some(otherRoute => otherRoute.route.startsWith(`${route}/`))
-    });
-  }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
-  async function recordRouteDefinition({
-    match,
-    children,
-    renderStatic
-  }, {
-    basePathname,
-    baseId,
-    addFallbacks
-  }) {
-    if (renderStatic === false) return;
-    let routeId;
-    const hasChildren = children && children.length > 0;
-    const hasManualMatches = typeof renderStatic === 'function' && typeof match !== 'string';
-    const matchedRoutes = [];
-
-    if (typeof match === 'string') {
-      routeId = joinPath(baseId, match);
-      matchedRoutes.push({
-        id: routeId,
-        route: joinPath(basePathname, match),
-        fallback: false
-      });
-    } else if (typeof match === 'function') {
-      routeId = joinPath(baseId, `__QUILT_FUNCTION_ROUTE_${match.toString()}__`);
-    } else if (match instanceof RegExp) {
-      routeId = joinPath(`__QUILT_REGEX_ROUTE_${match.source}__`);
-    } else {
-      routeId = joinPath(baseId, '__QUILT_FALLBACK_ROUTE__');
-
-      if (!hasManualMatches) {
-        matchedRoutes.push({
-          id: routeId,
-          route: basePathname,
-          fallback: true
-        });
-      }
-    }
-
-    if (seenRouteIds.has(routeId)) return;
-    seenRouteIds.add(routeId);
-
-    if (typeof renderStatic === 'function' && typeof match !== 'string') {
-      const matchedRouteParts = await renderStatic();
-
-      for (const routePart of matchedRouteParts) {
-        const id = joinPath(baseId, `__QUILT_MATCH_${routePart}__`);
-        seenRouteIds.add(id);
-        matchedRoutes.push({
-          id,
-          route: joinPath(basePathname, routePart),
-          fallback: false
-        });
-      }
-    }
-
-    if (hasChildren) {
-      for (const {
-        id,
-        route
-      } of matchedRoutes) {
-        for (const child of children) {
-          await recordRouteDefinition(child, {
-            addFallbacks,
-            basePathname: route,
-            baseId: id
-          });
-        }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+var BASE_URL = 'http://localhost:3000';
+function renderStatic(_x, _x2) {
+  return _renderStatic.apply(this, arguments);
+}
+
+function _renderStatic() {
+  _renderStatic = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(App, _ref) {
+    var assets, startingRoutes, onRender, _ref$crawl, crawl, _ref$baseUrl, baseUrl, _ref$prettify, prettify, routesToHandle, seenRoutes, seenRouteIds, renderableRoute, _loop, recordRouteDefinition, _recordRouteDefinition, renderUrl, _renderUrl;
+
+    return _regeneratorRuntime.wrap(function _callee3$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            _renderUrl = function _renderUrl3() {
+              _renderUrl = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(url) {
+                var _ref6,
+                    _ref6$fallback,
+                    fallback,
+                    routeRecorder,
+                    _yield$renderApp,
+                    http,
+                    htmlManager,
+                    markup,
+                    asyncAssets,
+                    usedAssets,
+                    _yield$Promise$all,
+                    _yield$Promise$all2,
+                    moduleStyles,
+                    moduleScripts,
+                    modulePreload,
+                    nomoduleStyles,
+                    nomoduleScripts,
+                    styles,
+                    preload,
+                    scripts,
+                    minifiedHtml,
+                    html,
+                    _args3 = arguments;
+
+                return _regeneratorRuntime.wrap(function _callee2$(_context3) {
+                  while (1) {
+                    switch (_context3.prev = _context3.next) {
+                      case 0:
+                        _ref6 = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : {}, _ref6$fallback = _ref6.fallback, fallback = _ref6$fallback === void 0 ? false : _ref6$fallback;
+                        routeRecorder = new StaticRenderer({
+                          forceFallback: fallback ? url.pathname : undefined
+                        });
+                        _context3.next = 4;
+                        return renderApp( /*#__PURE__*/jsx(App, {}), {
+                          url: url,
+                          decorate: function decorate(app) {
+                            return /*#__PURE__*/jsx(StaticRendererContext.Provider, {
+                              value: routeRecorder,
+                              children: app
+                            });
+                          }
+                        });
+
+                      case 4:
+                        _yield$renderApp = _context3.sent;
+                        http = _yield$renderApp.http;
+                        htmlManager = _yield$renderApp.html;
+                        markup = _yield$renderApp.markup;
+                        asyncAssets = _yield$renderApp.asyncAssets;
+                        usedAssets = asyncAssets.used({
+                          timing: 'load'
+                        });
+                        _context3.next = 12;
+                        return Promise.all([assets.styles({
+                          async: usedAssets,
+                          options: {
+                            modules: true
+                          }
+                        }), assets.scripts({
+                          async: usedAssets,
+                          options: {
+                            modules: true
+                          }
+                        }), assets.asyncAssets(asyncAssets.used({
+                          timing: 'preload'
+                        }), {
+                          options: {
+                            modules: true
+                          }
+                        }), assets.styles({
+                          async: usedAssets,
+                          options: {
+                            modules: false
+                          }
+                        }), assets.scripts({
+                          async: usedAssets,
+                          options: {
+                            modules: false
+                          }
+                        })]);
+
+                      case 12:
+                        _yield$Promise$all = _context3.sent;
+                        _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 5);
+                        moduleStyles = _yield$Promise$all2[0];
+                        moduleScripts = _yield$Promise$all2[1];
+                        modulePreload = _yield$Promise$all2[2];
+                        nomoduleStyles = _yield$Promise$all2[3];
+                        nomoduleScripts = _yield$Promise$all2[4];
+                        // We don’t want to load styles from both bundles, so we only use module styles,
+                        // since modules are intended to be the default and CSS (usually) doesn’t
+                        // have features that meaningfully break older user agents.
+                        styles = moduleStyles.length > 0 ? moduleStyles : nomoduleStyles; // If there are nomodule scripts, we can’t really do preloading, because we can’t
+                        // prevent the nomodule scripts from being preloaded in module browsers. If there
+                        // are only module scripts, we can preload those.
+
+                        preload = nomoduleScripts.length > 0 ? [] : modulePreload;
+                        scripts = [].concat(_toConsumableArray(moduleScripts), _toConsumableArray(nomoduleScripts.map(function (script) {
+                          return _objectSpread(_objectSpread({}, script), {}, {
+                            nomodule: true
+                          });
+                        })));
+                        minifiedHtml = render( /*#__PURE__*/jsx(Html, {
+                          url: url,
+                          manager: htmlManager,
+                          styles: styles,
+                          scripts: scripts,
+                          preloadAssets: preload,
+                          children: markup
+                        }));
+
+                        if (!prettify) {
+                          _context3.next = 29;
+                          break;
+                        }
+
+                        _context3.next = 26;
+                        return prettifyHtml(minifiedHtml);
+
+                      case 26:
+                        _context3.t0 = _context3.sent;
+                        _context3.next = 30;
+                        break;
+
+                      case 29:
+                        _context3.t0 = minifiedHtml;
+
+                      case 30:
+                        html = _context3.t0;
+                        return _context3.abrupt("return", {
+                          html: html,
+                          http: http.state,
+                          routes: routeRecorder.state
+                        });
+
+                      case 32:
+                      case "end":
+                        return _context3.stop();
+                    }
+                  }
+                }, _callee2);
+              }));
+              return _renderUrl.apply(this, arguments);
+            };
+
+            renderUrl = function _renderUrl2(_x6) {
+              return _renderUrl.apply(this, arguments);
+            };
+
+            _recordRouteDefinition = function _recordRouteDefinitio2() {
+              _recordRouteDefinition = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref3, _ref4) {
+                var match, children, renderStatic, basePathname, baseId, addFallbacks, routeId, hasChildren, hasManualMatches, matchedRoutes, matchedRouteParts, _iterator3, _step3, routePart, id, _iterator4, _step4, _ref5, _step4$value, _id, route, _iterator5, _step5, child, _i2, _matchedRoutes, _matchedRoutes$_i, _route, fallback, _renderableRoute2;
+
+                return _regeneratorRuntime.wrap(function _callee$(_context2) {
+                  while (1) {
+                    switch (_context2.prev = _context2.next) {
+                      case 0:
+                        match = _ref3.match, children = _ref3.children, renderStatic = _ref3.renderStatic;
+                        basePathname = _ref4.basePathname, baseId = _ref4.baseId, addFallbacks = _ref4.addFallbacks;
+
+                        if (!(renderStatic === false)) {
+                          _context2.next = 4;
+                          break;
+                        }
+
+                        return _context2.abrupt("return");
+
+                      case 4:
+                        hasChildren = children && children.length > 0;
+                        hasManualMatches = typeof renderStatic === 'function' && typeof match !== 'string';
+                        matchedRoutes = [];
+
+                        if (typeof match === 'string') {
+                          routeId = joinPath(baseId, match);
+                          matchedRoutes.push({
+                            id: routeId,
+                            route: joinPath(basePathname, match),
+                            fallback: false
+                          });
+                        } else if (typeof match === 'function') {
+                          routeId = joinPath(baseId, "__QUILT_FUNCTION_ROUTE_".concat(match.toString(), "__"));
+                        } else if (match instanceof RegExp) {
+                          routeId = joinPath("__QUILT_REGEX_ROUTE_".concat(match.source, "__"));
+                        } else {
+                          routeId = joinPath(baseId, '__QUILT_FALLBACK_ROUTE__');
+
+                          if (!hasManualMatches) {
+                            matchedRoutes.push({
+                              id: routeId,
+                              route: basePathname,
+                              fallback: true
+                            });
+                          }
+                        }
+
+                        if (!seenRouteIds.has(routeId)) {
+                          _context2.next = 10;
+                          break;
+                        }
+
+                        return _context2.abrupt("return");
+
+                      case 10:
+                        seenRouteIds.add(routeId);
+
+                        if (!(typeof renderStatic === 'function' && typeof match !== 'string')) {
+                          _context2.next = 17;
+                          break;
+                        }
+
+                        _context2.next = 14;
+                        return renderStatic();
+
+                      case 14:
+                        matchedRouteParts = _context2.sent;
+                        _iterator3 = _createForOfIteratorHelper(matchedRouteParts);
+
+                        try {
+                          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                            routePart = _step3.value;
+                            id = joinPath(baseId, "__QUILT_MATCH_".concat(routePart, "__"));
+                            seenRouteIds.add(id);
+                            matchedRoutes.push({
+                              id: id,
+                              route: joinPath(basePathname, routePart),
+                              fallback: false
+                            });
+                          }
+                        } catch (err) {
+                          _iterator3.e(err);
+                        } finally {
+                          _iterator3.f();
+                        }
+
+                      case 17:
+                        if (!hasChildren) {
+                          _context2.next = 54;
+                          break;
+                        }
+
+                        _iterator4 = _createForOfIteratorHelper(matchedRoutes);
+                        _context2.prev = 19;
+
+                        _iterator4.s();
+
+                      case 21:
+                        if ((_step4 = _iterator4.n()).done) {
+                          _context2.next = 45;
+                          break;
+                        }
+
+                        _step4$value = _step4.value, _id = _step4$value.id, route = _step4$value.route;
+                        _iterator5 = _createForOfIteratorHelper(children);
+                        _context2.prev = 24;
+
+                        _iterator5.s();
+
+                      case 26:
+                        if ((_step5 = _iterator5.n()).done) {
+                          _context2.next = 32;
+                          break;
+                        }
+
+                        child = _step5.value;
+                        _context2.next = 30;
+                        return recordRouteDefinition(child, {
+                          addFallbacks: addFallbacks,
+                          basePathname: route,
+                          baseId: _id
+                        });
+
+                      case 30:
+                        _context2.next = 26;
+                        break;
+
+                      case 32:
+                        _context2.next = 37;
+                        break;
+
+                      case 34:
+                        _context2.prev = 34;
+                        _context2.t0 = _context2["catch"](24);
+
+                        _iterator5.e(_context2.t0);
+
+                      case 37:
+                        _context2.prev = 37;
+
+                        _iterator5.f();
+
+                        return _context2.finish(37);
+
+                      case 40:
+                        if (!(addFallbacks && ((_ref5 = children[children.length - 1]) === null || _ref5 === void 0 ? void 0 : _ref5.match) != null)) {
+                          _context2.next = 43;
+                          break;
+                        }
+
+                        _context2.next = 43;
+                        return recordRouteDefinition({}, {
+                          addFallbacks: addFallbacks,
+                          basePathname: route,
+                          baseId: _id
+                        });
+
+                      case 43:
+                        _context2.next = 21;
+                        break;
+
+                      case 45:
+                        _context2.next = 50;
+                        break;
+
+                      case 47:
+                        _context2.prev = 47;
+                        _context2.t1 = _context2["catch"](19);
 
-        if (addFallbacks && children[children.length - 1]?.match != null) {
-          await recordRouteDefinition({}, {
-            addFallbacks,
-            basePathname: route,
-            baseId: id
-          });
+                        _iterator4.e(_context2.t1);
+
+                      case 50:
+                        _context2.prev = 50;
+
+                        _iterator4.f();
+
+                        return _context2.finish(50);
+
+                      case 53:
+                        return _context2.abrupt("return");
+
+                      case 54:
+                        for (_i2 = 0, _matchedRoutes = matchedRoutes; _i2 < _matchedRoutes.length; _i2++) {
+                          _matchedRoutes$_i = _matchedRoutes[_i2], _route = _matchedRoutes$_i.route, fallback = _matchedRoutes$_i.fallback;
+                          _renderableRoute2 = {
+                            route: _route,
+                            fallback: fallback
+                          };
+                          seenRoutes.push(_renderableRoute2);
+                          routesToHandle.push(_renderableRoute2);
+                        }
+
+                      case 55:
+                      case "end":
+                        return _context2.stop();
+                    }
+                  }
+                }, _callee, null, [[19, 47, 50, 53], [24, 34, 37, 40]]);
+              }));
+              return _recordRouteDefinition.apply(this, arguments);
+            };
+
+            recordRouteDefinition = function _recordRouteDefinitio(_x4, _x5) {
+              return _recordRouteDefinition.apply(this, arguments);
+            };
+
+            assets = _ref.assets, startingRoutes = _ref.routes, onRender = _ref.onRender, _ref$crawl = _ref.crawl, crawl = _ref$crawl === void 0 ? true : _ref$crawl, _ref$baseUrl = _ref.baseUrl, baseUrl = _ref$baseUrl === void 0 ? BASE_URL : _ref$baseUrl, _ref$prettify = _ref.prettify, prettify = _ref$prettify === void 0 ? true : _ref$prettify;
+            routesToHandle = startingRoutes.map(function (route) {
+              return {
+                route: removePostfixSlash(new URL(route, baseUrl).pathname),
+                fallback: false
+              };
+            });
+            seenRoutes = _toConsumableArray(routesToHandle);
+            seenRouteIds = new Set(seenRoutes.map(function (_ref2) {
+              var route = _ref2.route;
+              return route;
+            }));
+            _loop = /*#__PURE__*/_regeneratorRuntime.mark(function _loop() {
+              var _renderableRoute, route, fallback, url, _yield$renderUrl, html, http, routes, _iterator, _step, _routeDefinitions, _step$value, routeDefinitions, _step$value$fallback, _fallback, consumedPath, prefix, basePathname, baseId, _iterator2, _step2, routeDefinition;
+
+              return _regeneratorRuntime.wrap(function _loop$(_context) {
+                while (1) {
+                  switch (_context.prev = _context.next) {
+                    case 0:
+                      _renderableRoute = renderableRoute, route = _renderableRoute.route, fallback = _renderableRoute.fallback;
+                      url = new URL(route, baseUrl);
+                      _context.next = 4;
+                      return renderUrl(url, {
+                        fallback: fallback
+                      });
+
+                    case 4:
+                      _yield$renderUrl = _context.sent;
+                      html = _yield$renderUrl.html;
+                      http = _yield$renderUrl.http;
+                      routes = _yield$renderUrl.routes;
+
+                      if (!crawl) {
+                        _context.next = 46;
+                        break;
+                      }
+
+                      _iterator = _createForOfIteratorHelper(routes);
+                      _context.prev = 10;
+
+                      _iterator.s();
+
+                    case 12:
+                      if ((_step = _iterator.n()).done) {
+                        _context.next = 38;
+                        break;
+                      }
+
+                      _step$value = _step.value, routeDefinitions = _step$value.routes, _step$value$fallback = _step$value.fallback, _fallback = _step$value$fallback === void 0 ? false : _step$value$fallback, consumedPath = _step$value.consumedPath, prefix = _step$value.prefix;
+                      basePathname = joinPath(prefix, consumedPath);
+                      baseId = basePathname === '/' ? basePathname : "__QUILT_BASE_".concat(basePathname, "__");
+                      _iterator2 = _createForOfIteratorHelper(routeDefinitions);
+                      _context.prev = 17;
+
+                      _iterator2.s();
+
+                    case 19:
+                      if ((_step2 = _iterator2.n()).done) {
+                        _context.next = 25;
+                        break;
+                      }
+
+                      routeDefinition = _step2.value;
+                      _context.next = 23;
+                      return recordRouteDefinition(routeDefinition, {
+                        baseId: baseId,
+                        basePathname: basePathname,
+                        addFallbacks: _fallback
+                      });
+
+                    case 23:
+                      _context.next = 19;
+                      break;
+
+                    case 25:
+                      _context.next = 30;
+                      break;
+
+                    case 27:
+                      _context.prev = 27;
+                      _context.t0 = _context["catch"](17);
+
+                      _iterator2.e(_context.t0);
+
+                    case 30:
+                      _context.prev = 30;
+
+                      _iterator2.f();
+
+                      return _context.finish(30);
+
+                    case 33:
+                      if (!(_fallback && ((_routeDefinitions = routeDefinitions[routeDefinitions.length - 1]) === null || _routeDefinitions === void 0 ? void 0 : _routeDefinitions.match) != null)) {
+                        _context.next = 36;
+                        break;
+                      }
+
+                      _context.next = 36;
+                      return recordRouteDefinition({}, {
+                        baseId: baseId,
+                        basePathname: basePathname,
+                        addFallbacks: _fallback
+                      });
+
+                    case 36:
+                      _context.next = 12;
+                      break;
+
+                    case 38:
+                      _context.next = 43;
+                      break;
+
+                    case 40:
+                      _context.prev = 40;
+                      _context.t1 = _context["catch"](10);
+
+                      _iterator.e(_context.t1);
+
+                    case 43:
+                      _context.prev = 43;
+
+                      _iterator.f();
+
+                      return _context.finish(43);
+
+                    case 46:
+                      _context.next = 48;
+                      return onRender({
+                        route: route,
+                        content: html,
+                        http: http,
+                        fallback: fallback,
+                        hasChildren: !fallback && seenRoutes.some(function (otherRoute) {
+                          return otherRoute.route.startsWith("".concat(route, "/"));
+                        })
+                      });
+
+                    case 48:
+                    case "end":
+                      return _context.stop();
+                  }
+                }
+              }, _loop, null, [[10, 40, 43, 46], [17, 27, 30, 33]]);
+            });
+
+          case 9:
+            if (!(renderableRoute = routesToHandle.shift())) {
+              _context4.next = 13;
+              break;
+            }
+
+            return _context4.delegateYield(_loop(), "t0", 11);
+
+          case 11:
+            _context4.next = 9;
+            break;
+
+          case 13:
+          case "end":
+            return _context4.stop();
         }
       }
+    }, _callee3);
+  }));
+  return _renderStatic.apply(this, arguments);
+}
 
-      return;
-    }
-
-    for (const {
-      route,
-      fallback
-    } of matchedRoutes) {
-      const renderableRoute = {
-        route,
-        fallback
-      };
-      seenRoutes.push(renderableRoute);
-      routesToHandle.push(renderableRoute);
-    }
-  }
+function prettifyHtml(_x3) {
+  return _prettifyHtml.apply(this, arguments);
+}
 
-  async function renderUrl(url, {
-    fallback = false
-  }) {
-    const routeRecorder = new StaticRenderer({
-      forceFallback: fallback ? url.pathname : undefined
-    });
-    const {
-      http,
-      html: htmlManager,
-      markup,
-      asyncAssets
-    } = await renderApp( /*#__PURE__*/jsx(App, {}), {
-      url,
-
-      decorate(app) {
-        return /*#__PURE__*/jsx(StaticRendererContext.Provider, {
-          value: routeRecorder,
-          children: app
-        });
-      }
+function _prettifyHtml() {
+  _prettifyHtml = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(html) {
+    var _yield$import, prettier;
 
-    });
-    const usedAssets = asyncAssets.used({
-      timing: 'load'
-    });
-    const [moduleStyles, moduleScripts, modulePreload, nomoduleStyles, nomoduleScripts] = await Promise.all([assets.styles({
-      async: usedAssets,
-      options: {
-        modules: true
-      }
-    }), assets.scripts({
-      async: usedAssets,
-      options: {
-        modules: true
-      }
-    }), assets.asyncAssets(asyncAssets.used({
-      timing: 'preload'
-    }), {
-      options: {
-        modules: true
-      }
-    }), assets.styles({
-      async: usedAssets,
-      options: {
-        modules: false
-      }
-    }), assets.scripts({
-      async: usedAssets,
-      options: {
-        modules: false
+    return _regeneratorRuntime.wrap(function _callee4$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            _context5.prev = 0;
+            _context5.next = 3;
+            return import('prettier');
+
+          case 3:
+            _yield$import = _context5.sent;
+            prettier = _yield$import["default"];
+            return _context5.abrupt("return", prettier.format(html, {
+              parser: 'html'
+            }));
+
+          case 8:
+            _context5.prev = 8;
+            _context5.t0 = _context5["catch"](0);
+            return _context5.abrupt("return", html);
+
+          case 11:
+          case "end":
+            return _context5.stop();
+        }
       }
-    })]); // We don’t want to load styles from both bundles, so we only use module styles,
-    // since modules are intended to be the default and CSS (usually) doesn’t
-    // have features that meaningfully break older user agents.
-
-    const styles = moduleStyles.length > 0 ? moduleStyles : nomoduleStyles; // If there are nomodule scripts, we can’t really do preloading, because we can’t
-    // prevent the nomodule scripts from being preloaded in module browsers. If there
-    // are only module scripts, we can preload those.
-
-    const preload = nomoduleScripts.length > 0 ? [] : modulePreload;
-    const scripts = [...moduleScripts, ...nomoduleScripts.map(script => ({ ...script,
-      nomodule: true
-    }))];
-    const minifiedHtml = render( /*#__PURE__*/jsx(Html, {
-      url: url,
-      manager: htmlManager,
-      styles: styles,
-      scripts: scripts,
-      preloadAssets: preload,
-      children: markup
-    }));
-    const html = prettify ? await prettifyHtml(minifiedHtml) : minifiedHtml;
-    return {
-      html,
-      http: http.state,
-      routes: routeRecorder.state
-    };
-  }
+    }, _callee4, null, [[0, 8]]);
+  }));
+  return _prettifyHtml.apply(this, arguments);
 }
 
-async function prettifyHtml(html) {
-  try {
-    const {
-      default: prettier
-    } = await import('prettier');
-    return prettier.format(html, {
-      parser: 'html'
-    });
-  } catch (error) {
-    return html;
-  }
-}
+function joinPath() {
+  var path = '/';
 
-function joinPath(...parts) {
-  let path = '/';
+  for (var _len = arguments.length, parts = new Array(_len), _key = 0; _key < _len; _key++) {
+    parts[_key] = arguments[_key];
+  }
 
-  for (const part of parts) {
+  for (var _i = 0, _parts = parts; _i < _parts.length; _i++) {
+    var part = _parts[_i];
     if (typeof part !== 'string') continue;
-    const normalizedPart = part.startsWith('/') ? part.slice(1) : part;
+    var normalizedPart = part.startsWith('/') ? part.slice(1) : part;
     if (normalizedPart.length === 0) continue;
     if (path !== '/') path += '/';
     path += normalizedPart;