@tko/binding.template 4.0.0-alpha8.4 → 4.0.0-beta1.3

package/package.json

@@ -1,6 +1,6 @@
 {
+  "version": "4.0.0-beta1.3",
   "name": "@tko/binding.template",
-  "version": "4.0.0-alpha8.4",
   "description": "TKO Template bindings",
   "module": "dist/binding.template.js",
   "files": [
@@ -9,56 +9,46 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/knockout/tko.binding.template.git"
+    "url": "git+https://github.com/knockout/tko.git"
   },
   "keywords": [
     "knockout",
     "tko",
     "ko"
   ],
-  "author": "Knockout",
+  "author": "The Knockout Team",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/knockout/tko.util/issues"
+    "url": "https://github.com/knockout/tko/issues"
   },
   "homepage": "https://tko.io",
   "dependencies": {
-    "@tko/bind": "^4.0.0-alpha8.4",
-    "@tko/computed": "^4.0.0-alpha8.0",
-    "@tko/observable": "^4.0.0-alpha8.0",
-    "@tko/utils": "^4.0.0-alpha8.0",
-    "tslib": "^1.8.0"
+    "@tko/bind": "^4.0.0-beta1.3",
+    "@tko/computed": "^4.0.0-beta1.3",
+    "@tko/observable": "^4.0.0-beta1.3",
+    "@tko/utils": "^4.0.0-beta1.3",
+    "tslib": "^2.2.0"
   },
   "karma": {
     "frameworks": [
       "jasmine"
     ]
   },
-  "devDependencies": {
-    "@tko/binding.if": "^4.0.0-alpha8.4"
-  },
-  "__about__shared.package.json": "These properties are copied into all packages/*/package.json.  Run `yarn repackage`",
-  "standard": {
-    "env": [
-      "browser",
-      "jasmine",
-      "mocha"
-    ]
-  },
-  "scripts": {
-    "test": "npx karma start ../../karma.conf.js --once",
-    "build": "npx rollup -c ../../rollup.config.js",
-    "watch": "npx karma start ../../karma.conf.js",
-    "prepare": "npx rollup -c ../../rollup.config.js"
-  },
-  "publishConfig": {
-    "access": "public"
+  "peerDependencies": {
+    "@tko/binding.if": "^4.0.0-alpha9.0"
   },
   "licenses": [
     {
       "type": "MIT",
-      "url": "http://www.opensource.org/licenses/mit-license.php"
+      "url": "https://opensource.org/licenses/MIT"
     }
   ],
-  "gitHead": "a3c1ec00c69067939297a446d79a6cf0eecb7c76"
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    },
+    "./helpers/*": "./helpers/*"
+  },
+  "gitHead": "a8843acb8ae085915115e53a4e057b30731c635e"
 }

package/dist/binding.template.es6.js

