@modern-js/runtime 1.21.5 → 2.0.0-beta.1

package/dist/js/treeshaking/ssr/serverRender/index.js

@@ -1,63 +1,41 @@
 import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import { run } from '@modern-js/utils/ssr';
-import { PreRender } from "../react/prerender";
-import SSREntry from "./entry";
-import { time } from "./measure";
-export var render = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(ctx, config, App) {
-    var ssrContext;
-    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+/* eslint-disable eslint-comments/disable-enable-pair */
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable @typescript-eslint/no-require-imports */
+
+import { isReact18 } from "../utils";
+export default function serverRender(_x) {
+  return _serverRender.apply(this, arguments);
+}
+function _serverRender() {
+  _serverRender = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(options) {
+    var pipe, html;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
       while (1) {
-        switch (_context2.prev = _context2.next) {
+        switch (_context.prev = _context.next) {
           case 0:
-            ssrContext = ctx.ssrContext;
-            return _context2.abrupt("return", run(ssrContext.request.headers, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
-              var entry, end, html, cost, cacheConfig;
-              return _regeneratorRuntime().wrap(function _callee$(_context) {
-                while (1) {
-                  switch (_context.prev = _context.next) {
-                    case 0:
-                      entry = new SSREntry({
-                        ctx: ssrContext,
-                        App: App,
-                        config: config
-                      });
-                      entry.metrics.emitCounter('app.visit.count', 1);
-                      end = time();
-                      _context.next = 5;
-                      return entry.renderToHtml(ctx);
-
-                    case 5:
-                      html = _context.sent;
-                      cost = end();
-                      entry.logger.info('App Render Total cost = %d ms', cost);
-                      entry.metrics.emitTimer('app.render.cost', cost);
-                      cacheConfig = PreRender.config();
-
-                      if (cacheConfig) {
-                        ctx.ssrContext.cacheConfig = cacheConfig;
-                      }
-
-                      return _context.abrupt("return", html);
-
-                    case 12:
-                    case "end":
-                      return _context.stop();
-                  }
-                }
-              }, _callee);
-            }))));
-
-          case 2:
+            if (!(isReact18() && options.config.mode === 'stream')) {
+              _context.next = 7;
+              break;
+            }
+            _context.next = 3;
+            return require("./renderToStream").render(options);
+          case 3:
+            pipe = _context.sent;
+            return _context.abrupt("return", pipe);
+          case 7:
+            _context.next = 9;
+            return require("./renderToString").render(options);
+          case 9:
+            html = _context.sent;
+            return _context.abrupt("return", html);
+          case 11:
           case "end":
-            return _context2.stop();
+            return _context.stop();
         }
       }
-    }, _callee2);
+    }, _callee);
   }));
-
-  return function render(_x, _x2, _x3) {
-    return _ref.apply(this, arguments);
-  };
-}();
+  return _serverRender.apply(this, arguments);
+}

package/dist/js/treeshaking/ssr/serverRender/renderToStream/buildTemplate.after.js

@@ -0,0 +1,32 @@
+import serialize from 'serialize-javascript';
+import { buildTemplate } from "./buildTemplate.share";
+export function buildShellAfterTemplate(afterAppTemplate, options) {
+  var callbacks = [injectSSRDataScript];
+  return buildTemplate(afterAppTemplate, callbacks);
+  function injectSSRDataScript(template) {
+    var ssrDataScript = buildSSRDataScript();
+    return template.replace('<!--<?- SSRDataScript ?>-->', ssrDataScript);
+    function buildSSRDataScript() {
+      var ssrContext = options.ssrContext,
+        renderLevel = options.renderLevel;
+      var request = ssrContext.request;
+      var SSRData = {
+        context: {
+          request: {
+            params: request.params,
+            query: request.query,
+            pathname: request.pathname,
+            host: request.host,
+            url: request.url,
+            headers: request.headers,
+            cookieMap: request.cookieMap
+          }
+        },
+        renderLevel: renderLevel
+      };
+      return "\n      <script>window._SSR_DATA = ".concat(serialize(SSRData, {
+        isJSON: true
+      }), "</script>\n      ");
+    }
+  }
+}

package/dist/js/treeshaking/ssr/serverRender/renderToStream/buildTemplate.share.js

@@ -0,0 +1,7 @@
+// share script
+export var HEAD_REG_EXP = /<head(.|\n)*>(.|\n)*<\/head>/;
+export function buildTemplate(template, callbacks) {
+  return callbacks.reduce(function (template, buildTemplateCb) {
+    return buildTemplateCb(template);
+  }, template);
+}

