code: function (item, recycled) {
                      if (this._shouldCompile) {
                          try {
                              this._renderItemImpl = this._compileTemplate({ target: "renderItem" });
                              return this._renderItemImpl(item);
                          } catch (e) {
                              return {
                                  element: Promise.wrapError(e),
                                  renderComplete: Promise.wrapError(e),
                              };
                          }
                      }
  
                      var that = this;
  
                      // we only enable element cache when we are trying
                      // to recycle. Otherwise our element cache would
                      // grow unbounded.
                      //
                      if (this.enableRecycling && !this.bindingCache.elements) {
                          this.bindingCache.elements = {};
                      }
  
                      if (this.enableRecycling
                          && recycled
                          && recycled.msOriginalTemplate === this) {
  
                          // If we are asked to recycle, we cleanup any old work no matter what
                          //
                          var cacheEntry = this.bindingCache.elements[recycled.id];
                          var okToReuse = true;
                          if (cacheEntry) {
                              cacheEntry.bindings.forEach(function (v) { v(); });
                              cacheEntry.bindings = [];
                              okToReuse = !cacheEntry.nocache;
                          }
  
                          // If our cache indicates that we hit a non-cancelable thing, then we are
                          // in an unknown state, so we actually can't recycle the tree. We have
                          // cleaned up what we can, but at this point we need to reset and create
                          // a new tree.
                          //
                          if (okToReuse) {
                              // Element recycling requires that there be no other content in "recycled" other than this
                              // templates' output.
                              //
                              return {
                                  element: recycled,
                                  renderComplete: item.then(function (item) {
                                      return _Declarative.processAll(recycled, item.data, true, that.bindingCache);
                                  }),
                              };
                          }
                      }
  
                      var render = interpretedRender(this, item.then(function (item) { return item.data; }));
                      render.element = render.element.then(function (e) { e.msOriginalTemplate = that; return e; });
                      return render;
                  }
docs: Hook point for compiled template