@@ -1,557 +0,0 @@
-/*!
- * TKO Template bindings 🥊  @tko/binding.template@4.0.0-alpha8.4
- * (c) The Knockout.js Team - https://tko.io
- * License: MIT (http://www.opensource.org/licenses/mit-license.php)
- */
-
-import { tagNameLower, setHtml, domData, parseHtmlForTemplateNodes, extend, options, virtualElements, fixUpContinuousNodeArray, replaceDomNodes, memoization, domNodeIsAttachedToDocument, moveCleanedNodesToContainerElement, arrayFilter, ieVersion, makeArray, parseHtmlFragment } from '@tko/utils';
-import { applyBindings, setDomNodeChildrenFromArrayMapping, AsyncBindingHandler, bindingEvent, bindingContext } from '@tko/bind';
-import { computed } from '@tko/computed';
-import { isObservable, dependencyDetection, unwrap, observable, isObservableArray, peek } from '@tko/observable';
-
-// A template source represents a read/write way of accessing a template. This is to eliminate the need for template loading/saving
-
-// ---- ko.templateSources.domElement -----
-
-// template types
-var templateScript = 1,
-  templateTextArea = 2,
-  templateTemplate = 3,
-  templateElement = 4;
-
-function domElement (element) {
-  this.domElement = element;
-
-  if (!element) { return }
-  var tagNameLower$$1 = tagNameLower(element);
-  this.templateType =
-        tagNameLower$$1 === 'script' ? templateScript
-        : tagNameLower$$1 === 'textarea' ? templateTextArea
-            // For browsers with proper <template> element support, where the .content property gives a document fragment
-        : tagNameLower$$1 == 'template' && element.content && element.content.nodeType === 11 ? templateTemplate
-        : templateElement;
-}
-
-domElement.prototype.text = function (/* valueToWrite */) {
-  var elemContentsProperty = this.templateType === templateScript ? 'text'
-                             : this.templateType === templateTextArea ? 'value'
-                             : 'innerHTML';
-
-  if (arguments.length == 0) {
-    return this.domElement[elemContentsProperty]
-  } else {
-    var valueToWrite = arguments[0];
-    if (elemContentsProperty === 'innerHTML') { setHtml(this.domElement, valueToWrite); } else { this.domElement[elemContentsProperty] = valueToWrite; }
-  }
-};
-
-var dataDomDataPrefix = domData.nextKey() + '_';
-domElement.prototype.data = function (key /*, valueToWrite */) {
-  if (arguments.length === 1) {
-    return domData.get(this.domElement, dataDomDataPrefix + key)
-  } else {
-    domData.set(this.domElement, dataDomDataPrefix + key, arguments[1]);
-  }
-};
-
-var templatesDomDataKey = domData.nextKey();
-function getTemplateDomData (element) {
-  return domData.get(element, templatesDomDataKey) || {}
-}
-function setTemplateDomData (element, data) {
-  domData.set(element, templatesDomDataKey, data);
-}
-
-domElement.prototype.nodes = function (/* valueToWrite */) {
-  var element = this.domElement;
-  if (arguments.length == 0) {
-    const templateData = getTemplateDomData(element);
-    let nodes = templateData.containerData || (
-      this.templateType === templateTemplate ? element.content :
-      this.templateType === templateElement ? element :
-      undefined
-    );
-    if (!nodes || templateData.alwaysCheckText) {
-    // If the template is associated with an element that stores the template as text,
-    // parse and cache the nodes whenever there's new text content available. This allows
-    // the user to update the template content by updating the text of template node.
-      const text = this['text']();
-      if (text) {
-        nodes = parseHtmlForTemplateNodes(text, element.ownerDocument);
-        this['text']('');   // clear the text from the node
-        setTemplateDomData(element, {containerData: nodes, alwaysCheckText: true});
-      }
-    }
-
-    return nodes
-  } else {
-    var valueToWrite = arguments[0];
-    setTemplateDomData(element, {containerData: valueToWrite});
-  }
-};
-
-// ---- ko.templateSources.anonymousTemplate -----
-// Anonymous templates are normally saved/retrieved as DOM nodes through "nodes".
-// For compatibility, you can also read "text"; it will be serialized from the nodes on demand.
-// Writing to "text" is still supported, but then the template data will not be available as DOM nodes.
-
-function anonymousTemplate (element) {
-  this.domElement = element;
-}
-
-anonymousTemplate.prototype = new domElement();
-anonymousTemplate.prototype.constructor = anonymousTemplate;
-anonymousTemplate.prototype.text = function (/* valueToWrite */) {
-  if (arguments.length == 0) {
-    var templateData = getTemplateDomData(this.domElement);
-    if (templateData.textData === undefined && templateData.containerData) { templateData.textData = templateData.containerData.innerHTML; }
-    return templateData.textData
-  } else {
-    var valueToWrite = arguments[0];
-    setTemplateDomData(this.domElement, {textData: valueToWrite});
-  }
-};
-
-// If you want to make a custom template engine,
-
-function templateEngine () { }
-extend(templateEngine.prototype, {
-  renderTemplateSource: function (templateSource, bindingContext$$1, options$$1, templateDocument) {
-    options$$1.onError('Override renderTemplateSource');
-  },
-
-  createJavaScriptEvaluatorBlock: function (script) {
-    options.onError('Override createJavaScriptEvaluatorBlock');
-  },
-
-  makeTemplateSource: function (template, templateDocument) {
-      // Named template
-    if (typeof template === 'string') {
-      templateDocument = templateDocument || document;
-      var elem = templateDocument.getElementById(template);
-      if (!elem) { options.onError('Cannot find template with ID ' + template); }
-      return new domElement(elem)
-    } else if ((template.nodeType == 1) || (template.nodeType == 8)) {
-          // Anonymous template
-      return new anonymousTemplate(template)
-    } else { options.onError('Unknown template type: ' + template); }
-  },
-
-  renderTemplate: function (template, bindingContext$$1, options$$1, templateDocument) {
-    var templateSource = this['makeTemplateSource'](template, templateDocument);
-    return this.renderTemplateSource(templateSource, bindingContext$$1, options$$1, templateDocument)
-  }
-});
-
-var _templateEngine;
-const cleanContainerDomDataKey = domData.nextKey();
-
-function setTemplateEngine (tEngine) {
-  if ((tEngine !== undefined) && !(tEngine instanceof templateEngine)) {
-        // TODO: ko.templateEngine to appropriate name
-    throw new Error('templateEngine must inherit from ko.templateEngine')
-  }
-  _templateEngine = tEngine;
-}
-
-function invokeForEachNodeInContinuousRange (firstNode, lastNode, action) {
-  let node;
-  let nextInQueue = firstNode;
-  let firstOutOfRangeNode = virtualElements.nextSibling(lastNode);
-  while (nextInQueue && ((node = nextInQueue) !== firstOutOfRangeNode)) {
-    nextInQueue = virtualElements.nextSibling(node);
-    action(node, nextInQueue);
-  }
-}
-
-function activateBindingsOnContinuousNodeArray (continuousNodeArray, bindingContext$$1, afterBindingCallback) {
-  // To be used on any nodes that have been rendered by a template and have been inserted into some parent element
-  // Walks through continuousNodeArray (which *must* be continuous, i.e., an uninterrupted sequence of sibling nodes, because
-  // the algorithm for walking them relies on this), and for each top-level item in the virtual-element sense,
-  // (1) Does a regular "applyBindings" to associate bindingContext with this node and to activate any non-memoized bindings
-  // (2) Unmemoizes any memos in the DOM subtree (e.g., to activate bindings that had been memoized during template rewriting)
-
-  if (continuousNodeArray.length) {
-    var firstNode = continuousNodeArray[0];
-    var lastNode = continuousNodeArray[continuousNodeArray.length - 1];
-    var parentNode = firstNode.parentNode;
-    var provider = options.bindingProviderInstance;
-    var preprocessNode = provider.preprocessNode;
-
-    if (preprocessNode) {
-      invokeForEachNodeInContinuousRange(firstNode, lastNode, function (node, nextNodeInRange) {
-        var nodePreviousSibling = node.previousSibling;
-        var newNodes = preprocessNode.call(provider, node);
-        if (newNodes) {
-          if (node === firstNode) { firstNode = newNodes[0] || nextNodeInRange; }
-          if (node === lastNode) { lastNode = newNodes[newNodes.length - 1] || nodePreviousSibling; }
-        }
-      });
-
-      // Because preprocessNode can change the nodes, including the first and last nodes, update continuousNodeArray to match.
-      // We need the full set, including inner nodes, because the unmemoize step might remove the first node (and so the real
-      // first node needs to be in the array).
-      continuousNodeArray.length = 0;
-      if (!firstNode) { // preprocessNode might have removed all the nodes, in which case there's nothing left to do
-        return
-      }
-      if (firstNode === lastNode) {
-        continuousNodeArray.push(firstNode);
-      } else {
-        continuousNodeArray.push(firstNode, lastNode);
-        fixUpContinuousNodeArray(continuousNodeArray, parentNode);
-      }
-    }
-
-    // Need to applyBindings *before* unmemoziation, because unmemoization might introduce extra nodes (that we don't want to re-bind)
-    // whereas a regular applyBindings won't introduce new memoized nodes
-    invokeForEachNodeInContinuousRange(firstNode, lastNode, function (node) {
-      if (node.nodeType === 1 || node.nodeType === 8) { applyBindings(bindingContext$$1, node).then(afterBindingCallback); }
-    });
-    invokeForEachNodeInContinuousRange(firstNode, lastNode, function (node) {
-      if (node.nodeType === 1 || node.nodeType === 8) { memoization.unmemoizeDomNodeAndDescendants(node, [bindingContext$$1]); }
-    });
-
-    // Make sure any changes done by applyBindings or unmemoize are reflected in the array
-    fixUpContinuousNodeArray(continuousNodeArray, parentNode);
-  }
-}
-
-function getFirstNodeFromPossibleArray (nodeOrNodeArray) {
-  return nodeOrNodeArray.nodeType ? nodeOrNodeArray
-                                    : nodeOrNodeArray.length > 0 ? nodeOrNodeArray[0]
-                                    : null
-}
-
-function executeTemplate (targetNodeOrNodeArray, renderMode, template, bindingContext$$1, options$$1, afterBindingCallback) {
-  options$$1 = options$$1 || {};
-  var firstTargetNode = targetNodeOrNodeArray && getFirstNodeFromPossibleArray(targetNodeOrNodeArray);
-  var templateDocument = (firstTargetNode || template || {}).ownerDocument;
-  var templateEngineToUse = (options$$1.templateEngine || _templateEngine);
-  var renderedNodesArray = templateEngineToUse.renderTemplate(template, bindingContext$$1, options$$1, templateDocument);
-
-    // Loosely check result is an array of DOM nodes
-  if ((typeof renderedNodesArray.length !== 'number') || (renderedNodesArray.length > 0 && typeof renderedNodesArray[0].nodeType !== 'number')) { throw new Error('Template engine must return an array of DOM nodes') }
-
-  var haveAddedNodesToParent = false;
-  switch (renderMode) {
-    case 'replaceChildren':
-      virtualElements.setDomNodeChildren(targetNodeOrNodeArray, renderedNodesArray);
-      haveAddedNodesToParent = true;
-      break
-    case 'replaceNode':
-      replaceDomNodes(targetNodeOrNodeArray, renderedNodesArray);
-      haveAddedNodesToParent = true;
-      break
-    case 'ignoreTargetNode': break
-    default:
-      throw new Error('Unknown renderMode: ' + renderMode)
-  }
-
-  if (haveAddedNodesToParent) {
-    activateBindingsOnContinuousNodeArray(renderedNodesArray, bindingContext$$1, afterBindingCallback);
-    if (options$$1.afterRender) { dependencyDetection.ignore(options$$1.afterRender, null, [renderedNodesArray, bindingContext$$1['$data']]); }
-    if (renderMode === 'replaceChildren') {
-      bindingEvent.notify(targetNodeOrNodeArray, bindingEvent.childrenComplete);
-    }
-  }
-
-  return renderedNodesArray
-}
-
-function resolveTemplateName (template, data, context) {
-    // The template can be specified as:
-  if (isObservable(template)) {
-    // 1. An observable, with string value
-    return template()
-  } else if (typeof template === 'function') {
-    // 2. A function of (data, context) returning a string
-    return template(data, context)
-  } else {
-    // 3. A string
-    return template
-  }
-}
-
-function renderTemplate (template, dataOrBindingContext, options$$1, targetNodeOrNodeArray, renderMode, afterBindingCallback) {
-  options$$1 = options$$1 || {};
-  if ((options$$1.templateEngine || _templateEngine) === undefined) { throw new Error('Set a template engine before calling renderTemplate') }
-  renderMode = renderMode || 'replaceChildren';
-
-  if (targetNodeOrNodeArray) {
-    var firstTargetNode = getFirstNodeFromPossibleArray(targetNodeOrNodeArray);
-
-    var whenToDispose = function () { return (!firstTargetNode) || !domNodeIsAttachedToDocument(firstTargetNode) }; // Passive disposal (on next evaluation)
-    var activelyDisposeWhenNodeIsRemoved = (firstTargetNode && renderMode === 'replaceNode') ? firstTargetNode.parentNode : firstTargetNode;
-
-    return computed( // So the DOM is automatically updated when any dependency changes
-      function () {
-        // Ensure we've got a proper binding context to work with
-        var bindingContext$$1 = (dataOrBindingContext && (dataOrBindingContext instanceof bindingContext))
-              ? dataOrBindingContext
-              : new bindingContext(dataOrBindingContext, null, null, null, { 'exportDependencies': true });
-
-        var templateName = resolveTemplateName(template, bindingContext$$1.$data, bindingContext$$1);
-        const renderedNodesArray = executeTemplate(targetNodeOrNodeArray, renderMode, templateName, bindingContext$$1, options$$1, afterBindingCallback);
-
-        if (renderMode === 'replaceNode') {
-          targetNodeOrNodeArray = renderedNodesArray;
-          firstTargetNode = getFirstNodeFromPossibleArray(targetNodeOrNodeArray);
-        }
-      },
-      null,
-      { disposeWhen: whenToDispose, disposeWhenNodeIsRemoved: activelyDisposeWhenNodeIsRemoved }
-    )
-  } else {
-        // We don't yet have a DOM node to evaluate, so use a memo and render the template later when there is a DOM node
-    return memoization.memoize(function (domNode) {
-      renderTemplate(template, dataOrBindingContext, options$$1, domNode, 'replaceNode');
-    })
-  }
-}
-
-function renderTemplateForEach (template, arrayOrObservableArray, options$$1, targetNode, parentBindingContext, afterBindingCallback) {
-    // Since setDomNodeChildrenFromArrayMapping always calls executeTemplateForArrayItem and then
-    // activateBindingsCallback for added items, we can store the binding context in the former to use in the latter.
-  var arrayItemContext;
-
-    // This will be called by setDomNodeChildrenFromArrayMapping to get the nodes to add to targetNode
-  function executeTemplateForArrayItem (arrayValue, index) {
-    // Support selecting template as a function of the data being rendered
-    if (options$$1.as) {
-      if (options.createChildContextWithAs) {
-        arrayItemContext = parentBindingContext.createChildContext(
-          arrayValue, options$$1.as, context => { context.$index = index; }
-        );
-      } else {
-        arrayItemContext = parentBindingContext.extend({
-          [options$$1.as]: arrayValue,
-          $index: index
-        });
-      }
-    } else {
-      arrayItemContext = parentBindingContext.createChildContext(arrayValue, options$$1.as, context => { context.$index = index; });
-    }
-
-    var templateName = resolveTemplateName(template, arrayValue, arrayItemContext);
-    return executeTemplate(targetNode, 'ignoreTargetNode', templateName, arrayItemContext, options$$1, afterBindingCallback)
-  }
-
-    // This will be called whenever setDomNodeChildrenFromArrayMapping has added nodes to targetNode
-  var activateBindingsCallback = function (arrayValue, addedNodesArray /*, index */) {
-    activateBindingsOnContinuousNodeArray(addedNodesArray, arrayItemContext, afterBindingCallback);
-    if (options$$1.afterRender) { options$$1.afterRender(addedNodesArray, arrayValue); }
-
-        // release the "cache" variable, so that it can be collected by
-        // the GC when its value isn't used from within the bindings anymore.
-    arrayItemContext = null;
-  };
-
-  // Call setDomNodeChildrenFromArrayMapping, ignoring any observables unwrapped within (most likely from a callback function).
-  // If the array items are observables, though, they will be unwrapped in executeTemplateForArrayItem and managed within setDomNodeChildrenFromArrayMapping.
-  function localSetDomNodeChildrenFromArrayMapping (newArray, changeList) {
-    dependencyDetection.ignore(setDomNodeChildrenFromArrayMapping, null, [targetNode, newArray, executeTemplateForArrayItem, options$$1, activateBindingsCallback, changeList]);
-    bindingEvent.notify(targetNode, bindingEvent.childrenComplete);
-  }
-
-  const shouldHideDestroyed = (options$$1.includeDestroyed === false) || (options.foreachHidesDestroyed && !options$$1.includeDestroyed);
-  if (!shouldHideDestroyed && !options$$1.beforeRemove && isObservableArray(arrayOrObservableArray)) {
-    localSetDomNodeChildrenFromArrayMapping(arrayOrObservableArray.peek());
-    var subscription = arrayOrObservableArray.subscribe(function (changeList) {
-      localSetDomNodeChildrenFromArrayMapping(arrayOrObservableArray(), changeList);
-    }, null, 'arrayChange');
-    subscription.disposeWhenNodeIsRemoved(targetNode);
-    return subscription
-  } else {
-    return computed(function () {
-      var unwrappedArray = unwrap(arrayOrObservableArray) || [];
-      const unwrappedIsIterable = Symbol.iterator in unwrappedArray;
-      if (!unwrappedIsIterable) { unwrappedArray = [unwrappedArray]; }
-      if (shouldHideDestroyed) {
-        // Filter out any entries marked as destroyed
-        unwrappedArray = arrayFilter(unwrappedArray, function (item) {
-          return item === undefined || item === null || !unwrap(item._destroy);
-        });
-      }
-      localSetDomNodeChildrenFromArrayMapping(unwrappedArray);
-    }, null, { disposeWhenNodeIsRemoved: targetNode })
-  }
-}
-
-let templateComputedDomDataKey = domData.nextKey();
-
-class TemplateBindingHandler extends AsyncBindingHandler {
-  constructor (params) {
-    super(params);
-    const element = this.$element;
-    const bindingValue = unwrap(this.value);
-
-    // Expose 'conditional' for `else` chaining.
-    domData.set(element, 'conditional', {
-      elseChainSatisfied: observable(true)
-    });
-
-    // Support anonymous templates
-    if (typeof bindingValue === 'string' || bindingValue.name) {
-      this.bindNamedTemplate();
-    } else if ('nodes' in bindingValue) {
-      this.bindNodeTemplate(bindingValue.nodes || []);
-    } else {
-      this.bindAnonymousTemplate();
-    }
-  }
-
-  bindNamedTemplate () {
-    // It's a named template - clear the element
-    virtualElements.emptyNode(this.$element);
-  }
-
-  // We've been given an array of DOM nodes. Save them as the template source.
-  // There is no known use case for the node array being an observable array (if the output
-  // varies, put that behavior *into* your template - that's what templates are for), and
-  // the implementation would be a mess, so assert that it's not observable.
-  bindNodeTemplate (nodes) {
-    if (isObservable(nodes)) {
-      throw new Error('The "nodes" option must be a plain, non-observable array.')
-    }
-
-    // If the nodes are already attached to a KO-generated container, we reuse that container without moving the
-    // elements to a new one (we check only the first node, as the nodes are always moved together)
-    let container = nodes[0] && nodes[0].parentNode;
-    if (!container || !domData.get(container, cleanContainerDomDataKey)) {
-      container = moveCleanedNodesToContainerElement(nodes);
-      domData.set(container, cleanContainerDomDataKey, true);
-    }
-
-    new anonymousTemplate(this.$element).nodes(container);
-  }
-
-  bindAnonymousTemplate () {
-    // It's an anonymous template - store the element contents, then clear the element
-    const templateNodes = virtualElements.childNodes(this.$element);
-    if (templateNodes.length === 0) {
-      throw new Error('Anonymous template defined, but no template content was provided.')
-    }
-    const container = moveCleanedNodesToContainerElement(templateNodes); // This also removes the nodes from their current parent
-    new anonymousTemplate(this.$element).nodes(container);
-  }
-
-  onValueChange () {
-    const element = this.$element;
-    const bindingContext$$1 = this.$context;
-    var value = this.value;
-    var options$$1 = unwrap(value);
-    var shouldDisplay = true;
-    var templateComputed = null;
-    var elseChainSatisfied = domData.get(element, 'conditional').elseChainSatisfied;
-    var templateName;
-
-    if (typeof options$$1 === 'string') {
-      templateName = value;
-      options$$1 = {};
-    } else {
-      templateName = options$$1.name;
-
-      // Support "if"/"ifnot" conditions
-      if ('if' in options$$1) {
-        shouldDisplay = unwrap(options$$1.if);
-      }
-
-      if (shouldDisplay && 'ifnot' in options$$1) {
-        shouldDisplay = !unwrap(options$$1.ifnot);
-      }
-    }
-
-    if ('foreach' in options$$1) {
-      // Render once for each data point (treating data set as empty if shouldDisplay==false)
-      var dataArray = (shouldDisplay && options$$1.foreach) || [];
-      templateComputed = renderTemplateForEach(templateName || element, dataArray, options$$1, element, bindingContext$$1, this.completeBinding);
-
-      elseChainSatisfied((unwrap(dataArray) || []).length !== 0);
-    } else if (shouldDisplay) {
-      // Render once for this single data point (or use the viewModel if no data was provided)
-      var innerBindingContext = ('data' in options$$1)
-        ? bindingContext$$1.createStaticChildContext(options$$1.data, options$$1.as)  // Given an explicit 'data' value, we create a child binding context for it
-        : bindingContext$$1;                                                        // Given no explicit 'data' value, we retain the same binding context
-      templateComputed = renderTemplate(templateName || element, innerBindingContext, options$$1, element, undefined, this.completeBinding);
-      elseChainSatisfied(true);
-    } else {
-      virtualElements.emptyNode(element);
-      elseChainSatisfied(false);
-    }
-
-    // It only makes sense to have a single template computed per element (otherwise which one should have its output displayed?)
-    this.disposeOldComputedAndStoreNewOne(element, templateComputed);
-  }
-
-  disposeOldComputedAndStoreNewOne (element, newComputed) {
-    let oldComputed = domData.get(element, templateComputedDomDataKey);
-    if (oldComputed && (typeof oldComputed.dispose === 'function')) { oldComputed.dispose(); }
-    domData.set(element, templateComputedDomDataKey, (newComputed && (!newComputed.isActive || newComputed.isActive())) ? newComputed : undefined);
-  }
-
-  get controlsDescendants () { return true }
-  static get allowVirtualElements () { return true }
-}
-
-function nativeTemplateEngine () {
-}
-
-nativeTemplateEngine.prototype = new templateEngine();
-nativeTemplateEngine.prototype.constructor = nativeTemplateEngine;
-nativeTemplateEngine.prototype.renderTemplateSource = function (templateSource, bindingContext$$1, options$$1, templateDocument) {
-  var useNodesIfAvailable = !(ieVersion < 9), // IE<9 cloneNode doesn't work properly
-    templateNodesFunc = useNodesIfAvailable ? templateSource.nodes : null,
-    templateNodes = templateNodesFunc ? templateSource.nodes() : null;
-
-  if (templateNodes) {
-    return makeArray(templateNodes.cloneNode(true).childNodes)
-  } else {
-    var templateText = templateSource.text();
-    return parseHtmlFragment(templateText, templateDocument)
-  }
-};
-
-nativeTemplateEngine.instance = new nativeTemplateEngine();
-setTemplateEngine(nativeTemplateEngine.instance);
-
-// "foreach: someExpression" is equivalent to "template: { foreach: someExpression }"
-// "foreach: { data: someExpression, afterAdd: myfn }" is equivalent to "template: { foreach: someExpression, afterAdd: myfn }"
-class TemplateForEachBindingHandler extends TemplateBindingHandler {
-  get value () {
-    const modelValue = this.valueAccessor();
-    const unwrappedValue = peek(modelValue);    // Unwrap without setting a dependency here
-
-        // If unwrappedValue is the array, pass in the wrapped value on its own
-        // The value will be unwrapped and tracked within the template binding
-        // (See https://github.com/SteveSanderson/knockout/issues/523)
-    if (!unwrappedValue || typeof unwrappedValue.length === 'number') {
-      return { foreach: modelValue, templateEngine: nativeTemplateEngine.instance }
-    }
-
-    // If unwrappedValue.data is the array, preserve all relevant options and unwrap again value so we get updates
-    unwrap(modelValue);
-    return {
-      foreach: unwrappedValue.data,
-      as: unwrappedValue.as,
-      includeDestroyed: unwrappedValue.includeDestroyed,
-      afterAdd: unwrappedValue.afterAdd,
-      beforeRemove: unwrappedValue.beforeRemove,
-      afterRender: unwrappedValue.afterRender,
-      beforeMove: unwrappedValue.beforeMove,
-      afterMove: unwrappedValue.afterMove,
-      templateEngine: nativeTemplateEngine.instance
-    }
-  }
-}
-
-//    'let': letBinding,
-//    template: template,
-
-const bindings = {
-  foreach: TemplateForEachBindingHandler,
-  template: TemplateBindingHandler
-};
-
-export { bindings, nativeTemplateEngine, templateEngine, setTemplateEngine, renderTemplate, TemplateBindingHandler, domElement, anonymousTemplate };
-//# sourceMappingURL=binding.template.es6.js.map