package/dist/js/treeshaking/ssr/serverRender/renderToStream/bulidTemplate.before.js

@@ -0,0 +1,60 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import ReactHelmet from 'react-helmet';
+import { matchRoutes } from 'react-router-dom';
+import helmetReplace from "../helmet";
+import { HEAD_REG_EXP, buildTemplate } from "./buildTemplate.share";
+var CSS_CHUNKS_PLACEHOLDER = '<!--<?- chunksMap.css ?>-->';
+
+// build head template
+function getHeadTemplate(beforeEntryTemplate, context) {
+  var callbacks = [function (headTemplate) {
+    var helmetData = ReactHelmet.renderStatic();
+    return helmetData ? helmetReplace(headTemplate, helmetData) : headTemplate;
+  },
+  // @TODO: prefetch scripts of lazy component
+  injectCss];
+  var _ref = beforeEntryTemplate.match(HEAD_REG_EXP) || [],
+    _ref2 = _slicedToArray(_ref, 1),
+    _ref2$ = _ref2[0],
+    headTemplate = _ref2$ === void 0 ? '' : _ref2$;
+  if (!headTemplate.length) {
+    return '';
+  }
+  return buildTemplate(headTemplate, callbacks);
+  function injectCss(headTemplate) {
+    return headTemplate.replace(CSS_CHUNKS_PLACEHOLDER, getCssChunks());
+    function getCssChunks() {
+      var routeManifest = context.routeManifest,
+        routerContext = context.routerContext,
+        routes = context.routes;
+      if (!routeManifest || !routerContext || !routes) {
+        return '';
+      }
+      var routeAssets = routeManifest.routeAssets;
+      var cssChunks = [];
+      var matches = matchRoutes(routes, routerContext.location);
+      matches === null || matches === void 0 ? void 0 : matches.forEach(function (match) {
+        var routeId = match.route.id;
+        if (routeId) {
+          var _routeAssets$routeId$ = routeAssets[routeId].assets,
+            assets = _routeAssets$routeId$ === void 0 ? [] : _routeAssets$routeId$;
+          var _cssChunks = assets.filter(function (asset) {
+            return asset === null || asset === void 0 ? void 0 : asset.endsWith('.css');
+          });
+          cssChunks.push.apply(cssChunks, _toConsumableArray(_cssChunks));
+        }
+      });
+      var styleLinks = cssChunks.map(function (chunk) {
+        return "<link href=\"".concat(chunk, "\" rel=\"stylesheet\" />");
+      });
+      return "".concat(styleLinks.join(''));
+    }
+  }
+}
+
+// build script
+export function buildShellBeforeTemplate(beforeAppTemplate, context) {
+  var headTemplate = getHeadTemplate(beforeAppTemplate, context);
+  return beforeAppTemplate.replace(HEAD_REG_EXP, headTemplate);
+}

package/dist/js/treeshaking/ssr/serverRender/renderToStream/index.js

@@ -0,0 +1,50 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { createElement } from 'react';
+import { run } from '@modern-js/utils/ssr';
+import { PreRender } from "../../react/prerender";
+import { time } from "../utils";
+import renderToPipe from "./renderToPipe";
+export var render = function render(_ref) {
+  var App = _ref.App,
+    context = _ref.context;
+  var ssrContext = context.ssrContext;
+  if (!ssrContext) {
+    throw new Error('The "ssrContext" must not be undefined, but received undefined');
+  }
+  return run(ssrContext.request.headers, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    var end, rootElement, pipe;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            end = time();
+            rootElement = /*#__PURE__*/createElement(App, {
+              context: Object.assign(context || {}, {
+                ssr: true
+              })
+            });
+            pipe = renderToPipe(rootElement, context, {
+              onShellReady: function onShellReady() {
+                // set cacheConfig
+                var cacheConfig = PreRender.config();
+                if (cacheConfig) {
+                  ssrContext.cacheConfig = cacheConfig;
+                }
+              },
+              onAllReady: function onAllReady() {
+                // calculate streaming ssr cost
+                var cost = end();
+                ssrContext.logger.debug('App Render To HTML cost = %d ms', cost);
+                ssrContext.metrics.emitTimer('app.render.html.cost', cost);
+              }
+            });
+            return _context.abrupt("return", pipe);
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  })));
+};

package/dist/js/treeshaking/ssr/serverRender/renderToStream/loadable.js

