@tko/binding.template 4.0.0-alpha9.0 → 4.0.0-beta1.0

package/dist/binding.template.js

@@ -1,579 +0,0 @@
-/*!
- * TKO Template bindings 🥊  @tko/binding.template@4.0.0-alpha9.0
- * (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';
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
-
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABLITY OR NON-INFRINGEMENT.
-
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
-***************************************************************************** */
-/* global Reflect, Promise */
-
-var extendStatics = function(d, b) {
-    extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-    return extendStatics(d, b);
-};
-
-function __extends(d, b) {
-    extendStatics(d, b);
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-
-// 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) {
-        var templateData = getTemplateDomData(element);
-        var 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.
-            var 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;
-var 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) {
-    var node;
-    var nextInQueue = firstNode;
-    var 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);
-            var 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) {
-        var _a;
-        // 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, function (context) { context.$index = index; });
-            }
-            else {
-                arrayItemContext = parentBindingContext.extend((_a = {},
-                    _a[options$$1.as] = arrayValue,
-                    _a.$index = index,
-                    _a));
-            }
-        }
-        else {
-            arrayItemContext = parentBindingContext.createChildContext(arrayValue, options$$1.as, function (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);
-    }
-    var 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) || [];
-            var 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 });
-    }
-}
-var templateComputedDomDataKey = domData.nextKey();
-var TemplateBindingHandler = /** @class */ (function (_super) {
-    __extends(TemplateBindingHandler, _super);
-    function TemplateBindingHandler(params) {
-        var _this = _super.call(this, params) || this;
-        var element = _this.$element;
-        var 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();
-        }
-        return _this;
-    }
-    TemplateBindingHandler.prototype.bindNamedTemplate = function () {
-        // 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.
-    TemplateBindingHandler.prototype.bindNodeTemplate = function (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)
-        var 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);
-    };
-    TemplateBindingHandler.prototype.bindAnonymousTemplate = function () {
-        // It's an anonymous template - store the element contents, then clear the element
-        var templateNodes = virtualElements.childNodes(this.$element);
-        if (templateNodes.length === 0) {
-            throw new Error('Anonymous template defined, but no template content was provided.');
-        }
-        var container = moveCleanedNodesToContainerElement(templateNodes); // This also removes the nodes from their current parent
-        new anonymousTemplate(this.$element).nodes(container);
-    };
-    TemplateBindingHandler.prototype.onValueChange = function () {
-        var element = this.$element;
-        var 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);
-    };
-    TemplateBindingHandler.prototype.disposeOldComputedAndStoreNewOne = function (element, newComputed) {
-        var oldComputed = domData.get(element, templateComputedDomDataKey);
-        if (oldComputed && (typeof oldComputed.dispose === 'function')) {
-            oldComputed.dispose();
-        }
-        domData.set(element, templateComputedDomDataKey, (newComputed && (!newComputed.isActive || newComputed.isActive())) ? newComputed : undefined);
-    };
-    Object.defineProperty(TemplateBindingHandler.prototype, "controlsDescendants", {
-        get: function () { return true; },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(TemplateBindingHandler, "allowVirtualElements", {
-        get: function () { return true; },
-        enumerable: true,
-        configurable: true
-    });
-    return TemplateBindingHandler;
-}(AsyncBindingHandler));
-
-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 }"
-var TemplateForEachBindingHandler = /** @class */ (function (_super) {
-    __extends(TemplateForEachBindingHandler, _super);
-    function TemplateForEachBindingHandler() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Object.defineProperty(TemplateForEachBindingHandler.prototype, "value", {
-        get: function () {
-            var modelValue = this.valueAccessor();
-            var 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
-            };
-        },
-        enumerable: true,
-        configurable: true
-    });
-    return TemplateForEachBindingHandler;
-}(TemplateBindingHandler));
-
-//    'let': letBinding,
-//    template: template,
-var bindings = {
-    foreach: TemplateForEachBindingHandler,
-    template: TemplateBindingHandler
-};
-
-export { bindings, nativeTemplateEngine, templateEngine, setTemplateEngine, renderTemplate, TemplateBindingHandler, domElement, anonymousTemplate };
-//# sourceMappingURL=binding.template.js.map

package/dist/binding.template.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"binding.template.js","sources":["../../../node_modules/tslib/tslib.es6.js"],"sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n"],"names":[],"mappings":";;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;AAgBA,IAAI,aAAa,GAAG,SAAS,CAAC,EAAE,CAAC,EAAE;IAC/B,aAAa,GAAG,MAAM,CAAC,cAAc;SAChC,EAAE,SAAS,EAAE,EAAE,EAAE,YAAY,KAAK,IAAI,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,EAAE,CAAC;QAC5E,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,KAAK,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAC/E,OAAO,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAC9B,CAAC;;AAEF,SAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE;IAC5B,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACpB,SAAS,EAAE,GAAG,EAAE,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,EAAE;IACvC,CAAC,CAAC,SAAS,GAAG,CAAC,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,SAAS,GAAG,CAAC,CAAC,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;CACxF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}