code: function renderEmbeddedTemplate(viewNode, tView, context, rf) {
      var _isParent = isParent;
      var _previousOrParentNode = previousOrParentNode;
      var oldView;
      if (viewNode.data[PARENT] == null && viewNode.data[CONTEXT] && !tView.template) {
          // This is a root view inside the view tree
          tickRootContext(viewNode.data[CONTEXT]);
      }
      else {
          try {
              isParent = true;
              previousOrParentNode = null;
              oldView = enterView(viewNode.data, viewNode);
              namespaceHTML();
              tView.template(rf, context);
              if (rf & 2 /* Update */) {
                  refreshView();
              }
              else {
                  viewNode.data[TVIEW].firstTemplatePass = firstTemplatePass = false;
              }
          }
          finally {
              // renderEmbeddedTemplate() is called twice in fact, once for creation only and then once for
              // update. When for creation only, leaveView() must not trigger view hooks, nor clean flags.
              var isCreationOnly = (rf & 1 /* Create */) === 1 /* Create */;
              leaveView(oldView, isCreationOnly);
              isParent = _isParent;
              previousOrParentNode = _previousOrParentNode;
          }
      }
      return viewNode;
  }
docs: Used for rendering embedded views (e.g. dynamically created views)
  
  Dynamically created views must store/retrieve their TViews differently from component views
  because their template functions are nested in the template functions of their hosts, creating
  closures. If their host template happens to be an embedded template in a loop (e.g. ngFor inside
  an ngFor), the nesting would mean we'd have multiple instances of the template function, so we
  can't store TViews in the template function itself (as we do for comps). Instead, we store the
  TView for dynamically created views on their host TNode, which only has one instance.