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

package/dist/binding.core.js

@@ -1,1143 +0,0 @@
-/*!
- * TKO Core bindings 🥊  @tko/binding.core@4.0.0-alpha8.4
- * (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, ensureSelectElementIsRenderedCorrectly, selectExtensions, arrayForEach, options, domData, 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.)
-            var 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());
-    }
-};
-
-/*! *****************************************************************************
-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 __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;
-}
-
-// 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 || {};
-}
-var eventHandler = {
-    init: function (element, valueAccessor, allBindings, viewModel, bindingContext) {
-        var eventsToHandle = valueAccessor() || {};
-        objectForEach(eventsToHandle, function (eventName, descriptor) {
-            var _a = makeDescriptor(descriptor), passive = _a.passive, capture = _a.capture, once = _a.once, debounce$$1 = _a.debounce, throttle$$1 = _a.throttle;
-            var eventOptions = (capture || passive || once) && { capture: capture, passive: passive, once: once };
-            var eventHandlerFn = function (event) {
-                var more = [];
-                for (var _i = 1; _i < arguments.length; _i++) {
-                    more[_i - 1] = arguments[_i];
-                }
-                var handlerReturnValue;
-                var _a = makeDescriptor(valueAccessor()[eventName]), handler = _a.handler, passive = _a.passive, bubble = _a.bubble;
-                try {
-                    // Take all the event args, and prefix with the viewmodel
-                    if (handler) {
-                        var possiblyUpdatedViewModel = bindingContext.$data;
-                        var argsForHandler = __spread([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;
-                        }
-                    }
-                }
-                var 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);
-        });
-    }
-};
-var 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')
-};
-
-var DescendantsCompleteHandler = /** @class */ (function (_super) {
-    __extends(DescendantsCompleteHandler, _super);
-    function DescendantsCompleteHandler() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    DescendantsCompleteHandler.prototype.onDescendantsComplete = function () {
-        if (typeof this.value === 'function') {
-            this.value(this.$element);
-        }
-    };
-    Object.defineProperty(DescendantsCompleteHandler, "allowVirtualElements", {
-        get: function () { return true; },
-        enumerable: true,
-        configurable: true
-    });
-    return DescendantsCompleteHandler;
-}(BindingHandler));
-
-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;
-    }
-};
-
-var jQueryInstance = options.jQueryInstance;
-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, function (all, letter) { return letter.toUpperCase(); });
-                var 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
- */
-var TextInput = /** @class */ (function (_super) {
-    __extends(TextInput, _super);
-    function TextInput() {
-        var e_1, _a, e_2, _b;
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var _this = _super.apply(this, __spread(args)) || this;
-        _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, function (eventName) {
-                if (eventName.slice(0, 5) === 'after') {
-                    _this.addEventListener(eventName.slice(5), 'deferUpdateModel');
-                }
-                else {
-                    _this.addEventListener(eventName, 'updateModel');
-                }
-            });
-        }
-        try {
-            for (var _c = __values(_this.eventsIndicatingSyncValueChange()), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var eventName = _d.value;
-                _this.addEventListener(eventName, 'updateModel');
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_a = _c["return"])) _a.call(_c);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        try {
-            for (var _e = __values(_this.eventsIndicatingDeferValueChange()), _f = _e.next(); !_f.done; _f = _e.next()) {
-                var eventName = _f.value;
-                _this.addEventListener(eventName, 'deferUpdateModel');
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_f && !_f.done && (_b = _e["return"])) _b.call(_e);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        _this.computed('updateView');
-        return _this;
-    }
-    Object.defineProperty(TextInput.prototype, "aliases", {
-        get: function () { return 'textinput'; },
-        enumerable: true,
-        configurable: true
-    });
-    TextInput.prototype.eventsIndicatingSyncValueChange = function () {
-        // 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'];
-    };
-    TextInput.prototype.eventsIndicatingDeferValueChange = function () {
-        return [];
-    };
-    TextInput.prototype.updateModel = function (event) {
-        var element = this.$element;
-        clearTimeout(this.timeoutHandle);
-        this.elementValueBeforeEvent = this.timeoutHandle = undefined;
-        var 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;
-        }
-    };
-    TextInput.prototype.deferUpdateModel = function (event) {
-        var 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;
-            var handler = options.debug ? this.updateModel.bind(this, { type: event.type }) : this.updateModel;
-            this.timeoutHandle = safeSetTimeout(handler, 4);
-        }
-    };
-    TextInput.prototype.updateView = function () {
-        var 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)
-        }
-    };
-    return TextInput;
-}(BindingHandler));
-/**
- * Legacy Input Classes, below
- */
-var TextInputIE = /** @class */ (function (_super) {
-    __extends(TextInputIE, _super);
-    function TextInputIE() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var _this = _super.apply(this, __spread(args)) || this;
-        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', function (event) {
-                return event.propertyName === 'value' && _this.updateModel(event);
-            });
-        }
-        if (ieVersion >= 8 && ieVersion < 10) {
-            _this.watchForSelectionChangeEvent();
-            _this.addEventListener('dragend', 'deferUpdateModel');
-        }
-        return _this;
-    }
-    TextInputIE.prototype.eventsIndicatingSyncValueChange = function () {
-        // 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 __spread(_super.prototype.eventsIndicatingValueChange.call(this), ['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.
-    TextInputIE.prototype.selectionChangeHandler = function (event) {
-        var target = this.activeElement;
-        var handler = target && domData.get(target, selectionChangeHandlerName);
-        if (handler) {
-            handler(event);
-        }
-    };
-    TextInputIE.prototype.watchForSelectionChangeEvent = function (element, ieUpdateModel) {
-        var 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);
-    };
-    return TextInputIE;
-}(TextInput));
-// 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.
-var TextInputIE9 = /** @class */ (function (_super) {
-    __extends(TextInputIE9, _super);
-    function TextInputIE9() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    TextInputIE9.prototype.updateModel = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        // 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.apply(this, __spread(args));
-    };
-    return TextInputIE9;
-}(TextInputIE));
-var TextInputIE8 = /** @class */ (function (_super) {
-    __extends(TextInputIE8, _super);
-    function TextInputIE8() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    TextInputIE8.prototype.eventsIndicatingValueChange = function () {
-        // 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 __spread(_super.prototype.eventsIndicatingValueChange.call(this), ['keyup', 'keydown']);
-    };
-    return TextInputIE8;
-}(TextInputIE));
-// 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.
-var TextInputLegacySafari = /** @class */ (function (_super) {
-    __extends(TextInputLegacySafari, _super);
-    function TextInputLegacySafari() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    TextInputLegacySafari.prototype.eventsIndicatingDeferValueChange = function () {
-        return ['keydown', 'paste', 'cut'];
-    };
-    return TextInputLegacySafari;
-}(TextInput));
-var TextInputLegacyOpera = /** @class */ (function (_super) {
-    __extends(TextInputLegacyOpera, _super);
-    function TextInputLegacyOpera() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    TextInputLegacyOpera.prototype.eventsIndicatingDeferValueChange = function () {
-        // 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'];
-    };
-    return TextInputLegacyOpera;
-}(TextInput));
-var TextInputLegacyFirefox = /** @class */ (function (_super) {
-    __extends(TextInputLegacyFirefox, _super);
-    function TextInputLegacyFirefox() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    TextInputLegacyFirefox.prototype.eventsIndicatingValueChange = function () {
-        return __spread(_super.prototype.eventsIndicatingSyncValueChange.call(this), [
-            // 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',
-            'drop' // 3.5
-        ]);
-    };
-    return TextInputLegacyFirefox;
-}(TextInput));
-var w = options.global; // window / global
-if (w.navigator) {
-    var parseVersion_1 = function (matches) { return matches && parseFloat(matches[1]); };
-    var userAgent = w.navigator.userAgent;
-    var 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_1(userAgent.match(/Version\/([^ ]+) Safari/));
-    firefoxVersion = parseVersion_1(userAgent.match(/Firefox\/([^ ]*)/));
-}
-var 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
-};
-
-var value = /** @class */ (function (_super) {
-    __extends(value, _super);
-    function value() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var _this = _super.apply(this, __spread(args)) || this;
-        // 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;
-        }
-        _this.propertyChangedFired = false;
-        _this.elementValueBeforeEvent = null;
-        if (_this.ieAutoCompleteHackNeeded) {
-            _this.addEventListener('propertyChange', function () { return _this.propertyChangedFired = true; });
-            _this.addEventListener('focus', function () { return _this.propertyChangedFired = false; });
-            _this.addEventListener('blur', function () { return _this.propertyChangeFired &&
-                _this.valueUpdateHandler(); });
-        }
-        arrayForEach(_this.eventsToCatch, function (eventName) { return _this.registerEvent(eventName); });
-        if (_this.isInput && _this.$element.type === 'file') {
-            _this.updateFromModel = _this.updateFromModelForFile;
-        }
-        else {
-            _this.updateFromModel = _this.updateFromModelForValue;
-        }
-        _this.computed('updateFromModel');
-        return _this;
-    }
-    Object.defineProperty(value, "after", {
-        get: function () { return ['options', 'foreach', 'template']; },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(value.prototype, "eventsToCatch", {
-        get: function () {
-            var requestedEventsToCatch = this.allBindings.get('valueUpdate');
-            var requestedEventsArray = typeof requestedEventsToCatch === 'string' ?
-                [requestedEventsToCatch] : requestedEventsToCatch || [];
-            return __spread(new Set(__spread(['change'], requestedEventsArray)));
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(value.prototype, "isInput", {
-        get: function () {
-            return tagNameLower(this.$element) === 'input';
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(value.prototype, "isCheckboxOrRadio", {
-        get: function () {
-            var e = this.$element;
-            return this.isInput && (e.type == 'checkbox' || e.type == 'radio');
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(value.prototype, "ieAutoCompleteHackNeeded", {
-        // 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: function () {
-            return ieVersion && isInputElement &&
-                this.$element.type == 'text' && this.$element.autocomplete != 'off' &&
-                (!this.$element.form || this.$element.form.autocomplete != 'off');
-        },
-        enumerable: true,
-        configurable: true
-    });
-    value.prototype.valueUpdateHandler = function () {
-        this.elementValueBeforeEvent = null;
-        this.propertyChangedFired = false;
-        this.value = selectExtensions.readValue(this.$element);
-    };
-    value.prototype.registerEvent = function (eventName) {
-        var _this = this;
-        // 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 = function () {
-                // 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);
-    };
-    value.prototype.updateFromModelForFile = function () {
-        // 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
-        }
-    };
-    value.prototype.updateFromModelForValue = function () {
-        var 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') {
-            var 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);
-        }
-    };
-    return value;
-}(BindingHandler));
-
-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, function () { return !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: attr,
-    checked: checked,
-    checkedValue: checkedValue,
-    click: click,
-    css: css,
-    'class': css,
-    descendantsComplete: DescendantsCompleteHandler,
-    enable: enable,
-    'event': eventHandler,
-    disable: disable,
-    hasfocus: hasfocus,
-    hasFocus: hasfocus,
-    hidden: hidden,
-    html: html,
-    'let': $let,
-    on: onHandler,
-    options: options$1,
-    selectedOptions: selectedOptions,
-    style: style,
-    submit: submit,
-    text: text,
-    textInput: textInput,
-    textinput: textInput,
-    uniqueName: uniqueName,
-    using: using,
-    value: value,
-    visible: visible
-};
-
-export { bindings };
-//# sourceMappingURL=binding.core.js.map