@@ -0,0 +1,22 @@
+import { ChunkExtractor } from '@loadable/server';
+export function getLoadableChunks(_ref) {
+  var context = _ref.context,
+    jsx = _ref.jsx;
+  var _ref2 = context.ssrContext,
+    loadableStats = _ref2.loadableStats,
+    entryName = _ref2.entryName;
+  if (!loadableStats) {
+    return {
+      jsx: jsx
+    };
+  }
+  var extractor = new ChunkExtractor({
+    stats: loadableStats,
+    entrypoints: [entryName]
+  });
+  var collectedJsx = extractor.collectChunks(jsx);
+  return {
+    jsx: collectedJsx,
+    chunkExtractor: extractor
+  };
+}

package/dist/js/treeshaking/ssr/serverRender/renderToStream/renderToPipe.js

@@ -0,0 +1,68 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { Transform } from 'stream';
+import { renderToPipeableStream } from 'react-dom/server';
+import { RenderLevel } from "../types";
+import { getTemplates } from "./template";
+function renderToPipe(rootElement, context, options) {
+  var isShellStream = true;
+  var ssrContext = context.ssrContext;
+  var forUserPipe = function forUserPipe(stream) {
+    return new Promise(function (resolve) {
+      var _renderToPipeableStre = renderToPipeableStream(rootElement, _objectSpread(_objectSpread({}, options), {}, {
+          onShellReady: function onShellReady() {
+            var _options$onShellReady;
+            var _getTemplates = getTemplates(context, RenderLevel.SERVER_RENDER),
+              shellAfter = _getTemplates.shellAfter,
+              shellBefore = _getTemplates.shellBefore;
+            options === null || options === void 0 ? void 0 : (_options$onShellReady = options.onShellReady) === null || _options$onShellReady === void 0 ? void 0 : _options$onShellReady.call(options);
+            var injectableTransform = new Transform({
+              transform: function transform(chunk, _encoding, callback) {
+                try {
+                  if (isShellStream) {
+                    this.push(joinChunk(shellBefore, chunk, shellAfter));
+                    isShellStream = false;
+                  } else {
+                    this.push(chunk);
+                  }
+                  callback();
+                } catch (e) {
+                  if (e instanceof Error) {
+                    callback(e);
+                  } else {
+                    callback(new Error('Received unkown error when streaming'));
+                  }
+                }
+              }
+            });
+            resolve(pipe(injectableTransform).pipe(stream));
+          },
+          onShellError: function onShellError(error) {
+            var _options$onShellError;
+            // Don't log error in `onShellError` callback, since it has been logged in `onError` callback
+            ssrContext.metrics.emitCounter('app.render.streaming.shell.error', 1);
+            var _getTemplates2 = getTemplates(context, RenderLevel.CLIENT_RENDER),
+              shellAfter = _getTemplates2.shellAfter,
+              shellBefore = _getTemplates2.shellBefore;
+            var fallbackHtml = "".concat(shellBefore).concat(shellAfter);
+            resolve(fallbackHtml);
+            options === null || options === void 0 ? void 0 : (_options$onShellError = options.onShellError) === null || _options$onShellError === void 0 ? void 0 : _options$onShellError.call(options, error);
+          },
+          onError: function onError(error) {
+            var _options$onError;
+            ssrContext.logger.error('An error occurs during streaming SSR', error);
+            ssrContext.metrics.emitCounter('app.render.streaming.error', 1);
+            options === null || options === void 0 ? void 0 : (_options$onError = options.onError) === null || _options$onError === void 0 ? void 0 : _options$onError.call(options, error);
+          }
+        })),
+        pipe = _renderToPipeableStre.pipe;
+    });
+  };
+  return forUserPipe;
+  function joinChunk() {
+    var before = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+    var chunk = arguments.length > 1 ? arguments[1] : undefined;
+    var after = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+    return "".concat(before).concat(chunk.toString()).concat(after);
+  }
+}
+export default renderToPipe;

package/dist/js/treeshaking/ssr/serverRender/renderToStream/styledComponent.js

@@ -0,0 +1,10 @@
+import { ServerStyleSheet } from 'styled-components';
+export function getStyledComponentCss(_ref) {
+  var jsx = _ref.jsx;
+  var sheet = new ServerStyleSheet();
+  var collectedJsx = sheet.collectStyles(jsx);
+  return {
+    styleSheet: sheet,
+    jsx: collectedJsx
+  };
+}

package/dist/js/treeshaking/ssr/serverRender/renderToStream/template.js

