@tko/bind 4.0.0-alpha8.0 → 4.0.0-beta1.0

package/dist/bind.js

@@ -1,1185 +0,0 @@
-/*!
- * TKO DOM-Observable Binding 🥊  @tko/bind@4.0.0-alpha8.0
- * (c) The Knockout.js Team - https://tko.io
- * License: MIT (http://www.opensource.org/licenses/mit-license.php)
- */
-
-import { domData, extend, options, virtualElements, objectMap, tagNameLower, objectForEach, arrayIndexOf, arrayForEach, fixUpContinuousNodeArray, replaceDomNodes, arrayPushAll, anyDomNodeIsAttachedToDocument, arrayMap, cleanNode, removeNode, compareArrays } from '@tko/utils';
-import { subscribable, unwrap, isObservable, isWriteableObservable, dependencyDetection, observable } from '@tko/observable';
-import { pureComputed, computed } from '@tko/computed';
-import { LifeCycle } from '@tko/lifecycle';
-
-var contextAncestorBindingInfo = Symbol('_ancestorBindingInfo');
-var boundElementDomDataKey = domData.nextKey();
-var bindingEvent = {
-    childrenComplete: 'childrenComplete',
-    descendantsComplete: 'descendantsComplete',
-    subscribe: function (node, event, callback, context) {
-        var bindingInfo = domData.getOrSet(node, boundElementDomDataKey, {});
-        if (!bindingInfo.eventSubscribable) {
-            bindingInfo.eventSubscribable = new subscribable();
-        }
-        return bindingInfo.eventSubscribable.subscribe(callback, context, event);
-    },
-    notify: function (node, event) {
-        var bindingInfo = domData.get(node, boundElementDomDataKey);
-        if (bindingInfo) {
-            if (bindingInfo.eventSubscribable) {
-                bindingInfo.eventSubscribable.notifySubscribers(node, event);
-            }
-        }
-    }
-};
-
-var boundElementDomDataKey$1 = domData.nextKey();
-var contextSubscribeSymbol = Symbol('Knockout Context Subscription');
-// Unique stub to indicate inheritance.
-var inheritParentIndicator = Symbol('Knockout Parent Indicator');
-// The bindingContext constructor is only called directly to create the root context. For child
-// contexts, use bindingContext.createChildContext or bindingContext.extend.
-function bindingContext(dataItemOrAccessor, parentContext, dataItemAlias, extendCallback, settings) {
-    var self = this;
-    var shouldInheritData = dataItemOrAccessor === inheritParentIndicator;
-    var realDataItemOrAccessor = shouldInheritData ? undefined : dataItemOrAccessor;
-    var isFunc = typeof realDataItemOrAccessor === 'function' && !isObservable(realDataItemOrAccessor);
-    // Export 'ko' in the binding context so it will be available in bindings and templates
-    // even if 'ko' isn't exported as a global, such as when using an AMD loader.
-    // See https://github.com/SteveSanderson/knockout/issues/490
-    self.ko = options.knockoutInstance;
-    var subscribable$$1;
-    // The binding context object includes static properties for the current, parent, and root view models.
-    // If a view model is actually stored in an observable, the corresponding binding context object, and
-    // any child contexts, must be updated when the view model is changed.
-    function updateContext() {
-        // Most of the time, the context will directly get a view model object, but if a function is given,
-        // we call the function to retrieve the view model. If the function accesses any observables or returns
-        // an observable, the dependency is tracked, and those observables can later cause the binding
-        // context to be updated.
-        var dataItemOrObservable = isFunc ? realDataItemOrAccessor() : realDataItemOrAccessor;
-        var dataItem = unwrap(dataItemOrObservable);
-        if (parentContext) {
-            // When a "parent" context is given, register a dependency on the parent context. Thus whenever the
-            // parent context is updated, this context will also be updated.
-            if (parentContext[contextSubscribeSymbol]) {
-                parentContext[contextSubscribeSymbol]();
-            }
-            // Copy $root and any custom properties from the parent context
-            extend(self, parentContext);
-            // Copy Symbol properties
-            if (contextAncestorBindingInfo in parentContext) {
-                self[contextAncestorBindingInfo] = parentContext[contextAncestorBindingInfo];
-            }
-        }
-        else {
-            self.$parents = [];
-            self.$root = dataItem;
-        }
-        self[contextSubscribeSymbol] = subscribable$$1;
-        if (shouldInheritData) {
-            dataItem = self.$data;
-        }
-        else {
-            self.$rawData = dataItemOrObservable;
-            self.$data = dataItem;
-        }
-        if (dataItemAlias) {
-            self[dataItemAlias] = dataItem;
-        }
-        // The extendCallback function is provided when creating a child context or extending a context.
-        // It handles the specific actions needed to finish setting up the binding context. Actions in this
-        // function could also add dependencies to this binding context.
-        if (extendCallback) {
-            extendCallback(self, parentContext, dataItem);
-        }
-        return self.$data;
-    }
-    if (settings && settings.exportDependencies) {
-        // The "exportDependencies" option means that the calling code will track any dependencies and re-create
-        // the binding context when they change.
-        updateContext();
-    }
-    else {
-        subscribable$$1 = pureComputed(updateContext);
-        subscribable$$1.peek();
-        // At this point, the binding context has been initialized, and the "subscribable" computed observable is
-        // subscribed to any observables that were accessed in the process. If there is nothing to track, the
-        // computed will be inactive, and we can safely throw it away. If it's active, the computed is stored in
-        // the context object.
-        if (subscribable$$1.isActive()) {
-            self[contextSubscribeSymbol] = subscribable$$1;
-            // Always notify because even if the model ($data) hasn't changed, other context properties might have changed
-            subscribable$$1['equalityComparer'] = null;
-        }
-        else {
-            self[contextSubscribeSymbol] = undefined;
-        }
-    }
-}
-Object.assign(bindingContext.prototype, {
-    lookup: function (token, globals, node) {
-        // short circuits
-        switch (token) {
-            case '$element': return node;
-            case '$context': return this;
-            case 'this':
-            case '$data': return this.$data;
-        }
-        var $data = this.$data;
-        // instanceof Object covers 1. {}, 2. [], 3. function() {}, 4. new *;  it excludes undefined, null, primitives.
-        if ($data instanceof Object && token in $data) {
-            return $data[token];
-        }
-        if (token in this) {
-            return this[token];
-        }
-        if (token in globals) {
-            return globals[token];
-        }
-        throw new Error("The variable \"" + token + "\" was not found on $data, $context, or globals.");
-    },
-    // Extend the binding context hierarchy with a new view model object. If the parent context is watching
-    // any observables, the new child context will automatically get a dependency on the parent context.
-    // But this does not mean that the $data value of the child context will also get updated. If the child
-    // view model also depends on the parent view model, you must provide a function that returns the correct
-    // view model on each update.
-    createChildContext: function (dataItemOrAccessor, dataItemAlias, extendCallback, settings) {
-        return new bindingContext(dataItemOrAccessor, this, dataItemAlias, function (self, parentContext) {
-            // Extend the context hierarchy by setting the appropriate pointers
-            self.$parentContext = parentContext;
-            self.$parent = parentContext.$data;
-            self.$parents = (parentContext.$parents || []).slice(0);
-            self.$parents.unshift(self.$parent);
-            if (extendCallback) {
-                extendCallback(self);
-            }
-        }, settings);
-    },
-    // Extend the binding context with new custom properties. This doesn't change the context hierarchy.
-    // Similarly to "child" contexts, provide a function here to make sure that the correct values are set
-    // when an observable view model is updated.
-    extend: function (properties) {
-        // If the parent context references an observable view model, "_subscribable" will always be the
-        // latest view model object. If not, "_subscribable" isn't set, and we can use the static "$data" value.
-        return new bindingContext(inheritParentIndicator, this, null, function (self, parentContext) {
-            extend(self, typeof properties === 'function' ? properties.call(self) : properties);
-        });
-    },
-    createStaticChildContext: function (dataItemOrAccessor, dataItemAlias) {
-        return this.createChildContext(dataItemOrAccessor, dataItemAlias, null, { 'exportDependencies': true });
-    }
-});
-function storedBindingContextForNode(node) {
-    var bindingInfo = domData.get(node, boundElementDomDataKey$1);
-    return bindingInfo && bindingInfo.context;
-}
-// Retrieving binding context from arbitrary nodes
-function contextFor(node) {
-    // We can only do something meaningful for elements and comment nodes (in particular, not text nodes, as IE can't store domdata for them)
-    if (node && (node.nodeType === 1 || node.nodeType === 8)) {
-        return storedBindingContextForNode(node);
-    }
-}
-function dataFor(node) {
-    var context = contextFor(node);
-    return context ? context.$data : undefined;
-}
-
-/*! *****************************************************************************
-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 = 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]; };
-
-function __extends(d, b) {
-    extendStatics(d, b);
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            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;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-}
-
-function __values(o) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
-    if (m) return m.call(o);
-    return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-}
-
-function __read(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-}
-
-function __spread() {
-    for (var ar = [], i = 0; i < arguments.length; i++)
-        ar = ar.concat(__read(arguments[i]));
-    return ar;
-}
-
-var BindingResult = /** @class */ (function () {
-    function BindingResult(_a) {
-        var asyncBindingsApplied = _a.asyncBindingsApplied, rootNode = _a.rootNode, bindingContext = _a.bindingContext;
-        Object.assign(this, {
-            rootNode: rootNode,
-            bindingContext: bindingContext,
-            isSync: asyncBindingsApplied.size === 0,
-            isComplete: this.isSync
-        });
-        if (!this.isSync) {
-            this.completionPromise = this.completeWhenBindingsFinish(asyncBindingsApplied);
-        }
-    }
-    BindingResult.prototype.completeWhenBindingsFinish = function (asyncBindingsApplied) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, Promise.all(asyncBindingsApplied)];
-                    case 1:
-                        _a.sent();
-                        this.isComplete = true;
-                        return [2 /*return*/, this];
-                }
-            });
-        });
-    };
-    return BindingResult;
-}());
-
-var BindingHandler = /** @class */ (function (_super) {
-    __extends(BindingHandler, _super);
-    function BindingHandler(params) {
-        var _this = _super.call(this) || this;
-        var $element = params.$element, valueAccessor = params.valueAccessor, allBindings = params.allBindings, $context = params.$context;
-        Object.assign(_this, {
-            valueAccessor: valueAccessor,
-            allBindings: allBindings,
-            $element: $element,
-            $context: $context,
-            $data: $context.$data
-        });
-        _this.anchorTo($element);
-        return _this;
-    }
-    Object.defineProperty(BindingHandler.prototype, "value", {
-        get: function () { return this.valueAccessor(); },
-        set: function (v) {
-            var va = this.valueAccessor();
-            if (isWriteableObservable(va)) {
-                va(v);
-            }
-            else {
-                this.valueAccessor(v);
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(BindingHandler.prototype, "controlsDescendants", {
-        get: function () { return false; },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(BindingHandler, "allowVirtualElements", {
-        get: function () { return false; },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(BindingHandler, "isBindingHandlerClass", {
-        get: function () { return true; },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(BindingHandler.prototype, "bindingCompleted", {
-        /* Overload this for asynchronous bindings or bindings that recursively
-           apply bindings (e.g. components, foreach, template).
-      
-           A binding should be complete when it has run through once, notably
-           in server-side bindings for pre-rendering.
-        */
-        get: function () { return true; },
-        enumerable: true,
-        configurable: true
-    });
-    BindingHandler.registerAs = function (name, provider) {
-        if (provider === void 0) { provider = options.bindingProviderInstance; }
-        provider.bindingHandlers.set(name, this);
-    };
-    return BindingHandler;
-}(LifeCycle));
-/**
- * An AsyncBindingHandler shall call `completeBinding` when the binding
- * is to be considered complete.
- */
-var ResolveSymbol = Symbol('Async Binding Resolved');
-var AsyncBindingHandler = /** @class */ (function (_super) {
-    __extends(AsyncBindingHandler, _super);
-    function AsyncBindingHandler(params) {
-        var _this = _super.call(this, params) || this;
-        _this.bindingCompletion = new Promise(function (resolve) {
-            _this[ResolveSymbol] = resolve;
-        });
-        _this.completeBinding = function (bindingResult) { return _this[ResolveSymbol](bindingResult); };
-        return _this;
-    }
-    Object.defineProperty(AsyncBindingHandler.prototype, "bindingCompleted", {
-        get: function () { return this.bindingCompletion; },
-        enumerable: true,
-        configurable: true
-    });
-    return AsyncBindingHandler;
-}(BindingHandler));
-
-/**
- * We have no guarantees, for users employing legacy bindings,
- * that it has not been changed with a modification like
- *
- *    ko.bindingHandlers[name] = { init: ...}
- *
- * ... so we have to keep track by way of a map.
- */
-var PossibleWeakMap = options.global.WeakMap || Map;
-var legacyBindingMap = new PossibleWeakMap();
-var LegacyBindingHandler = /** @class */ (function (_super) {
-    __extends(LegacyBindingHandler, _super);
-    function LegacyBindingHandler(params) {
-        var _this = _super.call(this, params) || this;
-        var handler = _this.handler;
-        _this.onError = params.onError;
-        if (typeof handler.dispose === 'function') {
-            _this.addDisposable(handler);
-        }
-        try {
-            _this.initReturn = handler.init && handler.init.apply(handler, __spread(_this.legacyArgs));
-        }
-        catch (e) {
-            params.onError('init', e);
-        }
-        return _this;
-    }
-    LegacyBindingHandler.prototype.onValueChange = function () {
-        var handler = this.handler;
-        if (typeof handler.update !== 'function') {
-            return;
-        }
-        try {
-            handler.update.apply(handler, __spread(this.legacyArgs));
-        }
-        catch (e) {
-            this.onError('update', e);
-        }
-    };
-    Object.defineProperty(LegacyBindingHandler.prototype, "legacyArgs", {
-        get: function () {
-            return [
-                this.$element, this.valueAccessor, this.allBindings,
-                this.$data, this.$context
-            ];
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(LegacyBindingHandler.prototype, "controlsDescendants", {
-        get: function () {
-            var objectToTest = this.initReturn || this.handler || {};
-            return objectToTest.controlsDescendantBindings;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    /**
-     * Create a handler instance from the `origin`, which may be:
-     *
-     * 1. an object (becomes LegacyBindingHandler)
-     * 2. a function (becomes LegacyBindingHandler with `init: function`)
-     *
-     * If given an object (the only kind supported in knockout 3.x and before), it
-     * shall draw the `init`, `update`, and `allowVirtualElements` properties
-     */
-    LegacyBindingHandler.getOrCreateFor = function (key, handler) {
-        if (legacyBindingMap.has(handler)) {
-            return legacyBindingMap.get(handler);
-        }
-        var newLegacyHandler = this.createFor(key, handler);
-        legacyBindingMap.set(handler, newLegacyHandler);
-        return newLegacyHandler;
-    };
-    LegacyBindingHandler.createFor = function (key, handler) {
-        if (typeof handler === 'function') {
-            var _a = __read([handler, handler.dispose], 2), initFn_1 = _a[0], disposeFn_1 = _a[1];
-            return /** @class */ (function (_super) {
-                __extends(class_1, _super);
-                function class_1() {
-                    return _super !== null && _super.apply(this, arguments) || this;
-                }
-                Object.defineProperty(class_1.prototype, "handler", {
-                    get: function () {
-                        var init = initFn_1.bind(this);
-                        var dispose = disposeFn_1 ? disposeFn_1.bind(this) : null;
-                        return { init: init, dispose: dispose };
-                    },
-                    enumerable: true,
-                    configurable: true
-                });
-                Object.defineProperty(class_1, "after", {
-                    get: function () { return handler.after; },
-                    enumerable: true,
-                    configurable: true
-                });
-                Object.defineProperty(class_1, "allowVirtualElements", {
-                    get: function () {
-                        return handler.allowVirtualElements || virtualElements.allowedBindings[key];
-                    },
-                    enumerable: true,
-                    configurable: true
-                });
-                return class_1;
-            }(LegacyBindingHandler));
-        }
-        if (typeof handler === 'object') {
-            return /** @class */ (function (_super) {
-                __extends(class_2, _super);
-                function class_2() {
-                    return _super !== null && _super.apply(this, arguments) || this;
-                }
-                Object.defineProperty(class_2.prototype, "handler", {
-                    get: function () { return handler; },
-                    enumerable: true,
-                    configurable: true
-                });
-                Object.defineProperty(class_2, "after", {
-                    get: function () { return handler.after; },
-                    enumerable: true,
-                    configurable: true
-                });
-                Object.defineProperty(class_2, "allowVirtualElements", {
-                    get: function () {
-                        return handler.allowVirtualElements || virtualElements.allowedBindings[key];
-                    },
-                    enumerable: true,
-                    configurable: true
-                });
-                return class_2;
-            }(LegacyBindingHandler));
-        }
-        throw new Error('The given handler is not an appropriate type.');
-    };
-    return LegacyBindingHandler;
-}(BindingHandler));
-
-/* eslint no-cond-assign: 0 */
-// The following element types will not be recursed into during binding.
-var bindingDoesNotRecurseIntoElementTypes = {
-    // Don't want bindings that operate on text nodes to mutate <script> and <textarea> contents,
-    // because it's unexpected and a potential XSS issue.
-    // Also bindings should not operate on <template> elements since this breaks in Internet Explorer
-    // and because such elements' contents are always intended to be bound in a different context
-    // from where they appear in the document.
-    'script': true,
-    'textarea': true,
-    'template': true
-};
-function getBindingProvider() {
-    return options.bindingProviderInstance.instance || options.bindingProviderInstance;
-}
-function isProviderForNode(provider, node) {
-    var nodeTypes = provider.FOR_NODE_TYPES || [1, 3, 8];
-    return nodeTypes.includes(node.nodeType);
-}
-function asProperHandlerClass(handler, bindingKey) {
-    if (!handler) {
-        return;
-    }
-    return handler.isBindingHandlerClass ? handler
-        : LegacyBindingHandler.getOrCreateFor(bindingKey, handler);
-}
-function getBindingHandlerFromComponent(bindingKey, $component) {
-    if (!$component || typeof $component.getBindingHandler !== 'function') {
-        return;
-    }
-    return asProperHandlerClass($component.getBindingHandler(bindingKey));
-}
-function getBindingHandler(bindingKey) {
-    var bindingDefinition = options.getBindingHandler(bindingKey) || getBindingProvider().bindingHandlers.get(bindingKey);
-    return asProperHandlerClass(bindingDefinition, bindingKey);
-}
-// Returns the value of a valueAccessor function
-function evaluateValueAccessor(valueAccessor) {
-    return valueAccessor();
-}
-function applyBindingsToDescendantsInternal(bindingContext$$1, elementOrVirtualElement, asyncBindingsApplied) {
-    var nextInQueue = virtualElements.firstChild(elementOrVirtualElement);
-    if (!nextInQueue) {
-        return;
-    }
-    var currentChild;
-    var provider = getBindingProvider();
-    var preprocessNode = provider.preprocessNode;
-    // Preprocessing allows a binding provider to mutate a node before bindings are applied to it. For example it's
-    // possible to insert new siblings after it, and/or replace the node with a different one. This can be used to
-    // implement custom binding syntaxes, such as {{ value }} for string interpolation, or custom element types that
-    // trigger insertion of <template> contents at that point in the document.
-    if (preprocessNode) {
-        while (currentChild = nextInQueue) {
-            nextInQueue = virtualElements.nextSibling(currentChild);
-            preprocessNode.call(provider, currentChild);
-        }
-        // Reset nextInQueue for the next loop
-        nextInQueue = virtualElements.firstChild(elementOrVirtualElement);
-    }
-    while (currentChild = nextInQueue) {
-        // Keep a record of the next child *before* applying bindings, in case the binding removes the current child from its position
-        nextInQueue = virtualElements.nextSibling(currentChild);
-        applyBindingsToNodeAndDescendantsInternal(bindingContext$$1, currentChild, asyncBindingsApplied);
-    }
-    bindingEvent.notify(elementOrVirtualElement, bindingEvent.childrenComplete);
-}
-function hasBindings(node) {
-    var provider = getBindingProvider();
-    return isProviderForNode(provider, node) && provider.nodeHasBindings(node);
-}
-function nodeOrChildHasBindings(node) {
-    return hasBindings(node) || __spread(node.childNodes).some(function (c) { return nodeOrChildHasBindings(c); });
-}
-function applyBindingsToNodeAndDescendantsInternal(bindingContext$$1, nodeVerified, asyncBindingsApplied) {
-    var isElement = nodeVerified.nodeType === 1;
-    if (isElement) { // Workaround IE <= 8 HTML parsing weirdness
-        virtualElements.normaliseVirtualElementDomStructure(nodeVerified);
-    }
-    // Perf optimisation: Apply bindings only if...
-    // (1) We need to store the binding info for the node (all element nodes)
-    // (2) It might have bindings (e.g., it has a data-bind attribute, or it's a marker for a containerless template)
-    var shouldApplyBindings = isElement || // Case (1)
-        hasBindings(nodeVerified); // Case (2)
-    var shouldBindDescendants = (shouldApplyBindings
-        ? applyBindingsToNodeInternal(nodeVerified, null, bindingContext$$1, asyncBindingsApplied)
-        : { shouldBindDescendants: true }).shouldBindDescendants;
-    if (shouldBindDescendants && !bindingDoesNotRecurseIntoElementTypes[tagNameLower(nodeVerified)]) {
-        // We're recursing automatically into (real or virtual) child nodes without changing binding contexts. So,
-        //  * For children of a *real* element, the binding context is certainly the same as on their DOM .parentNode,
-        //    hence bindingContextsMayDifferFromDomParentElement is false
-        //  * For children of a *virtual* element, we can't be sure. Evaluating .parentNode on those children may
-        //    skip over any number of intermediate virtual elements, any of which might define a custom binding context,
-        //    hence bindingContextsMayDifferFromDomParentElement is true
-        applyBindingsToDescendantsInternal(bindingContext$$1, nodeVerified, asyncBindingsApplied);
-    }
-}
-function topologicalSortBindings(bindings, $component) {
-    var e_1, _a, results, bindingsConsidered, cyclicDependencyStack, results_1, results_1_1, result, e_1_1;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
-            case 0:
-                results = [];
-                bindingsConsidered = {} // A temporary record of which bindings are already in 'result'
-                ;
-                cyclicDependencyStack = [] // Keeps track of a depth-search so that, if there's a cycle, we know which bindings caused it
-                ;
-                objectForEach(bindings, function pushBinding(bindingKey) {
-                    if (!bindingsConsidered[bindingKey]) {
-                        var binding = getBindingHandlerFromComponent(bindingKey, $component) || getBindingHandler(bindingKey);
-                        if (!binding) {
-                            return;
-                        }
-                        // First add dependencies (if any) of the current binding
-                        if (binding.after) {
-                            cyclicDependencyStack.push(bindingKey);
-                            arrayForEach(binding.after, function (bindingDependencyKey) {
-                                if (!bindings[bindingDependencyKey]) {
-                                    return;
-                                }
-                                if (arrayIndexOf(cyclicDependencyStack, bindingDependencyKey) !== -1) {
-                                    throw Error('Cannot combine the following bindings, because they have a cyclic dependency: ' + cyclicDependencyStack.join(', '));
-                                }
-                                else {
-                                    pushBinding(bindingDependencyKey);
-                                }
-                            });
-                            cyclicDependencyStack.length--;
-                        }
-                        // Next add the current binding
-                        results.push([bindingKey, binding]);
-                    }
-                    bindingsConsidered[bindingKey] = true;
-                });
-                _b.label = 1;
-            case 1:
-                _b.trys.push([1, 6, 7, 8]);
-                results_1 = __values(results), results_1_1 = results_1.next();
-                _b.label = 2;
-            case 2:
-                if (!!results_1_1.done) return [3 /*break*/, 5];
-                result = results_1_1.value;
-                return [4 /*yield*/, result];
-            case 3:
-                _b.sent();
-                _b.label = 4;
-            case 4:
-                results_1_1 = results_1.next();
-                return [3 /*break*/, 2];
-            case 5: return [3 /*break*/, 8];
-            case 6:
-                e_1_1 = _b.sent();
-                e_1 = { error: e_1_1 };
-                return [3 /*break*/, 8];
-            case 7:
-                try {
-                    if (results_1_1 && !results_1_1.done && (_a = results_1["return"])) _a.call(results_1);
-                }
-                finally { if (e_1) throw e_1.error; }
-                return [7 /*endfinally*/];
-            case 8: return [2 /*return*/];
-        }
-    });
-}
-function applyBindingsToNodeInternal(node, sourceBindings, bindingContext$$1, asyncBindingsApplied) {
-    var e_2, _a;
-    var bindingInfo = domData.getOrSet(node, boundElementDomDataKey$1, {});
-    // Prevent multiple applyBindings calls for the same node, except when a binding value is specified
-    var alreadyBound = bindingInfo.alreadyBound;
-    if (!sourceBindings) {
-        if (alreadyBound) {
-            if (!nodeOrChildHasBindings(node)) {
-                return false;
-            }
-            onBindingError({
-                during: 'apply',
-                errorCaptured: new Error('You cannot apply bindings multiple times to the same element.'),
-                element: node,
-                bindingContext: bindingContext$$1
-            });
-            return false;
-        }
-        bindingInfo.alreadyBound = true;
-    }
-    if (!alreadyBound) {
-        bindingInfo.context = bindingContext$$1;
-    }
-    // Use bindings if given, otherwise fall back on asking the bindings provider to give us some bindings
-    var bindings;
-    if (sourceBindings && typeof sourceBindings !== 'function') {
-        bindings = sourceBindings;
-    }
-    else {
-        var provider_1 = getBindingProvider();
-        var getBindings_1 = provider_1.getBindingAccessors;
-        if (isProviderForNode(provider_1, node)) {
-            // Get the binding from the provider within a computed observable so that we can update the bindings whenever
-            // the binding context is updated or if the binding provider accesses observables.
-            var bindingsUpdater = computed(function () {
-                bindings = sourceBindings ? sourceBindings(bindingContext$$1, node) : getBindings_1.call(provider_1, node, bindingContext$$1);
-                // Register a dependency on the binding context to support observable view models.
-                if (bindings && bindingContext$$1[contextSubscribeSymbol]) {
-                    bindingContext$$1[contextSubscribeSymbol]();
-                }
-                return bindings;
-            }, null, { disposeWhenNodeIsRemoved: node });
-            if (!bindings || !bindingsUpdater.isActive()) {
-                bindingsUpdater = null;
-            }
-        }
-    }
-    var bindingHandlerThatControlsDescendantBindings;
-    if (bindings) {
-        var $component = bindingContext$$1.$component || {};
-        var allBindingHandlers = {};
-        domData.set(node, 'bindingHandlers', allBindingHandlers);
-        // Return the value accessor for a given binding. When bindings are static (won't be updated because of a binding
-        // context update), just return the value accessor from the binding. Otherwise, return a function that always gets
-        // the latest binding value and registers a dependency on the binding updater.
-        var getValueAccessor_1 = bindingsUpdater
-            ? function (bindingKey) { return function (optionalValue) {
-                var valueAccessor = bindingsUpdater()[bindingKey];
-                if (arguments.length === 0) {
-                    return evaluateValueAccessor(valueAccessor);
-                }
-                else {
-                    return valueAccessor(optionalValue);
-                }
-            }; } : function (bindingKey) { return bindings[bindingKey]; };
-        // Use of allBindings as a function is maintained for backwards compatibility, but its use is deprecated
-        function allBindings() {
-            return objectMap(bindingsUpdater ? bindingsUpdater() : bindings, evaluateValueAccessor);
-        }
-        // The following is the 3.x allBindings API
-        allBindings.has = function (key) { return key in bindings; };
-        allBindings.get = function (key) { return bindings[key] && evaluateValueAccessor(getValueAccessor_1(key)); };
-        if (bindingEvent.childrenComplete in bindings) {
-            bindingEvent.subscribe(node, bindingEvent.childrenComplete, function () {
-                var callback = evaluateValueAccessor(bindings[bindingEvent.childrenComplete]);
-                if (!callback) {
-                    return;
-                }
-                var nodes = virtualElements.childNodes(node);
-                if (nodes.length) {
-                    callback(nodes, dataFor(nodes[0]));
-                }
-            });
-        }
-        var bindingsGenerated = topologicalSortBindings(bindings, $component);
-        var nodeAsyncBindingPromises = new Set();
-        var _loop_1 = function (key, BindingHandlerClass) {
-            // Go through the sorted bindings, calling init and update for each
-            function reportBindingError(during, errorCaptured) {
-                onBindingError({
-                    during: during,
-                    errorCaptured: errorCaptured,
-                    bindings: bindings,
-                    allBindings: allBindings,
-                    bindingKey: key,
-                    bindingContext: bindingContext$$1,
-                    element: node,
-                    valueAccessor: getValueAccessor_1(key)
-                });
-            }
-            if (node.nodeType === 8 && !BindingHandlerClass.allowVirtualElements) {
-                throw new Error("The binding '" + key + "' cannot be used with virtual elements");
-            }
-            try {
-                var bindingHandler_1 = dependencyDetection.ignore(function () {
-                    return new BindingHandlerClass({
-                        allBindings: allBindings,
-                        $element: node,
-                        $context: bindingContext$$1,
-                        onError: reportBindingError,
-                        valueAccessor: function () {
-                            var v = [];
-                            for (var _i = 0; _i < arguments.length; _i++) {
-                                v[_i] = arguments[_i];
-                            }
-                            return getValueAccessor_1(key).apply(void 0, __spread(v));
-                        }
-                    });
-                });
-                if (bindingHandler_1.onValueChange) {
-                    dependencyDetection.ignore(function () {
-                        return bindingHandler_1.computed('onValueChange');
-                    });
-                }
-                // Expose the bindings via domData.
-                allBindingHandlers[key] = bindingHandler_1;
-                if (bindingHandler_1.controlsDescendants) {
-                    if (bindingHandlerThatControlsDescendantBindings !== undefined) {
-                        throw new Error('Multiple bindings (' + bindingHandlerThatControlsDescendantBindings + ' and ' + key + ') are trying to control descendant bindings of the same element. You cannot use these bindings together on the same element.');
-                    }
-                    bindingHandlerThatControlsDescendantBindings = key;
-                }
-                if (bindingHandler_1.bindingCompleted instanceof Promise) {
-                    asyncBindingsApplied.add(bindingHandler_1.bindingCompleted);
-                    nodeAsyncBindingPromises.add(bindingHandler_1.bindingCompleted);
-                }
-            }
-            catch (err) {
-                reportBindingError('creation', err);
-            }
-        };
-        try {
-            for (var bindingsGenerated_1 = __values(bindingsGenerated), bindingsGenerated_1_1 = bindingsGenerated_1.next(); !bindingsGenerated_1_1.done; bindingsGenerated_1_1 = bindingsGenerated_1.next()) {
-                var _b = __read(bindingsGenerated_1_1.value, 2), key = _b[0], BindingHandlerClass = _b[1];
-                _loop_1(key, BindingHandlerClass);
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (bindingsGenerated_1_1 && !bindingsGenerated_1_1.done && (_a = bindingsGenerated_1["return"])) _a.call(bindingsGenerated_1);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        triggerDescendantsComplete(node, bindings, nodeAsyncBindingPromises);
-    }
-    var shouldBindDescendants = bindingHandlerThatControlsDescendantBindings === undefined;
-    return { shouldBindDescendants: shouldBindDescendants };
-}
-/**
- *
- * @param {HTMLElement} node
- * @param {Object} bindings
- * @param {[Promise]} nodeAsyncBindingPromises
- */
-function triggerDescendantsComplete(node, bindings, nodeAsyncBindingPromises) {
-    /** descendantsComplete ought to be an instance of the descendantsComplete
-      *  binding handler. */
-    var hasBindingHandler = bindingEvent.descendantsComplete in bindings;
-    var hasFirstChild = virtualElements.firstChild(node);
-    var accessor = hasBindingHandler && evaluateValueAccessor(bindings[bindingEvent.descendantsComplete]);
-    var callback = function () {
-        bindingEvent.notify(node, bindingEvent.descendantsComplete);
-        if (accessor && hasFirstChild) {
-            accessor(node);
-        }
-    };
-    if (nodeAsyncBindingPromises.size) {
-        Promise.all(nodeAsyncBindingPromises).then(callback);
-    }
-    else {
-        callback();
-    }
-}
-function getBindingContext(viewModelOrBindingContext, extendContextCallback) {
-    return viewModelOrBindingContext && (viewModelOrBindingContext instanceof bindingContext)
-        ? viewModelOrBindingContext
-        : new bindingContext(viewModelOrBindingContext, undefined, undefined, extendContextCallback);
-}
-function applyBindingAccessorsToNode(node, bindings, viewModelOrBindingContext, asyncBindingsApplied) {
-    if (node.nodeType === 1) { // If it's an element, workaround IE <= 8 HTML parsing weirdness
-        virtualElements.normaliseVirtualElementDomStructure(node);
-    }
-    return applyBindingsToNodeInternal(node, bindings, getBindingContext(viewModelOrBindingContext), asyncBindingsApplied);
-}
-function applyBindingsToNode(node, bindings, viewModelOrBindingContext) {
-    var asyncBindingsApplied = new Set();
-    var bindingContext$$1 = getBindingContext(viewModelOrBindingContext);
-    var bindingAccessors = getBindingProvider().makeBindingAccessors(bindings, bindingContext$$1, node);
-    applyBindingAccessorsToNode(node, bindingAccessors, bindingContext$$1, asyncBindingsApplied);
-    return new BindingResult({ asyncBindingsApplied: asyncBindingsApplied, rootNode: node, bindingContext: bindingContext$$1 });
-}
-function applyBindingsToDescendants(viewModelOrBindingContext, rootNode) {
-    var asyncBindingsApplied = new Set();
-    if (rootNode.nodeType === 1 || rootNode.nodeType === 8) {
-        var bindingContext_1 = getBindingContext(viewModelOrBindingContext);
-        applyBindingsToDescendantsInternal(bindingContext_1, rootNode, asyncBindingsApplied);
-        return new BindingResult({ asyncBindingsApplied: asyncBindingsApplied, rootNode: rootNode, bindingContext: bindingContext_1 });
-    }
-    return new BindingResult({ asyncBindingsApplied: asyncBindingsApplied, rootNode: rootNode });
-}
-function applyBindings(viewModelOrBindingContext, rootNode, extendContextCallback) {
-    var asyncBindingsApplied = new Set();
-    // If jQuery is loaded after Knockout, we won't initially have access to it. So save it here.
-    if (!options.jQuery === undefined && options.jQuery) {
-        options.jQuery = options.jQuery;
-    }
-    // rootNode is optional
-    if (!rootNode) {
-        rootNode = window.document.body;
-        if (!rootNode) {
-            throw Error('ko.applyBindings: could not find window.document.body; has the document been loaded?');
-        }
-    }
-    else if (rootNode.nodeType !== 1 && rootNode.nodeType !== 8) {
-        throw Error('ko.applyBindings: first parameter should be your view model; second parameter should be a DOM node');
-    }
-    var rootContext = getBindingContext(viewModelOrBindingContext, extendContextCallback);
-    applyBindingsToNodeAndDescendantsInternal(rootContext, rootNode, asyncBindingsApplied);
-    return Promise.all(asyncBindingsApplied);
-}
-function onBindingError(spec) {
-    var error;
-    if (spec.bindingKey) {
-        // During: 'init' or initial 'update'
-        error = spec.errorCaptured;
-        spec.message = 'Unable to process binding "' + spec.bindingKey +
-            '" in binding "' + spec.bindingKey +
-            '"\nMessage: ' + (error.message ? error.message : error);
-    }
-    else {
-        // During: 'apply'
-        error = spec.errorCaptured;
-    }
-    try {
-        extend(error, spec);
-    }
-    catch (e) {
-        // Read-only error e.g. a DOMEXception.
-        spec.stack = error.stack;
-        error = new Error(error.message ? error.message : error);
-        extend(error, spec);
-    }
-    options.onError(error);
-}
-
-/* eslint no-cond-assign: 0 */
-// Objective:
-// * Given an input array, a container DOM node, and a function from array elements to arrays of DOM nodes,
-//   map the array elements to arrays of DOM nodes, concatenate together all these arrays, and use them to populate the container DOM node
-// * Next time we're given the same combination of things (with the array possibly having mutated), update the container DOM node
-//   so that its children is again the concatenation of the mappings of the array elements, but don't re-map any array elements that we
-//   previously mapped - retain those nodes, and just insert/delete other ones
-// "callbackAfterAddingNodes" will be invoked after any "mapping"-generated nodes are inserted into the container node
-// You can use this, for example, to activate bindings on those nodes.
-function mapNodeAndRefreshWhenChanged(containerNode, mapping, valueToMap, callbackAfterAddingNodes, index) {
-    // Map this array value inside a dependentObservable so we re-map when any dependency changes
-    var mappedNodes = [];
-    var dependentObservable = computed(function () {
-        var newMappedNodes = mapping(valueToMap, index, fixUpContinuousNodeArray(mappedNodes, containerNode)) || [];
-        // On subsequent evaluations, just replace the previously-inserted DOM nodes
-        if (mappedNodes.length > 0) {
-            replaceDomNodes(mappedNodes, newMappedNodes);
-            if (callbackAfterAddingNodes) {
-                dependencyDetection.ignore(callbackAfterAddingNodes, null, [valueToMap, newMappedNodes, index]);
-            }
-        }
-        // Replace the contents of the mappedNodes array, thereby updating the record
-        // of which nodes would be deleted if valueToMap was itself later removed
-        mappedNodes.length = 0;
-        arrayPushAll(mappedNodes, newMappedNodes);
-    }, null, { disposeWhenNodeIsRemoved: containerNode, disposeWhen: function () { return !anyDomNodeIsAttachedToDocument(mappedNodes); } });
-    return { mappedNodes: mappedNodes, dependentObservable: (dependentObservable.isActive() ? dependentObservable : undefined) };
-}
-var lastMappingResultDomDataKey = domData.nextKey();
-var deletedItemDummyValue = domData.nextKey();
-function setDomNodeChildrenFromArrayMapping(domNode, array, mapping, options$$1, callbackAfterAddingNodes, editScript) {
-    // Compare the provided array against the previous one
-    array = array || [];
-    if (typeof array.length === 'undefined') {
-        array = [array];
-    }
-    options$$1 = options$$1 || {};
-    var lastMappingResult = domData.get(domNode, lastMappingResultDomDataKey);
-    var isFirstExecution = !lastMappingResult;
-    // Build the new mapping result
-    var newMappingResult = [];
-    var lastMappingResultIndex = 0;
-    var newMappingResultIndex = 0;
-    var nodesToDelete = [];
-    var itemsToProcess = [];
-    var itemsForBeforeRemoveCallbacks = [];
-    var itemsForMoveCallbacks = [];
-    var itemsForAfterAddCallbacks = [];
-    var mapData;
-    var countWaitingForRemove = 0;
-    function itemAdded(value) {
-        mapData = { arrayEntry: value, indexObservable: observable(newMappingResultIndex++) };
-        newMappingResult.push(mapData);
-        itemsToProcess.push(mapData);
-        if (!isFirstExecution) {
-            itemsForAfterAddCallbacks.push(mapData);
-        }
-    }
-    function itemMovedOrRetained(oldPosition) {
-        mapData = lastMappingResult[oldPosition];
-        if (newMappingResultIndex !== oldPosition) {
-            itemsForMoveCallbacks.push(mapData);
-        }
-        // Since updating the index might change the nodes, do so before calling fixUpContinuousNodeArray
-        mapData.indexObservable(newMappingResultIndex++);
-        fixUpContinuousNodeArray(mapData.mappedNodes, domNode);
-        newMappingResult.push(mapData);
-        itemsToProcess.push(mapData);
-    }
-    function callCallback(callback, items) {
-        if (callback) {
-            for (var i = 0, n = items.length; i < n; i++) {
-                arrayForEach(items[i].mappedNodes, function (node) {
-                    callback(node, i, items[i].arrayEntry);
-                });
-            }
-        }
-    }
-    if (isFirstExecution) {
-        arrayForEach(array, itemAdded);
-    }
-    else {
-        if (!editScript || (lastMappingResult && lastMappingResult['_countWaitingForRemove'])) {
-            // Compare the provided array against the previous one
-            var lastArray = isFirstExecution ? [] : arrayMap(lastMappingResult, function (x) { return x.arrayEntry; });
-            var compareOptions = {
-                'dontLimitMoves': options$$1['dontLimitMoves'],
-                'sparse': true
-            };
-            editScript = compareArrays(lastArray, array, compareOptions);
-        }
-        for (var i = 0, editScriptItem, movedIndex, itemIndex; editScriptItem = editScript[i]; i++) {
-            movedIndex = editScriptItem['moved'];
-            itemIndex = editScriptItem['index'];
-            switch (editScriptItem['status']) {
-                case 'deleted':
-                    while (lastMappingResultIndex < itemIndex) {
-                        itemMovedOrRetained(lastMappingResultIndex++);
-                    }
-                    if (movedIndex === undefined) {
-                        mapData = lastMappingResult[lastMappingResultIndex];
-                        // Stop tracking changes to the mapping for these nodes
-                        if (mapData.dependentObservable) {
-                            mapData.dependentObservable.dispose();
-                            mapData.dependentObservable = undefined;
-                        }
-                        // Queue these nodes for later removal
-                        if (fixUpContinuousNodeArray(mapData.mappedNodes, domNode).length) {
-                            if (options$$1['beforeRemove']) {
-                                newMappingResult.push(mapData);
-                                itemsToProcess.push(mapData);
-                                countWaitingForRemove++;
-                                if (mapData.arrayEntry === deletedItemDummyValue) {
-                                    mapData = null;
-                                }
-                                else {
-                                    itemsForBeforeRemoveCallbacks.push(mapData);
-                                }
-                            }
-                            if (mapData) {
-                                nodesToDelete.push.apply(nodesToDelete, mapData.mappedNodes);
-                            }
-                        }
-                    }
-                    lastMappingResultIndex++;
-                    break;
-                case 'added':
-                    while (newMappingResultIndex < itemIndex) {
-                        itemMovedOrRetained(lastMappingResultIndex++);
-                    }
-                    if (movedIndex !== undefined) {
-                        itemMovedOrRetained(movedIndex);
-                    }
-                    else {
-                        itemAdded(editScriptItem['value']);
-                    }
-                    break;
-            }
-        }
-        while (newMappingResultIndex < array.length) {
-            itemMovedOrRetained(lastMappingResultIndex++);
-        }
-        // Record that the current view may still contain deleted items
-        // because it means we won't be able to use a provided editScript.
-        newMappingResult['_countWaitingForRemove'] = countWaitingForRemove;
-    }
-    // Store a copy of the array items we just considered so we can difference it next time
-    domData.set(domNode, lastMappingResultDomDataKey, newMappingResult);
-    // Call beforeMove first before any changes have been made to the DOM
-    callCallback(options$$1['beforeMove'], itemsForMoveCallbacks);
-    // Next remove nodes for deleted items (or just clean if there's a beforeRemove callback)
-    arrayForEach(nodesToDelete, options$$1['beforeRemove'] ? cleanNode : removeNode);
-    // Next add/reorder the remaining items (will include deleted items if there's a beforeRemove callback)
-    i = 0;
-    for (var nextNode = virtualElements.firstChild(domNode), lastNode, node; mapData = itemsToProcess[i]; i++) {
-        // Get nodes for newly added items
-        if (!mapData.mappedNodes) {
-            extend(mapData, mapNodeAndRefreshWhenChanged(domNode, mapping, mapData.arrayEntry, callbackAfterAddingNodes, mapData.indexObservable));
-        }
-        // Put nodes in the right place if they aren't there already
-        for (var j = 0; node = mapData.mappedNodes[j]; nextNode = node.nextSibling, lastNode = node, j++) {
-            if (node !== nextNode) {
-                virtualElements.insertAfter(domNode, node, lastNode);
-            }
-        }
-        // Run the callbacks for newly added nodes (for example, to apply bindings, etc.)
-        if (!mapData.initialized && callbackAfterAddingNodes) {
-            callbackAfterAddingNodes(mapData.arrayEntry, mapData.mappedNodes, mapData.indexObservable);
-            mapData.initialized = true;
-        }
-    }
-    // If there's a beforeRemove callback, call it after reordering.
-    // Note that we assume that the beforeRemove callback will usually be used to remove the nodes using
-    // some sort of animation, which is why we first reorder the nodes that will be removed. If the
-    // callback instead removes the nodes right away, it would be more efficient to skip reordering them.
-    // Perhaps we'll make that change in the future if this scenario becomes more common.
-    callCallback(options$$1['beforeRemove'], itemsForBeforeRemoveCallbacks);
-    // Replace the stored values of deleted items with a dummy value. This provides two benefits: it marks this item
-    // as already "removed" so we won't call beforeRemove for it again, and it ensures that the item won't match up
-    // with an actual item in the array and appear as "retained" or "moved".
-    for (i = 0; i < itemsForBeforeRemoveCallbacks.length; ++i) {
-        itemsForBeforeRemoveCallbacks[i].arrayEntry = deletedItemDummyValue;
-    }
-    // Finally call afterMove and afterAdd callbacks
-    callCallback(options$$1['afterMove'], itemsForMoveCallbacks);
-    callCallback(options$$1['afterAdd'], itemsForAfterAddCallbacks);
-}
-
-/**
- * This DescendantBindingHandler is a base class for bindings that control
- * descendants, such as the `if`, `with`, `component`, `foreach` and `template`
- * bindings.
- */
-var DescendantBindingHandler = /** @class */ (function (_super) {
-    __extends(DescendantBindingHandler, _super);
-    function DescendantBindingHandler() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Object.defineProperty(DescendantBindingHandler.prototype, "controlsDescendants", {
-        get: function () { return true; },
-        enumerable: true,
-        configurable: true
-    });
-    DescendantBindingHandler.prototype.applyBindingsToDescendants = function (childContext, callback) {
-        return __awaiter(this, void 0, void 0, function () {
-            var bindingResult;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        bindingResult = applyBindingsToDescendants(childContext, this.$element);
-                        if (!bindingResult.isSync) return [3 /*break*/, 1];
-                        this.bindingCompletion = bindingResult;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, bindingResult.completionPromise];
-                    case 2:
-                        _a.sent();
-                        _a.label = 3;
-                    case 3:
-                        if (callback) {
-                            callback(bindingResult);
-                        }
-                        this.completeBinding(bindingResult);
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    return DescendantBindingHandler;
-}(AsyncBindingHandler));
-
-export { BindingHandler, AsyncBindingHandler, DescendantBindingHandler, bindingEvent, boundElementDomDataKey$1 as boundElementDomDataKey, contextSubscribeSymbol, bindingContext, storedBindingContextForNode, contextFor, dataFor, getBindingHandler, applyBindingAccessorsToNode, applyBindingsToNode, applyBindingsToDescendants, applyBindings, setDomNodeChildrenFromArrayMapping };
-//# sourceMappingURL=bind.js.map