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

package/dist/binding.core.es6.js

@@ -1,1044 +0,0 @@
-/*!
- * TKO Core bindings 🥊  @tko/binding.core@4.0.0-alpha9.0
- * (c) The Knockout.js Team - https://tko.io
- * License: MIT (http://www.opensource.org/licenses/mit-license.php)
- */
-
-import { setElementName, objectForEach, registerEventHandler, arrayIndexOf, addOrRemoveItem, throttle, debounce, createSymbolOrString, toggleDomNodeCssClass, stringTrim, triggerEvent, setHtml, tagNameLower, arrayFilter, arrayMap, setTextContent, setOptionNodeSelectionState, domData, ensureSelectElementIsRenderedCorrectly, selectExtensions, arrayForEach, options, ieVersion, safeSetTimeout, stringStartsWith } from '@tko/utils';
-import { unwrap, dependencyDetection, isWriteableObservable } from '@tko/observable';
-import { computed, pureComputed } from '@tko/computed';
-import { BindingHandler, applyBindingsToDescendants, setDomNodeChildrenFromArrayMapping, applyBindingAccessorsToNode } from '@tko/bind';
-
-var attr = {
-  update: function (element, valueAccessor, allBindings) {
-    var value = unwrap(valueAccessor()) || {};
-    objectForEach(value, function (attrName, attrValue) {
-      attrValue = unwrap(attrValue);
-
-      // Find the namespace of this attribute, if any.
-      var prefixLen = attrName.indexOf(':');
-      var namespace = prefixLen > 0 && element.lookupNamespaceURI(attrName.substr(0, prefixLen));
-
-      // To cover cases like "attr: { checked:someProp }", we want to remove the attribute entirely
-      // when someProp is a "no value"-like value (strictly null, false, or undefined)
-      // (because the absence of the "checked" attr is how to mark an element as not checked, etc.)
-      const toRemove = attrValue === false || attrValue === null || attrValue === undefined;
-
-      if (toRemove) {
-        if (namespace) {
-          element.removeAttributeNS(namespace, attrName);
-        } else {
-          element.removeAttribute(attrName);
-        }
-      } else {
-        attrValue = attrValue.toString();
-        if (namespace) {
-          element.setAttributeNS(namespace, attrName, attrValue);
-        } else {
-          element.setAttribute(attrName, attrValue);
-        }
-      }
-
-      // Treat "name" specially - although you can think of it as an attribute, it also needs
-      // special handling on older versions of IE (https://github.com/SteveSanderson/knockout/pull/333)
-      // Deliberately being case-sensitive here because XHTML would regard "Name" as a different thing
-      // entirely, and there's no strong reason to allow for such casing in HTML.
-      if (attrName === 'name') {
-        setElementName(element, toRemove ? '' : attrValue);
-      }
-    });
-  }
-};
-
-var checked = {
-  after: ['value', 'attr'],
-  init: function (element, valueAccessor, allBindings) {
-    var checkedValue = pureComputed(function () {
-      // Treat "value" like "checkedValue" when it is included with "checked" binding
-      if (allBindings.has('checkedValue')) {
-        return unwrap(allBindings.get('checkedValue'))
-      } else if (useElementValue) {
-        if (allBindings.has('value')) {
-          return unwrap(allBindings.get('value'))
-        } else {
-          return element.value
-        }
-      }
-    });
-
-    function updateModel () {
-      // This updates the model value from the view value.
-      // It runs in response to DOM events (click) and changes in checkedValue.
-      var isChecked = element.checked,
-        elemValue = checkedValue();
-
-      // When we're first setting up this computed, don't change any model state.
-      if (dependencyDetection.isInitial()) {
-        return
-      }
-
-      // We can ignore unchecked radio buttons, because some other radio
-      // button will be checked, and that one can take care of updating state.
-      // button will be checked, and that one can take care of updating state
-      if (!isChecked && (isRadio || dependencyDetection.getDependenciesCount())) {
-        return
-      }
-
-      var modelValue = dependencyDetection.ignore(valueAccessor);
-      if (valueIsArray) {
-        var writableValue = rawValueIsNonArrayObservable ? modelValue.peek() : modelValue,
-          saveOldValue = oldElemValue;
-        oldElemValue = elemValue;
-
-        if (saveOldValue !== elemValue) {
-          // When we're responding to the checkedValue changing, and the element is
-          // currently checked, replace the old elem value with the new elem value
-          // in the model array.
-          if (isChecked) {
-            addOrRemoveItem(writableValue, elemValue, true);
-            addOrRemoveItem(writableValue, saveOldValue, false);
-          }
-
-          oldElemValue = elemValue;
-        } else {
-          // When we're responding to the user having checked/unchecked a checkbox,
-          // add/remove the element value to the model array.
-          addOrRemoveItem(writableValue, elemValue, isChecked);
-        }
-        if (rawValueIsNonArrayObservable && isWriteableObservable(modelValue)) {
-          modelValue(writableValue);
-        }
-      } else {
-        if (isCheckbox) {
-          if (elemValue === undefined) {
-            elemValue = isChecked;
-          } else if (!isChecked) {
-            elemValue = undefined;
-          }
-        }
-        valueAccessor(elemValue, {onlyIfChanged: true});
-      }
-    }
-    function updateView () {
-            // This updates the view value from the model value.
-            // It runs in response to changes in the bound (checked) value.
-      var modelValue = modelValue = unwrap(valueAccessor());
-      var elemValue = checkedValue();
-
-      if (valueIsArray) {
-                // When a checkbox is bound to an array, being checked represents its value being present in that array
-        element.checked = arrayIndexOf(modelValue, elemValue) >= 0;
-        oldElemValue = elemValue;
-      } else if (isCheckbox && elemValue === undefined) {
-                                 // When a checkbox is bound to any other value (not an array) and "checkedValue" is not defined,
-                                 // being checked represents the value being trueish
-        element.checked = !!modelValue;
-      } else {
-        // Otherwise, being checked means that the checkbox or radio button's value corresponds to the model value
-        element.checked = (checkedValue() === modelValue);
-      }
-    }
-    var isCheckbox = element.type == 'checkbox',
-      isRadio = element.type == 'radio';
-
-        // Only bind to check boxes and radio buttons
-    if (!isCheckbox && !isRadio) {
-      return
-    }
-
-    var rawValue = valueAccessor(),
-      valueIsArray = isCheckbox && (unwrap(rawValue) instanceof Array),
-      rawValueIsNonArrayObservable = !(valueIsArray && rawValue.push && rawValue.splice),
-      useElementValue = isRadio || valueIsArray,
-      oldElemValue = valueIsArray ? checkedValue() : undefined;
-
-        // Set up two computeds to update the binding:
-
-        // The first responds to changes in the checkedValue value and to element clicks
-    computed(updateModel, null, { disposeWhenNodeIsRemoved: element });
-    registerEventHandler(element, 'click', updateModel);
-
-        // The second responds to changes in the model value (the one associated with the checked binding)
-    computed(updateView, null, { disposeWhenNodeIsRemoved: element });
-
-    rawValue = undefined;
-  }
-};
-
-var checkedValue = {
-  update: function (element, valueAccessor) {
-    element.value = unwrap(valueAccessor());
-  }
-};
-
-// For certain common events (currently just 'click'), allow a simplified data-binding syntax
-// e.g. click:handler instead of the usual full-length event:{click:handler}
-function makeEventHandlerShortcut (eventName) {
-  return {
-    init: function (element, valueAccessor, allBindings, viewModel, bindingContext) {
-      var newValueAccessor = function () {
-        var result = {};
-        result[eventName] = valueAccessor();
-        return result
-      };
-      eventHandler.init.call(this, element, newValueAccessor, allBindings, viewModel, bindingContext);
-    }
-  }
-}
-
-function makeDescriptor (handlerOrObject) {
-  return typeof handlerOrObject === 'function' ? { handler: handlerOrObject } : handlerOrObject || {}
-}
-
-const eventHandler = {
-  init: function (element, valueAccessor, allBindings, viewModel, bindingContext) {
-    var eventsToHandle = valueAccessor() || {};
-    objectForEach(eventsToHandle, function (eventName, descriptor) {
-      const {passive, capture, once, debounce: debounce$$1, throttle: throttle$$1} = makeDescriptor(descriptor);
-      const eventOptions = (capture || passive || once) && {capture, passive, once};
-
-      let eventHandlerFn = (event, ...more) => {
-        var handlerReturnValue;
-        const {handler, passive, bubble} = makeDescriptor(valueAccessor()[eventName]);
-
-        try {
-          // Take all the event args, and prefix with the viewmodel
-          if (handler) {
-            const possiblyUpdatedViewModel = bindingContext.$data;
-            const argsForHandler = [possiblyUpdatedViewModel, event, ...more];
-            handlerReturnValue = handler.apply(possiblyUpdatedViewModel, argsForHandler);
-          }
-        } finally {
-          if (handlerReturnValue !== true) {
-            // Normally we want to prevent default action. Developer can override this be explicitly returning true.
-            // preventDefault will throw an error if the event is passive.
-            if (event.preventDefault) {
-              if (!passive) { event.preventDefault(); }
-            } else {
-              event.returnValue = false;
-            }
-          }
-        }
-
-        const bubbleMark = allBindings.get(eventName + 'Bubble') !== false;
-        if (bubble === false || !bubbleMark) {
-          event.cancelBubble = true;
-          if (event.stopPropagation) { event.stopPropagation(); }
-        }
-      };
-
-      if (debounce$$1) { eventHandlerFn = debounce(eventHandlerFn, debounce$$1); }
-      if (throttle$$1) { eventHandlerFn = throttle(eventHandlerFn, throttle$$1); }
-
-      registerEventHandler(element, eventName, eventHandlerFn, eventOptions || false);
-    });
-  }
-};
-
-const onHandler = {
-  init: eventHandler.init,
-  preprocess: function (value, key, addBinding) {
-    addBinding(key.replace('on.', ''), '=>' + value);
-  }
-};
-
-// 'click' is just a shorthand for the usual full-length event:{click:handler}
-var click = makeEventHandlerShortcut('click');
-
-var css = {
-  aliases: ['class'],
-  update: function (element, valueAccessor) {
-    var value = unwrap(valueAccessor());
-    if (value !== null && typeof value === 'object') {
-      objectForEach(value, function (className, shouldHaveClass) {
-        shouldHaveClass = unwrap(shouldHaveClass);
-        toggleDomNodeCssClass(element, className, shouldHaveClass);
-      });
-    } else {
-      value = stringTrim(String(value || '')); // Make sure we don't try to store or set a non-string value
-      toggleDomNodeCssClass(element, element[css.classesWrittenByBindingKey], false);
-      element[css.classesWrittenByBindingKey] = value;
-      toggleDomNodeCssClass(element, value, true);
-    }
-  },
-  classesWrittenByBindingKey: createSymbolOrString('__ko__cssValue')
-};
-
-/**
- * A simple callback binding.
- */
-
-class DescendantsCompleteHandler extends BindingHandler {
-  onDescendantsComplete () {
-    if (typeof this.value === 'function') {
-      this.value(this.$element);
-    }
-  }
-
-  static get allowVirtualElements () { return true }
-}
-
-var enable = {
-  update: function (element, valueAccessor) {
-    var value = unwrap(valueAccessor());
-    if (value && element.disabled) {
-      element.removeAttribute('disabled');
-    } else if ((!value) && (!element.disabled)) {
-      element.disabled = true;
-    }
-  }
-};
-
-var disable = {
-  update: function (element, valueAccessor) {
-    enable.update(element, function () { return !unwrap(valueAccessor()) });
-  }
-};
-
-var hasfocusUpdatingProperty = createSymbolOrString('__ko_hasfocusUpdating');
-var hasfocusLastValue = createSymbolOrString('__ko_hasfocusLastValue');
-
-var hasfocus = {
-  init: function (element, valueAccessor /*, allBindings */) {
-    var handleElementFocusChange = function (isFocused) {
-            // Where possible, ignore which event was raised and determine focus state using activeElement,
-            // as this avoids phantom focus/blur events raised when changing tabs in modern browsers.
-            // However, not all KO-targeted browsers (Firefox 2) support activeElement. For those browsers,
-            // prevent a loss of focus when changing tabs/windows by setting a flag that prevents hasfocus
-            // from calling 'blur()' on the element when it loses focus.
-            // Discussion at https://github.com/SteveSanderson/knockout/pull/352
-      element[hasfocusUpdatingProperty] = true;
-      var ownerDoc = element.ownerDocument;
-      if ('activeElement' in ownerDoc) {
-        var active;
-        try {
-          active = ownerDoc.activeElement;
-        } catch (e) {
-                    // IE9 throws if you access activeElement during page load (see issue #703)
-          active = ownerDoc.body;
-        }
-        isFocused = (active === element);
-      }
-            // var modelValue = valueAccessor();
-      valueAccessor(isFocused, {onlyIfChanged: true});
-
-            // cache the latest value, so we can avoid unnecessarily calling focus/blur in the update function
-      element[hasfocusLastValue] = isFocused;
-      element[hasfocusUpdatingProperty] = false;
-    };
-    var handleElementFocusIn = handleElementFocusChange.bind(null, true);
-    var handleElementFocusOut = handleElementFocusChange.bind(null, false);
-
-    registerEventHandler(element, 'focus', handleElementFocusIn);
-    registerEventHandler(element, 'focusin', handleElementFocusIn); // For IE
-    registerEventHandler(element, 'blur', handleElementFocusOut);
-    registerEventHandler(element, 'focusout', handleElementFocusOut); // For IE
-  },
-  update: function (element, valueAccessor) {
-    var value = !!unwrap(valueAccessor());
-
-    if (!element[hasfocusUpdatingProperty] && element[hasfocusLastValue] !== value) {
-      value ? element.focus() : element.blur();
-
-            // In IE, the blur method doesn't always cause the element to lose focus (for example, if the window is not in focus).
-            // Setting focus to the body element does seem to be reliable in IE, but should only be used if we know that the current
-            // element was focused already.
-      if (!value && element[hasfocusLastValue]) {
-        element.ownerDocument.body.focus();
-      }
-
-            // For IE, which doesn't reliably fire "focus" or "blur" events synchronously
-      dependencyDetection.ignore(triggerEvent, null, [element, value ? 'focusin' : 'focusout']);
-    }
-  }
-};
-
-var html = {
-  init: function () {
-        // Prevent binding on the dynamically-injected HTML (as developers are unlikely to expect that, and it has security implications)
-    return {
-      'controlsDescendantBindings': true
-    }
-  },
-    //
-    // Modify internal, per ko.punches and :
-    //      http://stackoverflow.com/a/15348139
-  update: function (element, valueAccessor) {
-    setHtml(element, valueAccessor());
-  },
-  allowVirtualElements: true
-};
-
-var $let = {
-  init: function (element, valueAccessor, allBindings, viewModel, bindingContext) {
-        // Make a modified binding context, with extra properties, and apply it to descendant elements
-    var innerContext = bindingContext['extend'](valueAccessor);
-    applyBindingsToDescendants(innerContext, element);
-
-    return { 'controlsDescendantBindings': true }
-  },
-  allowVirtualElements: true
-}
-
-var captionPlaceholder = {};
-
-var options$1 = {
-  init: function (element) {
-    if (tagNameLower(element) !== 'select') { throw new Error('options binding applies only to SELECT elements') }
-
-        // Remove all existing <option>s.
-    while (element.length > 0) {
-      element.remove(0);
-    }
-
-        // Ensures that the binding processor doesn't try to bind the options
-    return { 'controlsDescendantBindings': true }
-  },
-  update: function (element, valueAccessor, allBindings) {
-    function selectedOptions () {
-      return arrayFilter(element.options, function (node) { return node.selected })
-    }
-
-    var selectWasPreviouslyEmpty = element.length == 0,
-      multiple = element.multiple,
-      previousScrollTop = (!selectWasPreviouslyEmpty && multiple) ? element.scrollTop : null,
-      unwrappedArray = unwrap(valueAccessor()),
-      valueAllowUnset = allBindings.get('valueAllowUnset') && allBindings['has']('value'),
-      includeDestroyed = allBindings.get('optionsIncludeDestroyed'),
-      arrayToDomNodeChildrenOptions = {},
-      captionValue,
-      filteredArray,
-      previousSelectedValues = [];
-
-    if (!valueAllowUnset) {
-      if (multiple) {
-        previousSelectedValues = arrayMap(selectedOptions(), selectExtensions.readValue);
-      } else if (element.selectedIndex >= 0) {
-        previousSelectedValues.push(selectExtensions.readValue(element.options[element.selectedIndex]));
-      }
-    }
-
-    if (unwrappedArray) {
-      if (typeof unwrappedArray.length === 'undefined') // Coerce single value into array
-        { unwrappedArray = [unwrappedArray]; }
-
-            // Filter out any entries marked as destroyed
-      filteredArray = arrayFilter(unwrappedArray, function (item) {
-        return includeDestroyed || item === undefined || item === null || !unwrap(item['_destroy'])
-      });
-
-            // If caption is included, add it to the array
-      if (allBindings['has']('optionsCaption')) {
-        captionValue = unwrap(allBindings.get('optionsCaption'));
-                // If caption value is null or undefined, don't show a caption
-        if (captionValue !== null && captionValue !== undefined) {
-          filteredArray.unshift(captionPlaceholder);
-        }
-      }
-    }
-
-    function applyToObject (object, predicate, defaultValue) {
-      var predicateType = typeof predicate;
-      if (predicateType == 'function')    // Given a function; run it against the data value
-              { return predicate(object) } else if (predicateType == 'string') // Given a string; treat it as a property name on the data value
-              { return object[predicate] } else                                // Given no optionsText arg; use the data value itself
-                { return defaultValue }
-    }
-
-        // The following functions can run at two different times:
-        // The first is when the whole array is being updated directly from this binding handler.
-        // The second is when an observable value for a specific array entry is updated.
-        // oldOptions will be empty in the first case, but will be filled with the previously generated option in the second.
-    var itemUpdate = false;
-    function optionForArrayItem (arrayEntry, index, oldOptions) {
-      if (oldOptions.length) {
-        previousSelectedValues = !valueAllowUnset && oldOptions[0].selected ? [ selectExtensions.readValue(oldOptions[0]) ] : [];
-        itemUpdate = true;
-      }
-      var option = element.ownerDocument.createElement('option');
-      if (arrayEntry === captionPlaceholder) {
-        setTextContent(option, allBindings.get('optionsCaption'));
-        selectExtensions.writeValue(option, undefined);
-      } else {
-                // Apply a value to the option element
-        var optionValue = applyToObject(arrayEntry, allBindings.get('optionsValue'), arrayEntry);
-        selectExtensions.writeValue(option, unwrap(optionValue));
-
-                // Apply some text to the option element
-        var optionText = applyToObject(arrayEntry, allBindings.get('optionsText'), optionValue);
-        setTextContent(option, optionText);
-      }
-      return [option]
-    }
-
-        // By using a beforeRemove callback, we delay the removal until after new items are added. This fixes a selection
-        // problem in IE<=8 and Firefox. See https://github.com/knockout/knockout/issues/1208
-    arrayToDomNodeChildrenOptions['beforeRemove'] =
-            function (option) {
-              element.removeChild(option);
-            };
-
-    function setSelectionCallback (arrayEntry, newOptions) {
-      if (itemUpdate && valueAllowUnset) {
-                // The model value is authoritative, so make sure its value is the one selected
-                // There is no need to use dependencyDetection.ignore since setDomNodeChildrenFromArrayMapping does so already.
-        selectExtensions.writeValue(element, unwrap(allBindings.get('value')), true /* allowUnset */);
-      } else if (previousSelectedValues.length) {
-                // IE6 doesn't like us to assign selection to OPTION nodes before they're added to the document.
-                // That's why we first added them without selection. Now it's time to set the selection.
-        var isSelected = arrayIndexOf(previousSelectedValues, selectExtensions.readValue(newOptions[0])) >= 0;
-        setOptionNodeSelectionState(newOptions[0], isSelected);
-
-                // If this option was changed from being selected during a single-item update, notify the change
-        if (itemUpdate && !isSelected) {
-          dependencyDetection.ignore(triggerEvent, null, [element, 'change']);
-        }
-      }
-    }
-
-    var callback = setSelectionCallback;
-    if (allBindings['has']('optionsAfterRender') && typeof allBindings.get('optionsAfterRender') === 'function') {
-      callback = function (arrayEntry, newOptions) {
-        setSelectionCallback(arrayEntry, newOptions);
-        dependencyDetection.ignore(allBindings.get('optionsAfterRender'), null, [newOptions[0], arrayEntry !== captionPlaceholder ? arrayEntry : undefined]);
-      };
-    }
-
-    setDomNodeChildrenFromArrayMapping(element, filteredArray, optionForArrayItem, arrayToDomNodeChildrenOptions, callback);
-
-    dependencyDetection.ignore(function () {
-      if (valueAllowUnset) {
-                // The model value is authoritative, so make sure its value is the one selected
-        selectExtensions.writeValue(element, unwrap(allBindings.get('value')), true /* allowUnset */);
-      } else {
-                // Determine if the selection has changed as a result of updating the options list
-        var selectionChanged;
-        if (multiple) {
-                    // For a multiple-select box, compare the new selection count to the previous one
-                    // But if nothing was selected before, the selection can't have changed
-          selectionChanged = previousSelectedValues.length && selectedOptions().length < previousSelectedValues.length;
-        } else {
-                    // For a single-select box, compare the current value to the previous value
-                    // But if nothing was selected before or nothing is selected now, just look for a change in selection
-          selectionChanged = (previousSelectedValues.length && element.selectedIndex >= 0)
-                        ? (selectExtensions.readValue(element.options[element.selectedIndex]) !== previousSelectedValues[0])
-                        : (previousSelectedValues.length || element.selectedIndex >= 0);
-        }
-
-                // Ensure consistency between model value and selected option.
-                // If the dropdown was changed so that selection is no longer the same,
-                // notify the value or selectedOptions binding.
-        if (selectionChanged) {
-          triggerEvent(element, 'change');
-        }
-      }
-    });
-
-        // Workaround for IE bug
-    ensureSelectElementIsRenderedCorrectly(element);
-
-    if (previousScrollTop && Math.abs(previousScrollTop - element.scrollTop) > 20) { element.scrollTop = previousScrollTop; }
-  }
-};
-
-var selectedOptions = {
-  after: ['options', 'foreach'],
-
-  init: function (element, valueAccessor, allBindings) {
-    registerEventHandler(element, 'change', function () {
-      var value = valueAccessor(), valueToWrite = [];
-      arrayForEach(element.getElementsByTagName('option'), function (node) {
-        if (node.selected) { valueToWrite.push(selectExtensions.readValue(node)); }
-      });
-      valueAccessor(valueToWrite);
-    });
-  },
-
-  update: function (element, valueAccessor) {
-    if (tagNameLower(element) != 'select') { throw new Error('values binding applies only to SELECT elements') }
-
-    var newValue = unwrap(valueAccessor()),
-      previousScrollTop = element.scrollTop;
-
-    if (newValue && typeof newValue.length === 'number') {
-      arrayForEach(element.getElementsByTagName('option'), function (node) {
-        var isSelected = arrayIndexOf(newValue, selectExtensions.readValue(node)) >= 0;
-        if (node.selected != isSelected) {      // This check prevents flashing of the select element in IE
-          setOptionNodeSelectionState(node, isSelected);
-        }
-      });
-    }
-
-    element.scrollTop = previousScrollTop;
-  }
-};
-
-const {jQueryInstance} = options;
-
-var style = {
-  update: function (element, valueAccessor) {
-    var value = unwrap(valueAccessor() || {});
-    objectForEach(value, function (styleName, styleValue) {
-      styleValue = unwrap(styleValue);
-
-      if (styleValue === null || styleValue === undefined || styleValue === false) {
-        // Empty string removes the value, whereas null/undefined have no effect
-        styleValue = '';
-      }
-
-      if (jQueryInstance) {
-        jQueryInstance(element).css(styleName, styleValue);
-      } else {
-        styleName = styleName.replace(/-(\w)/g, (all, letter) => letter.toUpperCase());
-        const previousStyle = element.style[styleName];
-        element.style[styleName] = styleValue;
-        if (styleValue !== previousStyle && element.style[styleName] === previousStyle && !isNaN(styleValue)) {
-          element.style[styleName] = styleValue + 'px';
-        }
-      }
-    });
-  }
-};
-
-var submit = {
-  init: function (element, valueAccessor, allBindings, viewModel, bindingContext) {
-    if (typeof valueAccessor() !== 'function') { throw new Error('The value for a submit binding must be a function') }
-    registerEventHandler(element, 'submit', function (event) {
-      var handlerReturnValue;
-      var value = valueAccessor();
-      try { handlerReturnValue = value.call(bindingContext['$data'], element); } finally {
-        if (handlerReturnValue !== true) { // Normally we want to prevent default action. Developer can override this be explicitly returning true.
-          if (event.preventDefault) { event.preventDefault(); } else { event.returnValue = false; }
-        }
-      }
-    });
-  }
-};
-
-var text = {
-  init: function () {
-    // Prevent binding on the dynamically-injected text node (as developers are unlikely to expect that, and it has security implications).
-    // It should also make things faster, as we no longer have to consider whether the text node might be bindable.
-    return { controlsDescendantBindings: true }
-  },
-  update: function (element, valueAccessor) {
-    setTextContent(element, valueAccessor());
-  },
-  allowVirtualElements: true
-};
-
-var operaVersion, safariVersion, firefoxVersion;
-
-
-/**
- * TextInput binding handler for modern browsers (legacy below).
- * @extends BindingHandler
- */
-class TextInput extends BindingHandler {
-  get aliases () { return 'textinput' }
-
-  constructor (...args) {
-    super(...args);
-    this.previousElementValue = this.$element.value;
-
-    if (options.debug && this.constructor._forceUpdateOn) {
-      // Provide a way for tests to specify exactly which events are bound
-      arrayForEach(this.constructor._forceUpdateOn, (eventName) => {
-        if (eventName.slice(0, 5) === 'after') {
-          this.addEventListener(eventName.slice(5), 'deferUpdateModel');
-        } else {
-          this.addEventListener(eventName, 'updateModel');
-        }
-      });
-    }
-
-    for (const eventName of this.eventsIndicatingSyncValueChange()) {
-      this.addEventListener(eventName, 'updateModel');
-    }
-    for (const eventName of this.eventsIndicatingDeferValueChange()) {
-      this.addEventListener(eventName, 'deferUpdateModel');
-    }
-    this.computed('updateView');
-  }
-
-  eventsIndicatingSyncValueChange () {
-    // input: Default, modern handler
-    // change: Catch programmatic updates of the value that fire this event.
-    // blur: To deal with browsers that don't notify any kind of event for some changes (IE, Safari, etc.)
-    return ['input', 'change', 'blur']
-  }
-
-  eventsIndicatingDeferValueChange () {
-    return []
-  }
-
-  updateModel (event) {
-    const element = this.$element;
-    clearTimeout(this.timeoutHandle);
-    this.elementValueBeforeEvent = this.timeoutHandle = undefined;
-    const elementValue = element.value;
-    if (this.previousElementValue !== elementValue) {
-              // Provide a way for tests to know exactly which event was processed
-      if (options.debug && event) {
-        element._ko_textInputProcessedEvent = event.type;
-      }
-      this.previousElementValue = elementValue;
-      this.value = elementValue;
-    }
-  }
-
-  deferUpdateModel (event) {
-    const element = this.$element;
-    if (!this.timeoutHandle) {
-      // The elementValueBeforeEvent variable is set *only* during the brief gap between an
-      // event firing and the updateModel function running. This allows us to ignore model
-      // updates that are from the previous state of the element, usually due to techniques
-      // such as rateLimit. Such updates, if not ignored, can cause keystrokes to be lost.
-      this.elementValueBeforeEvent = element.value;
-      const handler = options.debug ? this.updateModel.bind(this, { type: event.type }) : this.updateModel;
-      this.timeoutHandle = safeSetTimeout(handler, 4);
-    }
-  }
-
-  updateView () {
-    let modelValue = unwrap(this.value);
-    if (modelValue === null || modelValue === undefined) {
-      modelValue = '';
-    }
-    if (this.elementValueBeforeEvent !== undefined
-               && modelValue === this.elementValueBeforeEvent) {
-      setTimeout(this.updateView.bind(this), 4);
-    } else if (this.$element.value !== modelValue) {
-      // Update the element only if the element and model are different. On some browsers, updating the value
-      // will move the cursor to the end of the input, which would be bad while the user is typing.
-      this.previousElementValue = modelValue; // Make sure we ignore events (propertychange) that result from updating the value
-      this.$element.value = modelValue;
-      this.previousElementValue = this.$element.value; // In case the browser changes the value (see #2281)
-    }
-  }
-}
-
-/**
- * Legacy Input Classes, below
- */
-class TextInputIE extends TextInput {
-  constructor (...args) {
-    super(...args);
-
-    if (ieVersion < 11) {
-      // Internet Explorer <= 8 doesn't support the 'input' event, but does include 'propertychange' that fires whenever
-      // any property of an element changes. Unlike 'input', it also fires if a property is changed from JavaScript code,
-      // but that's an acceptable compromise for this binding. IE 9 and 10 support 'input', but since they don't always
-      // fire it when using autocomplete, we'll use 'propertychange' for them also.
-      this.addEventListener('propertychange', event =>
-        event.propertyName === 'value' && this.updateModel(event)
-      );
-    }
-
-    if (ieVersion >= 8 && ieVersion < 10) {
-      this.watchForSelectionChangeEvent();
-      this.addEventListener('dragend', 'deferUpdateModel');
-    }
-  }
-
-  eventsIndicatingSyncValueChange () {
-    // keypress: All versions (including 11) of Internet Explorer have a bug that they don't generate an input or propertychange event when ESC is pressed
-    return [...super.eventsIndicatingValueChange(), 'keypress']
-  }
-
-  // IE 8 and 9 have bugs that prevent the normal events from firing when the value changes.
-  // But it does fire the 'selectionchange' event on many of those, presumably because the
-  // cursor is moving and that counts as the selection changing. The 'selectionchange' event is
-  // fired at the document level only and doesn't directly indicate which element changed. We
-  // set up just one event handler for the document and use 'activeElement' to determine which
-  // element was changed.
-  selectionChangeHandler (event) {
-      const target = this.activeElement;
-      const handler = target && domData.get(target, selectionChangeHandlerName);
-      if (handler) { handler(event); }
-  }
-
-  watchForSelectionChangeEvent (element, ieUpdateModel) {
-    const ownerDoc = element.ownerDocument;
-    if (!domData.get(ownerDoc, selectionChangeRegisteredName)) {
-        domData.set(ownerDoc, selectionChangeRegisteredName, true);
-        registerEventHandler(ownerDoc, 'selectionchange', this.selectionChangeHandler.bind(ownerDoc));
-    }
-    domData.set(element, selectionChangeHandlerName, handler);
-  }
-}
-
-
-// IE 8 and 9 have bugs that prevent the normal events from firing when the value changes.
-// But it does fire the 'selectionchange' event on many of those, presumably because the
-// cursor is moving and that counts as the selection changing. The 'selectionchange' event is
-// fired at the document level only and doesn't directly indicate which element changed. We
-// set up just one event handler for the document and use 'activeElement' to determine which
-// element was changed.
-class TextInputIE9 extends TextInputIE {
-  updateModel (...args) {
-    // IE9 will mess up the DOM if you handle events synchronously which results in DOM changes (such as other bindings);
-    // so we'll make sure all updates are asynchronous
-    this.deferUpdateModel(...args);
-  }
-}
-
-
-class TextInputIE8 extends TextInputIE {
-  eventsIndicatingValueChange () {
-    // IE 8 has a bug where it fails to fire 'propertychange' on the first update following a value change from
-    // JavaScript code. It also doesn't fire if you clear the entire value. To fix this, we bind to the following
-    // events too.
-    // keypress: All versions (including 11) of Internet Explorer have a bug that they don't generate an input or propertychange event when ESC is pressed
-    // keyup: A single keystoke
-    // keydown: First character when a key is held down
-    return [...super.eventsIndicatingValueChange(), 'keyup', 'keydown']
-  }
-}
-
-
-// Safari <5 doesn't fire the 'input' event for <textarea> elements (it does fire 'textInput'
-// but only when typing). So we'll just catch as much as we can with keydown, cut, and paste.
-class TextInputLegacySafari extends TextInput {
-  eventsIndicatingDeferValueChange () {
-    return ['keydown', 'paste', 'cut']
-  }
-}
-
-
-class TextInputLegacyOpera extends TextInput {
-  eventsIndicatingDeferValueChange () {
-    // Opera 10 doesn't always fire the 'input' event for cut, paste, undo & drop operations.
-    // We can try to catch some of those using 'keydown'.
-    return ['keydown']
-  }
-}
-
-
-class TextInputLegacyFirefox extends TextInput {
-  eventsIndicatingValueChange () {
-    return [
-      ...super.eventsIndicatingSyncValueChange(),
-      // Firefox <= 3.6 doesn't fire the 'input' event when text is filled in through autocomplete
-      'DOMAutoComplete',
-      // Firefox <=3.5 doesn't fire the 'input' event when text is dropped into the input.
-      'dragdrop', // < 3.5
-      'drop' // 3.5
-    ]
-  }
-}
-
-
-const w = options.global; // window / global
-if (w.navigator) {
-  const parseVersion = (matches) => matches && parseFloat(matches[1]);
-  const userAgent = w.navigator.userAgent;
-  const isChrome = userAgent.match(/Chrome\/([^ ]+)/);
-  // Detect various browser versions because some old versions don't fully support the 'input' event
-  operaVersion = w.opera && w.opera.version && parseInt(w.opera.version());
-  safariVersion = parseVersion(userAgent.match(/Version\/([^ ]+) Safari/));
-  firefoxVersion = parseVersion(userAgent.match(/Firefox\/([^ ]*)/));
-}
-
-
-const textInput =
-  ieVersion === 8 ? TextInputIE8
-  : ieVersion === 9 ? TextInputIE9
-  : ieVersion ? TextInputIE
-  : safariVersion && safariVersion < 5 ? TextInputLegacySafari
-  : operaVersion < 11 ? TextInputLegacyOpera
-  : firefoxVersion && firefoxVersion < 4 ? TextInputLegacyFirefox
-  : TextInput;
-
-var uniqueName = {
-  init: function (element, valueAccessor) {
-    if (valueAccessor()) {
-      var name = 'ko_unique_' + (++uniqueName.currentIndex);
-      setElementName(element, name);
-    }
-  },
-  currentIndex: 0
-};
-
-class value extends BindingHandler {
-  static get after () { return ['options', 'foreach', 'template'] }
-
-  constructor (...args) {
-    super(...args);
-
-    // If the value binding is placed on a radio/checkbox, then just pass through to checkedValue and quit
-    if (this.isCheckboxOrRadio) {
-      applyBindingAccessorsToNode(this.$element,
-        { checkedValue: this.valueAccessor });
-      return
-    }
-
-    this.propertyChangedFired = false;
-    this.elementValueBeforeEvent = null;
-
-    if (this.ieAutoCompleteHackNeeded) {
-      this.addEventListener('propertyChange', () => this.propertyChangedFired = true);
-      this.addEventListener('focus', () => this.propertyChangedFired = false);
-      this.addEventListener('blur', () => this.propertyChangeFired &&
-        this.valueUpdateHandler());
-    }
-
-    arrayForEach(this.eventsToCatch, eventName => this.registerEvent(eventName));
-
-    if (this.isInput && this.$element.type === 'file') {
-      this.updateFromModel = this.updateFromModelForFile;
-    } else {
-      this.updateFromModel = this.updateFromModelForValue;
-    }
-
-    this.computed('updateFromModel');
-  }
-
-  get eventsToCatch () {
-    const requestedEventsToCatch = this.allBindings.get('valueUpdate');
-    const requestedEventsArray = typeof requestedEventsToCatch === 'string' ?
-      [requestedEventsToCatch] : requestedEventsToCatch || [];
-    return [...new Set(['change', ...requestedEventsArray])]
-  }
-
-  get isInput () {
-    return tagNameLower(this.$element) === 'input'
-  }
-
-  get isCheckboxOrRadio () {
-    const e = this.$element;
-    return this.isInput && (e.type == 'checkbox' || e.type == 'radio')
-  }
-
-  // Workaround for https://github.com/SteveSanderson/knockout/issues/122
-  // IE doesn't fire "change" events on textboxes if the user selects a value from its autocomplete list
-  get ieAutoCompleteHackNeeded () {
-    return ieVersion && isInputElement &&
-      this.$element.type == 'text' && this.$element.autocomplete != 'off' &&
-      (!this.$element.form || this.$element.form.autocomplete != 'off')
-  }
-
-  valueUpdateHandler () {
-    this.elementValueBeforeEvent = null;
-    this.propertyChangedFired = false;
-    this.value = selectExtensions.readValue(this.$element);
-  }
-
-  registerEvent (eventName) {
-    // The syntax "after<eventname>" means "run the handler asynchronously after the event"
-    // This is useful, for example, to catch "keydown" events after the browser has updated the control
-    // (otherwise, selectExtensions.readValue(this) will receive the control's value *before* the key event)
-    var handler = this.valueUpdateHandler.bind(this);
-    if (stringStartsWith(eventName, 'after')) {
-      handler = () => {
-        // The elementValueBeforeEvent variable is non-null *only* during the brief gap between
-        // a keyX event firing and the valueUpdateHandler running, which is scheduled to happen
-        // at the earliest asynchronous opportunity. We store this temporary information so that
-        // if, between keyX and valueUpdateHandler, the underlying model value changes separately,
-        // we can overwrite that model value change with the value the user just typed. Otherwise,
-        // techniques like rateLimit can trigger model changes at critical moments that will
-        // override the user's inputs, causing keystrokes to be lost.
-        this.elementValueBeforeEvent = selectExtensions.readValue(this.$element);
-        safeSetTimeout(this.valueUpdateHandler.bind(this), 0);
-      };
-      eventName = eventName.substring(5 /* 'after'.length */);
-    }
-    this.addEventListener(eventName, handler);
-  }
-
-  updateFromModelForFile () {
-    // For file input elements, can only write the empty string
-    var newValue = unwrap(this.value);
-    if (newValue === null || newValue === undefined || newValue === '') {
-      this.$element.value = '';
-    } else {
-      dependencyDetection.ignore(this.valueUpdateHandler, this);   // reset the model to match the element
-    }
-  }
-
-  updateFromModelForValue () {
-    const element = this.$element;
-    var newValue = unwrap(this.value);
-    var elementValue = selectExtensions.readValue(element);
-
-    if (this.elementValueBeforeEvent !== null && newValue === this.elementValueBeforeEvent) {
-      safeSetTimeout(this.updateFromModel.bind(this), 0);
-      return
-    }
-
-    if (newValue === elementValue && elementValue !== undefined) { return }
-
-    if (tagNameLower(element) === 'select') {
-      const allowUnset = this.allBindings.get('valueAllowUnset');
-      selectExtensions.writeValue(element, newValue, allowUnset);
-
-      if (!allowUnset && newValue !== selectExtensions.readValue(element)) {
-       // If you try to set a model value that can't be represented in an already-populated dropdown, reject that change,
-       // because you're not allowed to have a model value that disagrees with a visible UI selection.
-        dependencyDetection.ignore(this.valueUpdateHandler, this);
-      }
-    } else {
-      selectExtensions.writeValue(element, newValue);
-    }
-  }
-}
-
-var visible = {
-  update: function (element, valueAccessor) {
-    var value = unwrap(valueAccessor());
-    var isCurrentlyVisible = !(element.style.display === 'none');
-    if (value && !isCurrentlyVisible) {
-      element.style.display = '';
-    } else if (!value && isCurrentlyVisible) {
-      element.style.display = 'none';
-    }
-  }
-};
-
-var hidden = {
-  update: function (element, valueAccessor) {
-    visible.update.call(this, element, () => !unwrap(valueAccessor()));
-  }
-};
-
-var using = {
-  init: function (element, valueAccessor, allBindings, viewModel, bindingContext) {
-    var innerContext = bindingContext.createChildContext(valueAccessor);
-    applyBindingsToDescendants(innerContext, element);
-    return { controlsDescendantBindings: true }
-  },
-  allowVirtualElements: true
-};
-
-var bindings = {
-  attr,
-  checked,
-  checkedValue,
-  click,
-  css,
-  'class': css,
-  descendantsComplete: DescendantsCompleteHandler,
-  enable,
-  'event': eventHandler,
-  disable,
-  hasfocus,
-  hasFocus: hasfocus,
-  hidden,
-  html,
-  'let': $let,
-  on: onHandler,
-  options: options$1,
-  selectedOptions,
-  style,
-  submit,
-  text,
-  textInput,
-  textinput: textInput,
-  uniqueName,
-  using,
-  value,
-  visible
-};
-
-export { bindings };
-//# sourceMappingURL=binding.core.es6.js.map