@@ -0,0 +1,22 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { buildShellAfterTemplate } from "./buildTemplate.after";
+import { buildShellBeforeTemplate } from "./bulidTemplate.before";
+var HTML_SEPARATOR = '<!--<?- html ?>-->';
+export var getTemplates = function getTemplates(context, renderLevel) {
+  var ssrContext = context.ssrContext;
+  var _ref = ssrContext.template.split(HTML_SEPARATOR) || [],
+    _ref2 = _slicedToArray(_ref, 2),
+    _ref2$ = _ref2[0],
+    beforeAppTemplate = _ref2$ === void 0 ? '' : _ref2$,
+    _ref2$2 = _ref2[1],
+    afterAppHtmlTemplate = _ref2$2 === void 0 ? '' : _ref2$2;
+  var builtBeforeTemplate = buildShellBeforeTemplate(beforeAppTemplate, context);
+  var builtAfterTemplate = buildShellAfterTemplate(afterAppHtmlTemplate, {
+    ssrContext: ssrContext,
+    renderLevel: renderLevel
+  });
+  return {
+    shellBefore: builtBeforeTemplate,
+    shellAfter: builtAfterTemplate
+  };
+};

package/dist/js/treeshaking/ssr/serverRender/{entry.js → renderToString/entry.js}

@@ -8,14 +8,14 @@ import React from 'react';
 import ReactDomServer from 'react-dom/server';
 import serialize from 'serialize-javascript';
 import ReactHelmet from 'react-helmet';
+import helmetReplace from "../helmet";
+import { RenderLevel } from "../types";
+import { time } from "../utils";
+import _prefetch from "../../prefetch";
 import { toFragments } from "./template";
-import { RenderLevel } from "./type";
-import helmetReplace from "./helmet";
 import { reduce } from "./reduce";
 import * as loadableRenderer from "./loadable";
 import * as styledComponentRenderer from "./styledComponent";
-import { time } from "./measure";
-
 var buildTemplateData = function buildTemplateData(context, data, renderLevel) {
   var request = context.request;
   return {
@@ -34,32 +34,22 @@ var buildTemplateData = function buildTemplateData(context, data, renderLevel) {
     renderLevel: renderLevel
   };
 };
-
 var Entry = /*#__PURE__*/function () {
   function Entry(options) {
     _classCallCheck(this, Entry);
-
     _defineProperty(this, "entryName", void 0);
-
     _defineProperty(this, "result", void 0);
-
     _defineProperty(this, "metrics", void 0);
-
     _defineProperty(this, "logger", void 0);
-
     _defineProperty(this, "App", void 0);
-
     _defineProperty(this, "fragments", void 0);
-
     _defineProperty(this, "pluginConfig", void 0);
-
     _defineProperty(this, "host", void 0);
-
     var ctx = options.ctx,
-        config = options.config;
+      config = options.config;
     var entryName = ctx.entryName,
-        template = ctx.template,
-        host = ctx.request.host;
+      template = ctx.template,
+      host = ctx.request.host;
     this.fragments = toFragments(template, entryName);
     this.entryName = entryName;
     this.host = host;
@@ -76,62 +66,48 @@ var Entry = /*#__PURE__*/function () {
       }
     };
   }
-
   _createClass(Entry, [{
     key: "renderToHtml",
     value: function () {
       var _renderToHtml = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(context) {
         var ssrContext, prefetchData, html, templateData, SSRData, _iterator, _step, fragment, helmetData;
-
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) {
             switch (_context.prev = _context.next) {
               case 0:
                 ssrContext = context.ssrContext;
-
                 if (!ssrContext.redirection.url) {
                   _context.next = 3;
                   break;
                 }
-
                 return _context.abrupt("return", '');
-
               case 3:
                 _context.next = 5;
                 return this.prefetch(context);
-
               case 5:
                 prefetchData = _context.sent;
-
                 if (!ssrContext.redirection.url) {
                   _context.next = 8;
                   break;
                 }
-
                 return _context.abrupt("return", '');
-
               case 8:
                 if (this.result.renderLevel >= RenderLevel.SERVER_PREFETCH) {
                   this.result.html = this.renderToString(context);
                 }
-
                 if (!ssrContext.redirection.url) {
                   _context.next = 11;
                   break;
                 }
-
                 return _context.abrupt("return", '');
-
               case 11:
                 html = '';
                 templateData = buildTemplateData(ssrContext, prefetchData, this.result.renderLevel);
                 SSRData = this.getSSRDataScript(templateData);
                 _iterator = _createForOfIteratorHelper(this.fragments);
-
                 try {
                   for (_iterator.s(); !(_step = _iterator.n()).done;) {
                     fragment = _step.value;
-
                     if (fragment.isVariable && fragment.content === 'SSRDataScript') {
                       html += fragment.getValue(SSRData);
                     } else {
@@ -143,10 +119,8 @@ var Entry = /*#__PURE__*/function () {
                 } finally {
                   _iterator.f();
                 }
-
                 helmetData = ReactHelmet.renderStatic();
                 return _context.abrupt("return", helmetData ? helmetReplace(html, helmetData) : html);
-
               case 18:
               case "end":
                 return _context.stop();
@@ -154,73 +128,50 @@ var Entry = /*#__PURE__*/function () {
           }
         }, _callee, this);
       }));
-
       function renderToHtml(_x) {
         return _renderToHtml.apply(this, arguments);
       }
-
       return renderToHtml;
     }()
   }, {
     key: "prefetch",
     value: function () {
-      var _prefetch = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(context) {
-        var prefetch, prefetchData, end, prefetchCost;
+      var _prefetch2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(context) {
+        var prefetchData, end, prefetchCost;
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) {
             switch (_context2.prev = _context2.next) {
               case 0:
-                prefetch = this.App.prefetch;
                 end = time();
-                _context2.prev = 2;
-
-                if (!prefetch) {
-                  _context2.next = 9;
-                  break;
-                }
-
-                _context2.next = 6;
-                return prefetch(context);
-
-              case 6:
-                _context2.t0 = _context2.sent;
-                _context2.next = 10;
-                break;
-
-              case 9:
-                _context2.t0 = null;
-
-              case 10:
-                prefetchData = _context2.t0;
+                _context2.prev = 1;
+                _context2.next = 4;
+                return _prefetch(this.App, context);
+              case 4:
+                prefetchData = _context2.sent;
                 this.result.renderLevel = RenderLevel.SERVER_PREFETCH;
                 prefetchCost = end();
                 this.logger.debug("App Prefetch cost = %d ms", prefetchCost);
                 this.metrics.emitTimer('app.prefetch.cost', prefetchCost);
-                _context2.next = 22;
+                _context2.next = 16;
                 break;
-
-              case 17:
-                _context2.prev = 17;
-                _context2.t1 = _context2["catch"](2);
+              case 11:
+                _context2.prev = 11;
+                _context2.t0 = _context2["catch"](1);
                 this.result.renderLevel = RenderLevel.CLIENT_RENDER;
-                this.logger.error('App Prefetch Render', _context2.t1);
+                this.logger.error('App Prefetch Render', _context2.t0);
                 this.metrics.emitCounter('app.prefetch.render.error', 1);
-
-              case 22:
+              case 16:
                 return _context2.abrupt("return", prefetchData || {});
-
-              case 23:
+              case 17:
               case "end":
                 return _context2.stop();
             }
           }
-        }, _callee2, this, [[2, 17]]);
+        }, _callee2, this, [[1, 11]]);
       }));
