@tko/bind 4.0.0-alpha8.4 → 4.0.0-beta1.3

package/dist/bind.es6.js

@@ -1,996 +0,0 @@
-/*!
- * TKO DOM-Observable Binding 🥊  @tko/bind@4.0.0-alpha8.4
- * (c) The Knockout.js Team - https://tko.io
- * License: MIT (http://www.opensource.org/licenses/mit-license.php)
- */
-
-import { domData, extend, options, anyDomNodeIsAttachedToDocument, virtualElements, objectMap, tagNameLower, objectForEach, arrayIndexOf, arrayForEach, fixUpContinuousNodeArray, replaceDomNodes, arrayPushAll, arrayMap, cleanNode, removeNode, compareArrays } from '@tko/utils';
-import { subscribable, unwrap, isObservable, isWriteableObservable, dependencyDetection, observable } from '@tko/observable';
-import { computed, pureComputed } from '@tko/computed';
-import { LifeCycle } from '@tko/lifecycle';
-
-const contextAncestorBindingInfo = Symbol('_ancestorBindingInfo');
-const boundElementDomDataKey = domData.nextKey();
-
-const bindingEvent = {
-  childrenComplete: 'childrenComplete',
-  descendantsComplete: 'descendantsComplete',
-
-  subscribe (node, event, callback, context) {
-    const bindingInfo = domData.getOrSet(node, boundElementDomDataKey, {});
-    if (!bindingInfo.eventSubscribable) {
-      bindingInfo.eventSubscribable = new subscribable();
-    }
-    return bindingInfo.eventSubscribable.subscribe(callback, context, event)
-  },
-
-  notify (node, event) {
-    const bindingInfo = domData.get(node, boundElementDomDataKey);
-    if (bindingInfo) {
-      if (bindingInfo.eventSubscribable) {
-        bindingInfo.eventSubscribable.notifySubscribers(node, event);
-      }
-    }
-  }
-};
-
-const boundElementDomDataKey$1 = domData.nextKey();
-
-const contextSubscribeSymbol = Symbol('Knockout Context Subscription');
-
-// Unique stub to indicate inheritance.
-const 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) {
-  const self = this;
-  const shouldInheritData = dataItemOrAccessor === inheritParentIndicator;
-  const realDataItemOrAccessor = shouldInheritData ? undefined : dataItemOrAccessor;
-  const 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;
-  let 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.
-    const dataItemOrObservable = isFunc ? realDataItemOrAccessor() : realDataItemOrAccessor;
-    let 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 (token, globals, node) {
-    // short circuits
-    switch (token) {
-      case '$element': return node
-      case '$context': return this
-      case 'this': case '$data': return this.$data
-    }
-    const $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 (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 (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 (dataItemOrAccessor, dataItemAlias) {
-    return this.createChildContext(dataItemOrAccessor, dataItemAlias, null, { 'exportDependencies': true })
-  }
-});
-
-function storedBindingContextForNode (node) {
-  const 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
-}
-
-class BindingResult {
-  constructor ({asyncBindingsApplied, rootNode, bindingContext}) {
-    Object.assign(this, {
-      rootNode,
-      bindingContext,
-      isSync: asyncBindingsApplied.size === 0,
-      isComplete: this.isSync
-    });
-
-    if (!this.isSync) {
-      this.completionPromise = this.completeWhenBindingsFinish(asyncBindingsApplied);
-    }
-  }
-
-  async completeWhenBindingsFinish (asyncBindingsApplied) {
-    await Promise.all(asyncBindingsApplied);
-    this.isComplete = true;
-    return this
-  }
-}
-
-class BindingHandler extends LifeCycle {
-  constructor (params) {
-    super();
-    const {$element, valueAccessor, allBindings, $context} = params;
-    Object.assign(this, {
-      valueAccessor,
-      allBindings,
-      $element,
-      $context,
-      $data: $context.$data
-    });
-
-    this.anchorTo($element);
-  }
-
-  get value () { return this.valueAccessor() }
-  set value (v) {
-    const va = this.valueAccessor();
-    if (isWriteableObservable(va)) {
-      va(v);
-    } else {
-      this.valueAccessor(v);
-    }
-  }
-
-  get controlsDescendants () { return false }
-
-  static get allowVirtualElements () { return false }
-  static get isBindingHandlerClass () { return true }
-
-  /* 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 bindingCompleted () { return true }
-
-  static registerAs (name, provider = options.bindingProviderInstance) {
-    provider.bindingHandlers.set(name, this);
-  }
-}
-
-/**
- * An AsyncBindingHandler shall call `completeBinding` when the binding
- * is to be considered complete.
- */
-const ResolveSymbol = Symbol('Async Binding Resolved');
-
-class AsyncBindingHandler extends BindingHandler {
-  constructor (params) {
-    super(params);
-    this.bindingCompletion = new Promise((resolve) => {
-      this[ResolveSymbol] = resolve;
-    });
-    this.completeBinding = bindingResult => this[ResolveSymbol](bindingResult);
-  }
-
-  get bindingCompleted () { return this.bindingCompletion }
-}
-
-/**
- * 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.
- */
-const PossibleWeakMap = options.global.WeakMap || Map;
-const legacyBindingMap = new PossibleWeakMap();
-
-class LegacyBindingHandler extends BindingHandler {
-  constructor (params) {
-    super(params);
-    const handler = this.handler;
-    this.onError = params.onError;
-
-    if (typeof handler.dispose === 'function') {
-      this.addDisposable(handler);
-    }
-
-    try {
-      this.initReturn = handler.init && handler.init(...this.legacyArgs);
-    } catch (e) {
-      params.onError('init', e);
-    }
-  }
-
-  onValueChange () {
-    const handler = this.handler;
-    if (typeof handler.update !== 'function') { return }
-    try {
-      handler.update(...this.legacyArgs);
-    } catch (e) {
-      this.onError('update', e);
-    }
-  }
-
-  get legacyArgs () {
-    return [
-      this.$element, this.valueAccessor, this.allBindings,
-      this.$data, this.$context
-    ]
-  }
-
-  get controlsDescendants () {
-    const objectToTest = this.initReturn || this.handler || {};
-    return objectToTest.controlsDescendantBindings
-  }
-
-  /**
-   * 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
-   */
-  static getOrCreateFor (key, handler) {
-    if (legacyBindingMap.has(handler)) {
-      return legacyBindingMap.get(handler)
-    }
-    const newLegacyHandler = this.createFor(key, handler);
-    legacyBindingMap.set(handler, newLegacyHandler);
-    return newLegacyHandler
-  }
-
-  static createFor (key, handler) {
-    if (typeof handler === 'function') {
-      const [initFn, disposeFn] = [handler, handler.dispose];
-      return class extends LegacyBindingHandler {
-        get handler () {
-          const init = initFn.bind(this);
-          const dispose = disposeFn ? disposeFn.bind(this) : null;
-          return { init, dispose }
-        }
-        static get after () { return handler.after }
-        static get allowVirtualElements () {
-          return handler.allowVirtualElements || virtualElements.allowedBindings[key]
-        }
-      }
-    }
-
-    if (typeof handler === 'object') {
-      return class extends LegacyBindingHandler {
-        get handler () { return handler }
-        static get after () { return handler.after }
-        static get allowVirtualElements () {
-          return handler.allowVirtualElements || virtualElements.allowedBindings[key]
-        }
-      }
-    }
-
-    throw new Error('The given handler is not an appropriate type.')
-  }
-}
-
-// The following element types will not be recursed into during binding.
-const 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) {
-  const 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) {
-  const 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) {
-  let nextInQueue = virtualElements.firstChild(elementOrVirtualElement);
-
-  if (!nextInQueue) { return }
-
-  let currentChild;
-  const provider = getBindingProvider();
-  const 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) {
-  const provider = getBindingProvider();
-  return isProviderForNode(provider, node) && provider.nodeHasBindings(node)
-}
-
-function nodeOrChildHasBindings (node) {
-  return hasBindings(node) || [...node.childNodes].some(c => 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)
-
-  let shouldApplyBindings = isElement || // Case (1)
-      hasBindings(nodeVerified);          // Case (2)
-
-  const { shouldBindDescendants } = shouldApplyBindings
-    ? applyBindingsToNodeInternal(nodeVerified, null, bindingContext$$1, asyncBindingsApplied)
-    : { shouldBindDescendants: true };
-
-  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) {
-  const results = [];
-  // Depth-first sort
-  const bindingsConsidered = {};    // A temporary record of which bindings are already in 'result'
-  const 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]) {
-      const 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;
-  });
-
-  for (const result of results) { yield result; }
-}
-
-function applyBindingsToNodeInternal (node, sourceBindings, bindingContext$$1, asyncBindingsApplied) {
-  const bindingInfo = domData.getOrSet(node, boundElementDomDataKey$1, {});
-  // Prevent multiple applyBindings calls for the same node, except when a binding value is specified
-  const 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 {
-    const provider = getBindingProvider();
-    const getBindings = provider.getBindingAccessors;
-
-    if (isProviderForNode(provider, 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.call(provider, 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) {
-    const $component = bindingContext$$1.$component || {};
-
-    const 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.
-    const getValueAccessor = bindingsUpdater
-            ? (bindingKey) => function (optionalValue) {
-              const valueAccessor = bindingsUpdater()[bindingKey];
-              if (arguments.length === 0) {
-                return evaluateValueAccessor(valueAccessor)
-              } else {
-                return valueAccessor(optionalValue)
-              }
-            } : (bindingKey) => 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 = (key) => key in bindings;
-    allBindings.get = (key) => bindings[key] && evaluateValueAccessor(getValueAccessor(key));
-
-    if (bindingEvent.childrenComplete in bindings) {
-      bindingEvent.subscribe(node, bindingEvent.childrenComplete, () => {
-        const callback = evaluateValueAccessor(bindings[bindingEvent.childrenComplete]);
-        if (!callback) { return }
-        const nodes = virtualElements.childNodes(node);
-        if (nodes.length) { callback(nodes, dataFor(nodes[0])); }
-      });
-    }
-
-    const bindingsGenerated = topologicalSortBindings(bindings, $component);
-    const nodeAsyncBindingPromises = new Set();
-    for (const [key, BindingHandlerClass] of bindingsGenerated) {
-        // Go through the sorted bindings, calling init and update for each
-      function reportBindingError (during, errorCaptured) {
-        onBindingError({
-          during,
-          errorCaptured,
-          bindings,
-          allBindings,
-          bindingKey: key,
-          bindingContext: bindingContext$$1,
-          element: node,
-          valueAccessor: getValueAccessor(key)
-        });
-      }
-
-      if (node.nodeType === 8 && !BindingHandlerClass.allowVirtualElements) {
-        throw new Error(`The binding '${key}' cannot be used with virtual elements`)
-      }
-
-      try {
-        const bindingHandler = dependencyDetection.ignore(() =>
-          new BindingHandlerClass({
-            allBindings,
-            $element: node,
-            $context: bindingContext$$1,
-            onError: reportBindingError,
-            valueAccessor (...v) { return getValueAccessor(key)(...v) }
-          })
-        );
-
-        if (bindingHandler.onValueChange) {
-          dependencyDetection.ignore(() =>
-            bindingHandler.computed('onValueChange')
-          );
-        }
-
-        // Expose the bindings via domData.
-        allBindingHandlers[key] = bindingHandler;
-
-        if (bindingHandler.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.bindingCompleted instanceof Promise) {
-          asyncBindingsApplied.add(bindingHandler.bindingCompleted);
-          nodeAsyncBindingPromises.add(bindingHandler.bindingCompleted);
-        }
-      } catch (err) {
-        reportBindingError('creation', err);
-      }
-    }
-
-    triggerDescendantsComplete(node, bindings, nodeAsyncBindingPromises);
-  }
-
-  const shouldBindDescendants = bindingHandlerThatControlsDescendantBindings === undefined;
-  return { 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. */
-  const hasBindingHandler = bindingEvent.descendantsComplete in bindings;
-  const hasFirstChild = virtualElements.firstChild(node);
-  const accessor = hasBindingHandler && evaluateValueAccessor(bindings[bindingEvent.descendantsComplete]);
-  const callback = () => {
-    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) {
-  const asyncBindingsApplied = new Set();
-  const bindingContext$$1 = getBindingContext(viewModelOrBindingContext);
-  const bindingAccessors = getBindingProvider().makeBindingAccessors(bindings, bindingContext$$1, node);
-  applyBindingAccessorsToNode(node, bindingAccessors, bindingContext$$1, asyncBindingsApplied);
-  return new BindingResult({asyncBindingsApplied, rootNode: node, bindingContext: bindingContext$$1})
-}
-
-function applyBindingsToDescendants (viewModelOrBindingContext, rootNode) {
-  const asyncBindingsApplied = new Set();
-  if (rootNode.nodeType === 1 || rootNode.nodeType === 8) {
-    const bindingContext$$1 = getBindingContext(viewModelOrBindingContext);
-    applyBindingsToDescendantsInternal(bindingContext$$1, rootNode, asyncBindingsApplied);
-    return new BindingResult({asyncBindingsApplied, rootNode, bindingContext: bindingContext$$1})
-  }
-  return new BindingResult({asyncBindingsApplied, rootNode})
-}
-
-function applyBindings (viewModelOrBindingContext, rootNode, extendContextCallback) {
-  const 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')
-  }
-  const 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();
-let 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 || {};
-  let lastMappingResult = domData.get(domNode, lastMappingResultDomDataKey);
-  let 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;
-  let 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.
- */
-class DescendantBindingHandler extends AsyncBindingHandler {
-  get controlsDescendants () { return true }
-
-  async applyBindingsToDescendants (childContext, callback) {
-    const bindingResult = applyBindingsToDescendants(childContext, this.$element);
-    if (bindingResult.isSync) {
-      this.bindingCompletion = bindingResult;
-    } else {
-      await bindingResult.completionPromise;
-    }
-    if (callback) { callback(bindingResult); }
-    this.completeBinding(bindingResult);
-  }
-}
-
-export { BindingHandler, AsyncBindingHandler, DescendantBindingHandler, bindingEvent, boundElementDomDataKey$1 as boundElementDomDataKey, contextSubscribeSymbol, bindingContext, storedBindingContextForNode, contextFor, dataFor, getBindingHandler, applyBindingAccessorsToNode, applyBindingsToNode, applyBindingsToDescendants, applyBindings, setDomNodeChildrenFromArrayMapping };
-//# sourceMappingURL=bind.es6.js.map