@quilted/quilt 0.5.106 → 0.5.107

package/build/esm/static/index.mjs

@@ -0,0 +1,618 @@
+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';
+
+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; }
+
+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; }
+
+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);
+
+                        _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);
+}
+
+function prettifyHtml(_x3) {
+  return _prettifyHtml.apply(this, arguments);
+}
+
+function _prettifyHtml() {
+  _prettifyHtml = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(html) {
+    var _yield$import, prettier;
+
+    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();
+        }
+      }
+    }, _callee4, null, [[0, 8]]);
+  }));
+  return _prettifyHtml.apply(this, arguments);
+}
+
+function joinPath() {
+  var path = '/';
+
+  for (var _len = arguments.length, parts = new Array(_len), _key = 0; _key < _len; _key++) {
+    parts[_key] = arguments[_key];
+  }
+
+  for (var _i = 0, _parts = parts; _i < _parts.length; _i++) {
+    var part = _parts[_i];
+    if (typeof part !== 'string') continue;
+    var normalizedPart = part.startsWith('/') ? part.slice(1) : part;
+    if (normalizedPart.length === 0) continue;
+    if (path !== '/') path += '/';
+    path += normalizedPart;
+    path = removePostfixSlash(path);
+  }
+
+  return path;
+}
+
+function removePostfixSlash(value) {
+  return value.endsWith('/') && value !== '/' ? value.slice(0, value.length - 1) : value;
+}
+
+export { renderStatic };

package/build/esm/static/render.mjs

@@ -0,0 +1,78 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
+import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
+import _regeneratorRuntime from '@babel/runtime/regenerator';
+import { extract } from '@quilted/react-server-render/server';
+import { HtmlManager } from '@quilted/react-html/server';
+import { HttpManager } from '@quilted/react-http/server';
+import { AsyncAssetManager } from '@quilted/react-async/server';
+import { StaticContext } from './StaticContext.mjs';
+import { jsx } from 'react/jsx-runtime';
+
+var _excluded = ["decorate", "url", "headers"];
+
+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; }
+
+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; }
+function renderApp(_x) {
+  return _renderApp.apply(this, arguments);
+}
+
+function _renderApp() {
+  _renderApp = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(app) {
+    var _ref,
+        _decorate,
+        url,
+        headers,
+        rest,
+        html,
+        asyncAssets,
+        http,
+        markup,
+        _args = arguments;
+
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _ref = _args.length > 1 && _args[1] !== undefined ? _args[1] : {}, _decorate = _ref.decorate, url = _ref.url, headers = _ref.headers, rest = _objectWithoutProperties(_ref, _excluded);
+            html = new HtmlManager();
+            asyncAssets = new AsyncAssetManager();
+            http = new HttpManager({
+              headers: headers
+            });
+            _context.next = 6;
+            return extract(app, _objectSpread({
+              decorate: function decorate(app) {
+                var _decorate2;
+
+                return /*#__PURE__*/jsx(StaticContext, {
+                  asyncAssets: asyncAssets,
+                  html: html,
+                  http: http,
+                  url: url,
+                  children: (_decorate2 = _decorate === null || _decorate === void 0 ? void 0 : _decorate(app)) !== null && _decorate2 !== void 0 ? _decorate2 : app
+                });
+              }
+            }, rest));
+
+          case 6:
+            markup = _context.sent;
+            return _context.abrupt("return", {
+              markup: markup,
+              http: http,
+              html: html,
+              asyncAssets: asyncAssets
+            });
+
+          case 8:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _renderApp.apply(this, arguments);
+}
+
+export { renderApp };