-
       function prefetch(_x2) {
-        return _prefetch.apply(this, arguments);
+        return _prefetch2.apply(this, arguments);
       }
-
       return prefetch;
     }()
   }, {
@@ -229,7 +180,6 @@ var Entry = /*#__PURE__*/function () {
       var html = '';
       var end = time();
       var ssrContext = context.ssrContext;
-
       try {
         var App = /*#__PURE__*/React.createElement(this.App, {
           context: Object.assign(context, {
@@ -254,7 +204,6 @@ var Entry = /*#__PURE__*/function () {
         this.logger.error('App Render To HTML', e);
         this.metrics.emitCounter('app.render.html.error', 1);
       }
-
       return html;
     }
   }, {
@@ -267,8 +216,6 @@ var Entry = /*#__PURE__*/function () {
       };
     }
   }]);
-
   return Entry;
 }();
-
 export { Entry as default };

package/dist/js/treeshaking/ssr/serverRender/renderToString/index.js

@@ -0,0 +1,44 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { run } from '@modern-js/utils/ssr';
+import { PreRender } from "../../react/prerender";
+import { time } from "../utils";
+import SSREntry from "./entry";
+export var render = function render(_ref) {
+  var App = _ref.App,
+    context = _ref.context,
+    config = _ref.config;
+  var ssrContext = context.ssrContext;
+  return run(ssrContext.request.headers, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    var entry, end, html, cost, cacheConfig;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            entry = new SSREntry({
+              ctx: ssrContext,
+              App: App,
+              config: config
+            });
+            entry.metrics.emitCounter('app.visit.count', 1);
+            end = time();
+            _context.next = 5;
+            return entry.renderToHtml(context);
+          case 5:
+            html = _context.sent;
+            cost = end();
+            entry.logger.info('App Render Total cost = %d ms', cost);
+            entry.metrics.emitTimer('app.render.cost', cost);
+            cacheConfig = PreRender.config();
+            if (cacheConfig) {
+              context.ssrContext.cacheConfig = cacheConfig;
+            }
+            return _context.abrupt("return", html);
+          case 12:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  })));
+};