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

package/dist/index.cjs

@@ -1,8 +1,13 @@
-// @tko/binding.core 🥊 4.0.0-beta1.0 CommonJS
+// @tko/binding.core 🥊 4.0.0 CommonJS
+"use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -16,19 +21,71 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value2) => {
+      try {
+        step(generator.next(value2));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value2) => {
+      try {
+        step(generator.throw(value2));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __yieldStar = (value2) => {
+  var obj = value2[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
+  if (obj == null) {
+    obj = value2[__knownSymbol("iterator")]();
+    method = (k) => it[k] = (x) => obj[k](x);
+  } else {
+    obj = obj.call(value2);
+    method = (k) => it[k] = (v) => {
+      if (isAwait) {
+        isAwait = false;
+        if (k === "throw") throw v;
+        return v;
+      }
+      isAwait = true;
+      return {
+        done: false,
+        value: new __await(new Promise((resolve) => {
+          var x = obj[k](v);
+          if (!(x instanceof Object)) __typeError("Object expected");
+          resolve(x);
+        }), 1)
+      };
+    };
+  }
+  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
+    throw x;
+  }, "return" in obj && method("return"), it;
+};
 
 // index.ts
-var binding_exports = {};
-__export(binding_exports, {
+var index_exports = {};
+__export(index_exports, {
   bindings: () => bindings
 });
-module.exports = __toCommonJS(binding_exports);
+module.exports = __toCommonJS(index_exports);
 
 // ../utils/dist/array.js
 var { isArray } = Array;
-function arrayForEach(array, action, thisArg) {
+function arrayForEach(array, action, actionOwner) {
   if (arguments.length > 2) {
-    action = action.bind(thisArg);
+    action = action.bind(actionOwner);
   }
   for (let i = 0, j = array.length; i < j; ++i) {
     action(array[i], i, array);
@@ -40,23 +97,23 @@ function arrayIndexOf(array, item) {
 function arrayFirst(array, predicate, predicateOwner) {
   return (isArray(array) ? array : [...array]).find(predicate, predicateOwner);
 }
-function arrayMap(array = [], mapping, thisArg) {
+function arrayMap(array, mapping, thisArg) {
   if (arguments.length > 2) {
     mapping = mapping.bind(thisArg);
   }
   return array === null ? [] : Array.from(array, mapping);
 }
 function arrayRemoveItem(array, itemToRemove) {
-  var index = arrayIndexOf(array, itemToRemove);
+  const index = arrayIndexOf(array, itemToRemove);
   if (index > 0) {
     array.splice(index, 1);
   } else if (index === 0) {
     array.shift();
   }
 }
-function arrayFilter(array, predicate, thisArg) {
+function arrayFilter(array, predicate, predicateOwner) {
   if (arguments.length > 2) {
-    predicate = predicate.bind(thisArg);
+    predicate = predicate.bind(predicateOwner);
   }
   return array === null ? [] : (isArray(array) ? array : [...array]).filter(predicate);
 }
@@ -64,14 +121,14 @@ function arrayPushAll(array, valuesToPush) {
   if (isArray(valuesToPush)) {
     array.push.apply(array, valuesToPush);
   } else {
-    for (var i = 0, j = valuesToPush.length; i < j; i++) {
+    for (let i = 0, j = valuesToPush.length; i < j; i++) {
       array.push(valuesToPush[i]);
     }
   }
   return array;
 }
 function addOrRemoveItem(array, value2, included) {
-  var existingEntryIndex = arrayIndexOf(typeof array.peek === "function" ? array.peek() : array, value2);
+  const existingEntryIndex = arrayIndexOf(typeof array.peek === "function" ? array.peek() : array, value2);
   if (existingEntryIndex < 0) {
     if (included) {
       array.push(value2);
@@ -87,7 +144,7 @@ function makeArray(arrayLikeObject) {
 }
 function findMovesInArrayComparison(left, right, limitFailedCompares) {
   if (left.length && right.length) {
-    var failedCompares, l, r, leftItem, rightItem;
+    let failedCompares, l, r, leftItem, rightItem;
     for (failedCompares = l = 0; (!limitFailedCompares || failedCompares < limitFailedCompares) && (leftItem = left[l]); ++l) {
       for (r = 0; rightItem = right[r]; ++r) {
         if (leftItem.value === rightItem.value) {
@@ -115,10 +172,10 @@ function compareArrays(oldArray, newArray, options3) {
   }
 }
 function compareSmallArrayToBigArray(smlArray, bigArray, statusNotInSml, statusNotInBig, options3) {
-  var myMin = Math.min, myMax = Math.max, editDistanceMatrix = [], smlIndex, smlIndexMax = smlArray.length, bigIndex, bigIndexMax = bigArray.length, compareRange = bigIndexMax - smlIndexMax || 1, maxDistance = smlIndexMax + bigIndexMax + 1, thisRow, lastRow, bigIndexMaxForRow, bigIndexMinForRow;
+  let myMin = Math.min, myMax = Math.max, editDistanceMatrix = new Array(), smlIndex, smlIndexMax = smlArray.length, bigIndex, bigIndexMax = bigArray.length, compareRange = bigIndexMax - smlIndexMax || 1, maxDistance = smlIndexMax + bigIndexMax + 1, thisRow, lastRow, bigIndexMaxForRow, bigIndexMinForRow;
   for (smlIndex = 0; smlIndex <= smlIndexMax; smlIndex++) {
     lastRow = thisRow;
-    editDistanceMatrix.push(thisRow = []);
+    editDistanceMatrix.push(thisRow = new Array());
     bigIndexMaxForRow = myMin(bigIndexMax, smlIndex + compareRange);
     bigIndexMinForRow = myMax(0, smlIndex - 1);
     for (bigIndex = bigIndexMinForRow; bigIndex <= bigIndexMaxForRow; bigIndex++) {
@@ -129,35 +186,38 @@ function compareSmallArrayToBigArray(smlArray, bigArray, statusNotInSml, statusN
       } else if (smlArray[smlIndex - 1] === bigArray[bigIndex - 1]) {
         thisRow[bigIndex] = lastRow[bigIndex - 1];
       } else {
-        var northDistance = lastRow[bigIndex] || maxDistance;
-        var westDistance = thisRow[bigIndex - 1] || maxDistance;
+        const northDistance = lastRow[bigIndex] || maxDistance;
+        const westDistance = thisRow[bigIndex - 1] || maxDistance;
         thisRow[bigIndex] = myMin(northDistance, westDistance) + 1;
       }
     }
   }
-  var editScript = [], meMinusOne, notInSml = [], notInBig = [];
+  let editScript = new Array(), meMinusOne, notInSml = new Array(), notInBig = new Array();
   for (smlIndex = smlIndexMax, bigIndex = bigIndexMax; smlIndex || bigIndex; ) {
     meMinusOne = editDistanceMatrix[smlIndex][bigIndex] - 1;
     if (bigIndex && meMinusOne === editDistanceMatrix[smlIndex][bigIndex - 1]) {
-      notInSml.push(editScript[editScript.length] = {
-        "status": statusNotInSml,
-        "value": bigArray[--bigIndex],
-        "index": bigIndex
-      });
+      notInSml.push(
+        editScript[editScript.length] = {
+          // added
+          status: statusNotInSml,
+          value: bigArray[--bigIndex],
+          index: bigIndex
+        }
+      );
     } else if (smlIndex && meMinusOne === editDistanceMatrix[smlIndex - 1][bigIndex]) {
-      notInBig.push(editScript[editScript.length] = {
-        "status": statusNotInBig,
-        "value": smlArray[--smlIndex],
-        "index": smlIndex
-      });
+      notInBig.push(
+        editScript[editScript.length] = {
+          // deleted
+          status: statusNotInBig,
+          value: smlArray[--smlIndex],
+          index: smlIndex
+        }
+      );
     } else {
       --bigIndex;
       --smlIndex;
-      if (!options3.sparse) {
-        editScript.push({
-          "status": "retained",
-          "value": bigArray[bigIndex]
-        });
+      if (!(options3 == null ? void 0 : options3.sparse)) {
+        editScript.push({ status: "retained", value: bigArray[bigIndex] });
       }
     }
   }
@@ -166,40 +226,79 @@ function compareSmallArrayToBigArray(smlArray, bigArray, statusNotInSml, statusN
 }
 
 // ../utils/dist/options.js
-var options = {
-  deferUpdates: false,
-  useOnlyNativeEvents: false,
-  protoProperty: "__ko_proto__",
-  defaultBindingAttribute: "data-bind",
-  allowVirtualElements: true,
-  bindingGlobals: /* @__PURE__ */ Object.create(null),
-  bindingProviderInstance: null,
-  createChildContextWithAs: false,
-  jQuery: globalThis.jQuery,
-  Promise: globalThis.Promise,
-  taskScheduler: null,
-  debug: false,
-  global: globalThis,
-  document: globalThis.document,
-  filters: {},
-  includeDestroyed: false,
-  foreachHidesDestroyed: false,
-  onError: function(e) {
-    throw e;
-  },
-  set: function(name, value2) {
-    options[name] = value2;
-  },
-  getBindingHandler() {
-  },
-  cleanExternalData() {
+var Options = class {
+  constructor() {
+    this.bindingStringPreparsers = [];
+    this.knockoutInstance = null;
+    this.deferUpdates = false;
+    this.useOnlyNativeEvents = true;
+    this.useTemplateTag = true;
+    this.protoProperty = "__ko_proto__";
+    this.defaultBindingAttribute = "data-bind";
+    this.allowVirtualElements = true;
+    this.bindingGlobals = /* @__PURE__ */ Object.create(null);
+    this.createChildContextWithAs = false;
+    this.disableJQueryUsage = false;
+    this.Promise = globalThis.Promise;
+    this.taskScheduler = null;
+    this.debug = false;
+    this.templateSizeLimit = 4096;
+    this.allowScriptTagsInTemplates = false;
+    this._sanitizeWarningLogged = false;
+    this.global = globalThis;
+    this.document = globalThis.document;
+    this.filters = {};
+    this.includeDestroyed = false;
+    this.foreachHidesDestroyed = false;
+  }
+  get jQuery() {
+    var _a;
+    if (this.disableJQueryUsage) return;
+    return (_a = this._jQuery) != null ? _a : globalThis.jQuery;
+  }
+  /**
+   * Set jQuery manuall to be used by TKO.
+   * @param jQuery If jQuery set to undefined, TKO will not use jQuery and this.disableJQueryUsage to true.
+   */
+  set jQuery(jQuery2) {
+    if (!jQuery2) {
+      this.disableJQueryUsage = true;
+      this._jQuery = void 0;
+    } else {
+      this._jQuery = jQuery2;
+      this.disableJQueryUsage = false;
+    }
+  }
+  /**
+   * Sanitize HTML templates before parsing them. Default is a no-op.
+   * Please configure something like DOMPurify or validator.js for your environment.
+   * @param html HTML string to be sanitized
+   * @returns Sanitized HTML string
+   */
+  sanitizeHtmlTemplate(html2) {
+    if (!this._sanitizeWarningLogged) {
+      console.warn(
+        "WARNING -- You don't have a HTML sanitizer configured. Please configure options.sanitizeHtmlTemplate to avoid XSS vulnerabilities."
+      );
+      this._sanitizeWarningLogged = true;
+    }
+    return html2;
+  }
+  onError(e, throws = true) {
+    if (throws) throw e;
+    return e;
+  }
+  set(name, value2) {
+    this[name] = value2;
+  }
+  // Overload getBindingHandler to have a custom lookup function.
+  getBindingHandler(key) {
+    return null;
   }
-};
-Object.defineProperty(options, "$", {
-  get: function() {
-    return options.jQuery;
+  cleanExternalData(node, callback) {
   }
-});
+};
+var options = new Options();
 var options_default = options;
 
 // ../utils/dist/error.js
@@ -220,13 +319,13 @@ function deferError(error) {
     throw error;
   }, 0);
 }
-function safeSetTimeout(handler2, timeout) {
-  return setTimeout(catchFunctionErrors(handler2), timeout);
+function safeSetTimeout(handler, timeout) {
+  return setTimeout(catchFunctionErrors(handler), timeout);
 }
 
 // ../utils/dist/async.js
 function throttle(callback, timeout) {
-  var timeoutInstance;
+  let timeoutInstance;
   return function(...args) {
     if (!timeoutInstance) {
       timeoutInstance = safeSetTimeout(function() {
@@ -237,25 +336,13 @@ function throttle(callback, timeout) {
   };
 }
 function debounce(callback, timeout) {
-  var timeoutInstance;
+  let timeoutInstance;
   return function(...args) {
     clearTimeout(timeoutInstance);
     timeoutInstance = safeSetTimeout(() => callback(...args), timeout);
   };
 }
 
-// ../utils/dist/ie.js
-var ieVersion = options_default.document && function() {
-  var version = 3, div = options_default.document.createElement("div"), iElems = div.getElementsByTagName("i");
-  while (div.innerHTML = "<!--[if gt IE " + ++version + "]><i></i><![endif]-->", iElems[0]) {
-  }
-  if (!version) {
-    const userAgent = window.navigator.userAgent;
-    return ua.match(/MSIE ([^ ]+)/) || ua.match(/rv:([^ )]+)/);
-  }
-  return version > 4 ? version : void 0;
-}();
-
 // ../utils/dist/object.js
 function hasOwnProperty(obj, propName) {
   return Object.prototype.hasOwnProperty.call(obj, propName);
@@ -268,8 +355,9 @@ function isObjectLike(obj) {
 }
 function extend(target, source) {
   if (source) {
-    for (var prop in source) {
+    for (const prop of Object.keys(source)) {
       if (hasOwnProperty(source, prop)) {
+        ;
         target[prop] = source[prop];
       }
     }
@@ -277,7 +365,7 @@ function extend(target, source) {
   return target;
 }
 function objectForEach(obj, action) {
-  for (var prop in obj) {
+  for (const prop in obj) {
     if (hasOwnProperty(obj, prop)) {
       action(prop, obj[prop]);
     }
@@ -290,8 +378,8 @@ function objectMap(source, mapping, thisArg) {
   if (arguments.length > 2) {
     mapping = mapping.bind(thisArg);
   }
-  var target = {};
-  for (var prop in source) {
+  const target = {};
+  for (const prop in source) {
     if (hasOwnProperty(source, prop)) {
       target[prop] = mapping(source[prop], prop, source);
     }
@@ -337,7 +425,7 @@ function createSymbolOrString(identifier) {
 // ../utils/dist/css.js
 var cssClassNameRegex = /\S+/g;
 function toggleDomNodeCssClass(node, classNames, shouldHaveClass) {
-  var addOrRemoveFn;
+  let addOrRemoveFn;
   if (!classNames) {
     return;
   }
@@ -353,34 +441,32 @@ function toggleDomNodeCssClass(node, classNames, shouldHaveClass) {
   }
 }
 function toggleObjectClassPropertyString(obj, prop, classNames, shouldHaveClass) {
-  var currentClassNames = obj[prop].match(cssClassNameRegex) || [];
+  const currentClassNames = obj[prop].match(cssClassNameRegex) || [];
   arrayForEach(classNames.match(cssClassNameRegex), function(className) {
     addOrRemoveItem(currentClassNames, className, shouldHaveClass);
   });
   obj[prop] = currentClassNames.join(" ");
 }
 
-// ../utils/dist/jquery.js
-var jQueryInstance = options_default.global && options_default.global.jQuery;
-
 // ../utils/dist/dom/info.js
 function domNodeIsContainedBy(node, containedByNode) {
   if (node === containedByNode) {
     return true;
   }
-  if (node.nodeType === 11) {
+  if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
     return false;
   }
   if (containedByNode.contains) {
-    return containedByNode.contains(node.nodeType !== 1 ? node.parentNode : node);
+    return containedByNode.contains(node.nodeType !== Node.ELEMENT_NODE ? node.parentNode : node);
   }
   if (containedByNode.compareDocumentPosition) {
     return (containedByNode.compareDocumentPosition(node) & 16) == 16;
   }
-  while (node && node != containedByNode) {
-    node = node.parentNode;
+  let parentNode = node;
+  while (parentNode && parentNode != containedByNode) {
+    parentNode = parentNode.parentNode;
   }
-  return !!node;
+  return !!parentNode;
 }
 function domNodeIsAttachedToDocument(node) {
   return domNodeIsContainedBy(node, node.ownerDocument.documentElement);
@@ -392,6 +478,88 @@ function tagNameLower(element) {
   return element && element.tagName && element.tagName.toLowerCase();
 }
 
+// ../utils/dist/dom/event.js
+var knownEvents = {};
+var knownEventTypesByEventName = {};
+knownEvents["UIEvents"] = ["keyup", "keydown", "keypress"];
+knownEvents["MouseEvents"] = [
+  "click",
+  "dblclick",
+  "mousedown",
+  "mouseup",
+  "mousemove",
+  "mouseover",
+  "mouseout",
+  "mouseenter",
+  "mouseleave"
+];
+objectForEach(knownEvents, function(eventType, knownEventsForType) {
+  if (knownEventsForType.length) {
+    for (let i = 0, j = knownEventsForType.length; i < j; i++) {
+      knownEventTypesByEventName[knownEventsForType[i]] = eventType;
+    }
+  }
+});
+function isClickOnCheckableElement(element, eventType) {
+  if (tagNameLower(element) !== "input" || !element.type) return false;
+  if (eventType.toLowerCase() != "click") return false;
+  const inputType = element.type;
+  return inputType == "checkbox" || inputType == "radio";
+}
+function registerEventHandler(element, eventType, handler, eventOptions = false) {
+  const wrappedHandler = catchFunctionErrors(handler);
+  const mustUseNative = Boolean(eventOptions);
+  const jQuery2 = options_default.jQuery;
+  if (!options_default.useOnlyNativeEvents && !mustUseNative && jQuery2) {
+    jQuery2(element).on(eventType, wrappedHandler);
+  } else if (typeof element.addEventListener === "function") {
+    element.addEventListener(eventType, wrappedHandler, eventOptions);
+  } else {
+    throw new Error("Browser doesn't support addEventListener");
+  }
+}
+function hasClick(element) {
+  return typeof element.click === "function";
+}
+function triggerEvent(element, eventType) {
+  if (!(element && element.nodeType)) {
+    throw new Error("element must be a DOM node when calling triggerEvent");
+  }
+  const useClickWorkaround = isClickOnCheckableElement(element, eventType);
+  if (!options_default.useOnlyNativeEvents && options_default.jQuery && !useClickWorkaround) {
+    options_default.jQuery(element).trigger(eventType);
+  } else if (typeof document.createEvent === "function") {
+    if (typeof element.dispatchEvent === "function") {
+      const eventCategory = knownEventTypesByEventName[eventType] || "HTMLEvents";
+      const event = document.createEvent(eventCategory);
+      event.initEvent(
+        eventType,
+        true,
+        true,
+        options_default.global,
+        0,
+        0,
+        0,
+        0,
+        0,
+        false,
+        false,
+        false,
+        false,
+        0,
+        element
+      );
+      element.dispatchEvent(event);
+    } else {
+      throw new Error("The supplied element doesn't support dispatchEvent");
+    }
+  } else if (useClickWorkaround && hasClick(element)) {
+    element.click();
+  } else {
+    throw new Error("Browser doesn't support triggering events");
+  }
+}
+
 // ../utils/dist/dom/data.js
 var data_exports = {};
 __export(data_exports, {
@@ -401,64 +569,53 @@ __export(data_exports, {
   nextKey: () => nextKey,
   set: () => set
 });
-var datastoreTime = new Date().getTime();
+var datastoreTime = (/* @__PURE__ */ new Date()).getTime();
 var dataStoreKeyExpandoPropertyName = `__ko__${datastoreTime}`;
-var dataStoreSymbol = Symbol("Knockout data");
-var dataStore;
+var dataStoreSymbol = /* @__PURE__ */ Symbol("Knockout data");
 var uniqueId = 0;
-var modern = {
-  getDataForNode(node, createIfNotFound) {
-    let dataForNode = node[dataStoreSymbol];
-    if (!dataForNode && createIfNotFound) {
-      dataForNode = node[dataStoreSymbol] = {};
-    }
-    return dataForNode;
-  },
-  clear(node) {
-    if (node[dataStoreSymbol]) {
-      delete node[dataStoreSymbol];
-      return true;
-    }
-    return false;
+function isSafeKey(key) {
+  return key !== "__proto__" && key !== "constructor" && key !== "prototype";
+}
+function getDataForNode(node, createIfNotFound) {
+  let dataForNode = node[dataStoreSymbol];
+  if (!dataForNode && createIfNotFound) {
+    dataForNode = node[dataStoreSymbol] = {};
   }
-};
-var IE = {
-  getDataforNode(node, createIfNotFound) {
-    let dataStoreKey = node[dataStoreKeyExpandoPropertyName];
-    const hasExistingDataStore = dataStoreKey && dataStoreKey !== "null" && dataStore[dataStoreKey];
-    if (!hasExistingDataStore) {
-      if (!createIfNotFound) {
-        return void 0;
-      }
-      dataStoreKey = node[dataStoreKeyExpandoPropertyName] = "ko" + uniqueId++;
-      dataStore[dataStoreKey] = {};
-    }
-    return dataStore[dataStoreKey];
-  },
-  clear(node) {
-    const dataStoreKey = node[dataStoreKeyExpandoPropertyName];
-    if (dataStoreKey) {
-      delete dataStore[dataStoreKey];
-      node[dataStoreKeyExpandoPropertyName] = null;
-      return true;
-    }
-    return false;
+  return dataForNode;
+}
+function clear(node) {
+  if (node[dataStoreSymbol]) {
+    delete node[dataStoreSymbol];
+    return true;
   }
-};
-var { getDataForNode, clear } = ieVersion ? IE : modern;
+  return false;
+}
 function nextKey() {
   return uniqueId++ + dataStoreKeyExpandoPropertyName;
 }
 function get(node, key) {
+  if (!isSafeKey(key)) throw new Error("Unsafe key for DOM data: " + key);
   const dataForNode = getDataForNode(node, false);
   return dataForNode && dataForNode[key];
 }
 function set(node, key, value2) {
-  var dataForNode = getDataForNode(node, value2 !== void 0);
-  dataForNode && (dataForNode[key] = value2);
+  if (!isSafeKey(key)) throw new Error("Unsafe key for DOM data: " + key);
+  const dataForNode = getDataForNode(
+    node,
+    value2 !== void 0
+    /* createIfNotFound */
+  );
+  if (dataForNode) {
+    dataForNode[key] = value2;
+  }
 }
 function getOrSet(node, key, value2) {
-  const dataForNode = getDataForNode(node, true);
+  if (!isSafeKey(key)) throw new Error("Unsafe key for DOM data: " + key);
+  const dataForNode = getDataForNode(
+    node,
+    true
+    /* createIfNotFound */
+  );
   return dataForNode[key] || (dataForNode[key] = value2);
 }
 
@@ -467,9 +624,9 @@ var domDataKey = nextKey();
 var cleanableNodeTypes = { 1: true, 8: true, 9: true };
 var cleanableNodeTypesWithDescendants = { 1: true, 9: true };
 function getDisposeCallbacksCollection(node, createIfNotFound) {
-  var allDisposeCallbacks = get(node, domDataKey);
+  let allDisposeCallbacks = get(node, domDataKey);
   if (allDisposeCallbacks === void 0 && createIfNotFound) {
-    allDisposeCallbacks = [];
+    allDisposeCallbacks = new Array();
     set(node, domDataKey, allDisposeCallbacks);
   }
   return allDisposeCallbacks;
@@ -478,7 +635,7 @@ function destroyCallbacksCollection(node) {
   set(node, domDataKey, void 0);
 }
 function cleanSingleNode(node) {
-  var callbacks = getDisposeCallbacksCollection(node, false);
+  let callbacks = getDisposeCallbacksCollection(node, false);
   if (callbacks) {
     callbacks = callbacks.slice(0);
     for (let i = 0; i < callbacks.length; i++) {
@@ -493,14 +650,18 @@ function cleanSingleNode(node) {
     options_default.cleanExternalData(node);
   }
   if (cleanableNodeTypesWithDescendants[node.nodeType]) {
-    cleanNodesInList(node.childNodes, true);
+    cleanNodesInList(
+      node.childNodes,
+      true
+      /* onlyComments */
+    );
   }
 }
 function cleanNodesInList(nodeList, onlyComments) {
-  const cleanedNodes = [];
+  const cleanedNodes = new Array();
   let lastCleanedNode;
-  for (var i = 0; i < nodeList.length; i++) {
-    if (!onlyComments || nodeList[i].nodeType === 8) {
+  for (let i = 0; i < nodeList.length; i++) {
+    if (!onlyComments || nodeList[i].nodeType === Node.COMMENT_NODE) {
       cleanSingleNode(cleanedNodes[cleanedNodes.length] = lastCleanedNode = nodeList[i]);
       if (nodeList[i] !== lastCleanedNode) {
         while (i-- && arrayIndexOf(cleanedNodes, nodeList[i]) === -1) {
@@ -516,7 +677,7 @@ function addDisposeCallback(node, callback) {
   getDisposeCallbacksCollection(node, true).push(callback);
 }
 function removeDisposeCallback(node, callback) {
-  var callbacksCollection = getDisposeCallbacksCollection(node, false);
+  const callbacksCollection = getDisposeCallbacksCollection(node, false);
   if (callbacksCollection) {
     arrayRemoveItem(callbacksCollection, callback);
     if (callbacksCollection.length === 0) {
@@ -527,140 +688,52 @@ function removeDisposeCallback(node, callback) {
 function cleanNode(node) {
   if (cleanableNodeTypes[node.nodeType]) {
     cleanSingleNode(node);
-    if (cleanableNodeTypesWithDescendants[node.nodeType]) {
+    if (cleanableNodeTypesWithDescendants[node.nodeType] && node instanceof Element) {
       cleanNodesInList(node.getElementsByTagName("*"));
     }
   }
   return node;
 }
 function removeNode(node) {
+  if (!node) {
+    return;
+  }
   cleanNode(node);
   if (node.parentNode) {
     node.parentNode.removeChild(node);
   }
 }
-var otherNodeCleanerFunctions = [];
+var otherNodeCleanerFunctions = new Array();
 function cleanjQueryData(node) {
-  var jQueryCleanNodeFn = jQueryInstance ? jQueryInstance.cleanData : null;
+  const jQueryCleanNodeFn = options_default.jQuery ? options_default.jQuery.cleanData : null;
   if (jQueryCleanNodeFn) {
     jQueryCleanNodeFn([node]);
   }
 }
 otherNodeCleanerFunctions.push(cleanjQueryData);
 
-// ../utils/dist/dom/event.js
-var knownEvents = {};
-var knownEventTypesByEventName = {};
-var keyEventTypeName = options_default.global.navigator && /Firefox\/2/i.test(options_default.global.navigator.userAgent) ? "KeyboardEvent" : "UIEvents";
-knownEvents[keyEventTypeName] = ["keyup", "keydown", "keypress"];
-knownEvents["MouseEvents"] = [
-  "click",
-  "dblclick",
-  "mousedown",
-  "mouseup",
-  "mousemove",
-  "mouseover",
-  "mouseout",
-  "mouseenter",
-  "mouseleave"
-];
-objectForEach(knownEvents, function(eventType, knownEventsForType) {
-  if (knownEventsForType.length) {
-    for (var i = 0, j = knownEventsForType.length; i < j; i++) {
-      knownEventTypesByEventName[knownEventsForType[i]] = eventType;
-    }
-  }
-});
-function isClickOnCheckableElement(element, eventType) {
-  if (tagNameLower(element) !== "input" || !element.type)
-    return false;
-  if (eventType.toLowerCase() != "click")
-    return false;
-  var inputType = element.type;
-  return inputType == "checkbox" || inputType == "radio";
-}
-var eventsThatMustBeRegisteredUsingAttachEvent = { "propertychange": true };
-var jQueryEventAttachName;
-function registerEventHandler(element, eventType, handler2, eventOptions = false) {
-  const wrappedHandler = catchFunctionErrors(handler2);
-  const mustUseAttachEvent = ieVersion && eventsThatMustBeRegisteredUsingAttachEvent[eventType];
-  const mustUseNative = Boolean(eventOptions);
-  if (!options_default.useOnlyNativeEvents && !mustUseAttachEvent && !mustUseNative && jQueryInstance) {
-    if (!jQueryEventAttachName) {
-      jQueryEventAttachName = typeof jQueryInstance(element).on === "function" ? "on" : "bind";
-    }
-    jQueryInstance(element)[jQueryEventAttachName](eventType, wrappedHandler);
-  } else if (!mustUseAttachEvent && typeof element.addEventListener === "function") {
-    element.addEventListener(eventType, wrappedHandler, eventOptions);
-  } else if (typeof element.attachEvent !== "undefined") {
-    const attachEventHandler = function(event) {
-      wrappedHandler.call(element, event);
-    };
-    const attachEventName = "on" + eventType;
-    element.attachEvent(attachEventName, attachEventHandler);
-    addDisposeCallback(element, function() {
-      element.detachEvent(attachEventName, attachEventHandler);
-    });
-  } else {
-    throw new Error("Browser doesn't support addEventListener or attachEvent");
-  }
-}
-function triggerEvent(element, eventType) {
-  if (!(element && element.nodeType)) {
-    throw new Error("element must be a DOM node when calling triggerEvent");
-  }
-  var useClickWorkaround = isClickOnCheckableElement(element, eventType);
-  if (!options_default.useOnlyNativeEvents && jQueryInstance && !useClickWorkaround) {
-    jQueryInstance(element).trigger(eventType);
-  } else if (typeof document.createEvent === "function") {
-    if (typeof element.dispatchEvent === "function") {
-      var eventCategory = knownEventTypesByEventName[eventType] || "HTMLEvents";
-      var event = document.createEvent(eventCategory);
-      event.initEvent(eventType, true, true, options_default.global, 0, 0, 0, 0, 0, false, false, false, false, 0, element);
-      element.dispatchEvent(event);
-    } else {
-      throw new Error("The supplied element doesn't support dispatchEvent");
-    }
-  } else if (useClickWorkaround && element.click) {
-    element.click();
-  } else if (typeof element.fireEvent !== "undefined") {
-    element.fireEvent("on" + eventType);
-  } else {
-    throw new Error("Browser doesn't support triggering events");
-  }
-}
-
 // ../utils/dist/dom/manipulation.js
 function setDomNodeChildren(domNode, childNodes2) {
   emptyDomNode(domNode);
   if (childNodes2) {
-    for (var i = 0, j = childNodes2.length; i < j; i++) {
+    for (let i = 0; i < childNodes2.length; i++) {
       domNode.appendChild(childNodes2[i]);
     }
   }
 }
 function replaceDomNodes(nodeToReplaceOrNodeArray, newNodesArray) {
-  var nodesToReplaceArray = nodeToReplaceOrNodeArray.nodeType ? [nodeToReplaceOrNodeArray] : nodeToReplaceOrNodeArray;
+  const nodesToReplaceArray = Array.isArray(nodeToReplaceOrNodeArray) ? nodeToReplaceOrNodeArray : [nodeToReplaceOrNodeArray];
   if (nodesToReplaceArray.length > 0) {
-    var insertionPoint = nodesToReplaceArray[0];
-    var parent = insertionPoint.parentNode;
-    for (var i = 0, j = newNodesArray.length; i < j; i++) {
-      parent.insertBefore(newNodesArray[i], insertionPoint);
+    const insertionPoint = nodesToReplaceArray[0];
+    const parent = insertionPoint.parentNode;
+    for (let i = 0; i < newNodesArray.length; i++) {
+      parent == null ? void 0 : parent.insertBefore(newNodesArray[i], insertionPoint);
     }
-    for (i = 0, j = nodesToReplaceArray.length; i < j; i++) {
+    for (let i = 0; i < nodesToReplaceArray.length; i++) {
       removeNode(nodesToReplaceArray[i]);
     }
   }
 }
-function setElementName(element, name) {
-  element.name = name;
-  if (ieVersion <= 7) {
-    try {
-      element.mergeAttributes(document.createElement("<input name='" + element.name + "'/>"), false);
-    } catch (e) {
-    }
-  }
-}
 function emptyDomNode(domNode) {
   while (domNode.firstChild) {
     removeNode(domNode.firstChild);
@@ -670,7 +743,7 @@ function emptyDomNode(domNode) {
 // ../utils/dist/dom/fixes.js
 function fixUpContinuousNodeArray(continuousNodeArray, parentNode) {
   if (continuousNodeArray.length) {
-    parentNode = parentNode.nodeType === 8 && parentNode.parentNode || parentNode;
+    parentNode = parentNode.nodeType === Node.COMMENT_NODE && parentNode.parentNode || parentNode;
     while (continuousNodeArray.length && continuousNodeArray[0].parentNode !== parentNode) {
       continuousNodeArray.splice(0, 1);
     }
@@ -678,7 +751,7 @@ function fixUpContinuousNodeArray(continuousNodeArray, parentNode) {
       continuousNodeArray.length--;
     }
     if (continuousNodeArray.length > 1) {
-      var current = continuousNodeArray[0], last = continuousNodeArray[continuousNodeArray.length - 1];
+      let current = continuousNodeArray[0], last = continuousNodeArray[continuousNodeArray.length - 1];
       continuousNodeArray.length = 0;
       while (current !== last) {
         continuousNodeArray.push(current);
@@ -690,26 +763,7 @@ function fixUpContinuousNodeArray(continuousNodeArray, parentNode) {
   return continuousNodeArray;
 }
 function setOptionNodeSelectionState(optionNode, isSelected) {
-  if (ieVersion < 7) {
-    optionNode.setAttribute("selected", isSelected);
-  } else {
-    optionNode.selected = isSelected;
-  }
-}
-function forceRefresh(node) {
-  if (ieVersion >= 9) {
-    var elem = node.nodeType == 1 ? node : node.parentNode;
-    if (elem.style) {
-      elem.style.zoom = elem.style.zoom;
-    }
-  }
-}
-function ensureSelectElementIsRenderedCorrectly(selectElement) {
-  if (ieVersion) {
-    var originalWidth = selectElement.style.width;
-    selectElement.style.width = 0;
-    selectElement.style.width = originalWidth;
-  }
+  optionNode.selected = isSelected;
 }
 
 // ../utils/dist/dom/virtualElements.js
@@ -734,24 +788,23 @@ __export(virtualElements_exports, {
   startCommentRegex: () => startCommentRegex,
   virtualNodeBindingValue: () => virtualNodeBindingValue
 });
-var commentNodesHaveTextProperty = options_default.document && options_default.document.createComment("test").text === "<!--test-->";
-var startCommentRegex = commentNodesHaveTextProperty ? /^<!--\s*ko(?:\s+([\s\S]+))?\s*-->$/ : /^\s*ko(?:\s+([\s\S]+))?\s*$/;
-var endCommentRegex = commentNodesHaveTextProperty ? /^<!--\s*\/ko\s*-->$/ : /^\s*\/ko\s*$/;
-var htmlTagsWithOptionallyClosingChildren = { "ul": true, "ol": true };
+var startCommentRegex = /^\s*ko(?:\s+([\s\S]+))?\s*$/;
+var endCommentRegex = /^\s*\/ko\s*$/;
+var htmlTagsWithOptionallyClosingChildren = { ul: true, ol: true };
 function isStartComment(node) {
-  return node.nodeType == 8 && startCommentRegex.test(commentNodesHaveTextProperty ? node.text : node.nodeValue);
+  return node.nodeType === Node.COMMENT_NODE && startCommentRegex.test(node.nodeValue);
 }
 function isEndComment(node) {
-  return node.nodeType == 8 && endCommentRegex.test(commentNodesHaveTextProperty ? node.text : node.nodeValue);
+  return node.nodeType === Node.COMMENT_NODE && endCommentRegex.test(node.nodeValue);
 }
 function isUnmatchedEndComment(node) {
   return isEndComment(node) && !get(node, matchedEndCommentDataKey);
 }
 var matchedEndCommentDataKey = "__ko_matchedEndComment__";
 function getVirtualChildren(startComment, allowUnbalanced) {
-  var currentNode = startComment;
-  var depth = 1;
-  var children = [];
+  let currentNode = startComment;
+  let depth = 1;
+  const children = new Array();
   while (currentNode = currentNode.nextSibling) {
     if (isEndComment(currentNode)) {
       set(currentNode, matchedEndCommentDataKey, true);
@@ -771,7 +824,7 @@ function getVirtualChildren(startComment, allowUnbalanced) {
   return null;
 }
 function getMatchingEndComment(startComment, allowUnbalanced) {
-  var allVirtualChildren = getVirtualChildren(startComment, allowUnbalanced);
+  const allVirtualChildren = getVirtualChildren(startComment, allowUnbalanced);
   if (allVirtualChildren) {
     if (allVirtualChildren.length > 0) {
       return allVirtualChildren[allVirtualChildren.length - 1].nextSibling;
@@ -782,13 +835,17 @@ function getMatchingEndComment(startComment, allowUnbalanced) {
   }
 }
 function getUnbalancedChildTags(node) {
-  var childNode = node.firstChild, captureRemaining = null;
+  let childNode = node.firstChild, captureRemaining = null;
   if (childNode) {
     do {
       if (captureRemaining) {
         captureRemaining.push(childNode);
       } else if (isStartComment(childNode)) {
-        var matchingEndComment = getMatchingEndComment(childNode, true);
+        const matchingEndComment = getMatchingEndComment(
+          childNode,
+          /* allowUnbalanced: */
+          true
+        );
         if (matchingEndComment) {
           childNode = matchingEndComment;
         } else {
@@ -801,7 +858,7 @@ function getUnbalancedChildTags(node) {
   }
   return captureRemaining;
 }
-var allowedBindings = {};
+var allowedBindings = /* @__PURE__ */ Object.create(null);
 var hasBindingValue = isStartComment;
 function childNodes(node) {
   return isStartComment(node) ? getVirtualChildren(node) : node.childNodes;
@@ -810,8 +867,8 @@ function emptyNode(node) {
   if (!isStartComment(node)) {
     emptyDomNode(node);
   } else {
-    var virtualChildren = childNodes(node);
-    for (var i = 0, j = virtualChildren.length; i < j; i++) {
+    const virtualChildren = childNodes(node);
+    for (let i = 0, j = virtualChildren.length; i < j; i++) {
       removeNode(virtualChildren[i]);
     }
   }
@@ -822,13 +879,16 @@ function setDomNodeChildren2(node, childNodes2) {
   } else {
     emptyNode(node);
     const endCommentNode = node.nextSibling;
-    const parentNode = endCommentNode.parentNode;
-    for (var i = 0, j = childNodes2.length; i < j; ++i) {
-      parentNode.insertBefore(childNodes2[i], endCommentNode);
+    if (endCommentNode && endCommentNode.parentNode) {
+      const parentNode = endCommentNode.parentNode;
+      for (let i = 0, j = childNodes2.length; i < j; ++i) {
+        parentNode.insertBefore(childNodes2[i], endCommentNode);
+      }
     }
   }
 }
 function prepend(containerNode, nodeToPrepend) {
+  var _a;
   if (!isStartComment(containerNode)) {
     if (containerNode.firstChild) {
       containerNode.insertBefore(nodeToPrepend, containerNode.firstChild);
@@ -836,10 +896,11 @@ function prepend(containerNode, nodeToPrepend) {
       containerNode.appendChild(nodeToPrepend);
     }
   } else {
-    containerNode.parentNode.insertBefore(nodeToPrepend, containerNode.nextSibling);
+    (_a = containerNode.parentNode) == null ? void 0 : _a.insertBefore(nodeToPrepend, containerNode.nextSibling);
   }
 }
 function insertAfter(containerNode, nodeToInsert, insertAfterNode) {
+  var _a;
   if (!insertAfterNode) {
     prepend(containerNode, nodeToInsert);
   } else if (!isStartComment(containerNode)) {
@@ -849,7 +910,7 @@ function insertAfter(containerNode, nodeToInsert, insertAfterNode) {
       containerNode.appendChild(nodeToInsert);
     }
   } else {
-    containerNode.parentNode.insertBefore(nodeToInsert, insertAfterNode.nextSibling);
+    (_a = containerNode.parentNode) == null ? void 0 : _a.insertBefore(nodeToInsert, insertAfterNode.nextSibling);
   }
 }
 function firstChild(node) {
@@ -866,6 +927,7 @@ function firstChild(node) {
 }
 function lastChild(node) {
   let nextChild = firstChild(node);
+  if (!nextChild) return null;
   let lastChildNode;
   do {
     lastChildNode = nextChild;
@@ -878,7 +940,9 @@ function nextSibling(node) {
   }
   if (node.nextSibling && isEndComment(node.nextSibling)) {
     if (isUnmatchedEndComment(node.nextSibling)) {
-      throw Error("Found end comment without a matching opening comment, as next sibling of " + node.outerHTML);
+      throw Error(
+        "Found end comment without a matching opening comment, as next sibling of " + node.outerHTML
+      );
     }
     return null;
   } else {
@@ -886,9 +950,9 @@ function nextSibling(node) {
   }
 }
 function previousSibling(node) {
-  var depth = 0;
+  let depth = 0;
   do {
-    if (node.nodeType === 8) {
+    if (node.nodeType === Node.COMMENT_NODE) {
       if (isStartComment(node)) {
         if (--depth === 0) {
           return node;
@@ -904,21 +968,21 @@ function previousSibling(node) {
   } while (node = node.previousSibling);
 }
 function virtualNodeBindingValue(node) {
-  var regexMatch = (commentNodesHaveTextProperty ? node.text : node.nodeValue).match(startCommentRegex);
+  const regexMatch = node.nodeValue.match(startCommentRegex);
   return regexMatch ? regexMatch[1] : null;
 }
 function normaliseVirtualElementDomStructure(elementVerified) {
   if (!htmlTagsWithOptionallyClosingChildren[tagNameLower(elementVerified)]) {
     return;
   }
-  var childNode = elementVerified.firstChild;
+  let childNode = elementVerified.firstChild;
   if (childNode) {
     do {
-      if (childNode.nodeType === 1) {
-        var unbalancedTags = getUnbalancedChildTags(childNode);
+      if (childNode.nodeType === Node.ELEMENT_NODE) {
+        const unbalancedTags = getUnbalancedChildTags(childNode);
         if (unbalancedTags) {
-          var nodeToInsertBefore = childNode.nextSibling;
-          for (var i = 0; i < unbalancedTags.length; i++) {
+          const nodeToInsertBefore = childNode.nextSibling;
+          for (let i = 0; i < unbalancedTags.length; i++) {
             if (nodeToInsertBefore) {
               elementVerified.insertBefore(unbalancedTags[i], nodeToInsertBefore);
             } else {
@@ -932,78 +996,48 @@ function normaliseVirtualElementDomStructure(elementVerified) {
 }
 
 // ../utils/dist/dom/html.js
-var none = [0, "", ""];
-var table = [1, "<table>", "</table>"];
-var tbody = [2, "<table><tbody>", "</tbody></table>"];
-var colgroup = [2, "<table><tbody></tbody><colgroup>", "</colgroup></table>"];
-var tr = [3, "<table><tbody><tr>", "</tr></tbody></table>"];
-var select = [1, "<select multiple='multiple'>", "</select>"];
-var fieldset = [1, "<fieldset>", "</fieldset>"];
-var map = [1, "<map>", "</map>"];
-var object = [1, "<object>", "</object>"];
-var lookup = {
-  "area": map,
-  "col": colgroup,
-  "colgroup": table,
-  "caption": table,
-  "legend": fieldset,
-  "thead": table,
-  "tbody": table,
-  "tfoot": table,
-  "tr": tbody,
-  "td": tr,
-  "th": tr,
-  "option": select,
-  "optgroup": select,
-  "param": object
-};
-var supportsTemplateTag = options_default.document && "content" in options_default.document.createElement("template");
-function getWrap(tags) {
-  const m = tags.match(/^(?:<!--.*?-->\s*?)*?<([a-z]+)[\s>]/);
-  return m && lookup[m[1]] || none;
-}
+var supportsTemplateTag = options_default.useTemplateTag && options_default.document && "content" in options_default.document.createElement("template");
 function simpleHtmlParse(html2, documentContext) {
-  documentContext || (documentContext = document);
-  var windowContext = documentContext["parentWindow"] || documentContext["defaultView"] || window;
-  var tags = stringTrim(html2).toLowerCase(), div = documentContext.createElement("div"), wrap = getWrap(tags), depth = wrap[0];
-  var markup = "ignored<div>" + wrap[1] + html2 + wrap[2] + "</div>";
-  if (typeof windowContext["innerShiv"] === "function") {
-    div.appendChild(windowContext["innerShiv"](markup));
-  } else {
-    div.innerHTML = markup;
-  }
-  while (depth--) {
-    div = div.lastChild;
+  if (!documentContext) {
+    documentContext = document;
   }
-  return makeArray(div.lastChild.childNodes);
+  const div = documentContext.createElement("div");
+  div.innerHTML = html2;
+  return makeArray(div.childNodes);
 }
 function templateHtmlParse(html2, documentContext) {
   if (!documentContext) {
     documentContext = document;
   }
-  var template = documentContext.createElement("template");
+  const template = documentContext.createElement("template");
   template.innerHTML = html2;
   return makeArray(template.content.childNodes);
 }
 function jQueryHtmlParse(html2, documentContext) {
-  if (jQueryInstance.parseHTML) {
-    return jQueryInstance.parseHTML(html2, documentContext) || [];
-  } else {
-    var elems = jQueryInstance.clean([html2], documentContext);
-    if (elems && elems[0]) {
-      var elem = elems[0];
-      while (elem.parentNode && elem.parentNode.nodeType !== 11) {
-        elem = elem.parentNode;
-      }
-      if (elem.parentNode) {
-        elem.parentNode.removeChild(elem);
-      }
-    }
-    return elems;
+  const jQuery2 = options_default.jQuery;
+  if (jQuery2) {
+    return jQuery2.parseHTML(html2, documentContext) || [];
   }
+  return [];
 }
 function parseHtmlFragment(html2, documentContext) {
-  return supportsTemplateTag ? templateHtmlParse(html2, documentContext) : jQueryInstance ? jQueryHtmlParse(html2, documentContext) : simpleHtmlParse(html2, documentContext);
+  const saferHtml = validateHTMLInput(html2);
+  if (supportsTemplateTag) return templateHtmlParse(saferHtml, documentContext);
+  if (options_default.jQuery) {
+    return jQueryHtmlParse(saferHtml, documentContext);
+  }
+  return simpleHtmlParse(saferHtml, documentContext);
+}
+var scriptTagPattern = /<script\b[^>]*>([\s\S]*?)<\/script[^>]*>/i;
+function validateHTMLInput(html2) {
+  if (!html2) return "";
+  if (options_default.templateSizeLimit > 0 && html2.length > options_default.templateSizeLimit) {
+    throw new Error("Template is too long. Please configure the 'templateSizeLimit'");
+  }
+  if (!options_default.allowScriptTagsInTemplates && scriptTagPattern.test(html2)) {
+    throw new Error("Script-tag in template detected.");
+  }
+  return options_default.sanitizeHtmlTemplate(html2);
 }
 function setHtml(node, html2) {
   emptyDomNode(node);
@@ -1014,18 +1048,25 @@ function setHtml(node, html2) {
     if (typeof html2 !== "string") {
       html2 = html2.toString();
     }
-    if (jQueryInstance && !supportsTemplateTag) {
-      jQueryInstance(node).html(html2);
+    const jQuery2 = options_default.jQuery;
+    if (jQuery2 && !supportsTemplateTag) {
+      const saferHtml = validateHTMLInput(html2);
+      jQuery2(node).html(saferHtml);
     } else {
-      var parsedNodes = parseHtmlFragment(html2, node.ownerDocument);
-      if (node.nodeType === 8) {
+      let parsedNodes;
+      if (node.ownerDocument) {
+        parsedNodes = parseHtmlFragment(html2, node.ownerDocument);
+      } else {
+        parsedNodes = parseHtmlFragment(html2);
+      }
+      if (node.nodeType === Node.COMMENT_NODE) {
         if (html2 === null) {
           emptyNode(node);
         } else {
           setDomNodeChildren2(node, parsedNodes);
         }
       } else {
-        for (var i = 0; i < parsedNodes.length; i++) {
+        for (let i = 0; i < parsedNodes.length; i++) {
           node.appendChild(parsedNodes[i]);
         }
       }
@@ -1033,32 +1074,35 @@ function setHtml(node, html2) {
   }
 }
 function setTextContent(element, textContent) {
-  var value2 = typeof textContent === "function" ? textContent() : textContent;
+  let value2 = typeof textContent === "function" ? textContent() : textContent;
   if (value2 === null || value2 === void 0) {
     value2 = "";
   }
-  var innerTextNode = firstChild(element);
-  if (!innerTextNode || innerTextNode.nodeType != 3 || nextSibling(innerTextNode)) {
+  const innerTextNode = firstChild(element);
+  if (!innerTextNode || innerTextNode.nodeType !== Node.TEXT_NODE || nextSibling(innerTextNode)) {
     setDomNodeChildren2(element, [element.ownerDocument.createTextNode(value2)]);
   } else {
+    ;
     innerTextNode.data = value2;
   }
-  forceRefresh(element);
 }
 
 // ../utils/dist/dom/selectExtensions.js
-var hasDomDataExpandoProperty = Symbol("Knockout selectExtensions hasDomDataProperty");
+var hasDomDataExpandoProperty = /* @__PURE__ */ Symbol("Knockout selectExtensions hasDomDataProperty");
 var selectExtensions = {
   optionValueDomDataKey: nextKey(),
   readValue: function(element) {
     switch (tagNameLower(element)) {
-      case "option":
+      case "option": {
         if (element[hasDomDataExpandoProperty] === true) {
           return get(element, selectExtensions.optionValueDomDataKey);
         }
         return element.value;
-      case "select":
-        return element.selectedIndex >= 0 ? selectExtensions.readValue(element.options[element.selectedIndex]) : void 0;
+      }
+      case "select": {
+        const selectElement = element;
+        return selectElement.selectedIndex >= 0 ? selectExtensions.readValue(selectElement.options[selectElement.selectedIndex]) : void 0;
+      }
       default:
         return element.value;
     }
@@ -1071,36 +1115,42 @@ var selectExtensions = {
           if (hasDomDataExpandoProperty in element) {
             delete element[hasDomDataExpandoProperty];
           }
+          ;
           element.value = value2;
         } else {
+          const el = element;
           set(element, selectExtensions.optionValueDomDataKey, value2);
-          element[hasDomDataExpandoProperty] = true;
-          element.value = typeof value2 === "number" ? value2 : "";
+          el[hasDomDataExpandoProperty] = true;
+          el.value = typeof value2 === "number" ? value2 : "";
         }
         break;
       case "select":
-        if (value2 === "" || value2 === null) {
-          value2 = void 0;
-        }
-        var selection = -1;
-        for (let i = 0, n = element.options.length, optionValue; i < n; ++i) {
-          optionValue = selectExtensions.readValue(element.options[i]);
-          const strictEqual = optionValue === value2;
-          const blankEqual = optionValue === "" && value2 === void 0;
-          const numericEqual = typeof value2 === "number" && Number(optionValue) === value2;
-          if (strictEqual || blankEqual || numericEqual) {
-            selection = i;
-            break;
+        {
+          if (value2 === "" || value2 === null) {
+            value2 = void 0;
+          }
+          let selection = -1;
+          const selectElement = element;
+          for (let i = 0, n = selectElement.options.length, optionValue; i < n; ++i) {
+            optionValue = selectExtensions.readValue(selectElement.options[i]);
+            const strictEqual = optionValue === value2;
+            const blankEqual = optionValue === "" && value2 === void 0;
+            const numericEqual = typeof value2 === "number" && Number(optionValue) === value2;
+            if (strictEqual || blankEqual || numericEqual) {
+              selection = i;
+              break;
+            }
+          }
+          if (allowUnset || selection >= 0 || value2 === void 0 && selectElement.size > 1) {
+            selectElement.selectedIndex = selection;
           }
-        }
-        if (allowUnset || selection >= 0 || value2 === void 0 && element.size > 1) {
-          element.selectedIndex = selection;
         }
         break;
       default:
         if (value2 === null || value2 === void 0) {
           value2 = "";
         }
+        ;
         element.value = value2;
         break;
     }
@@ -1115,30 +1165,19 @@ __export(tasks_exports, {
   runEarly: () => processTasks,
   schedule: () => schedule
 });
-var taskQueue = [];
+var taskQueue = new Array();
 var taskQueueLength = 0;
 var nextHandle = 1;
 var nextIndexToProcess = 0;
 var w = options_default.global;
 if (w && w.MutationObserver && !(w.navigator && w.navigator.standalone)) {
-  options_default.taskScheduler = function(callback) {
-    var div = w.document.createElement("div");
+  options_default.taskScheduler = (function(callback) {
+    const div = w.document.createElement("div");
     new w.MutationObserver(callback).observe(div, { attributes: true });
     return function() {
       div.classList.toggle("foo");
     };
-  }(scheduledProcess);
-} else if (w && w.document && "onreadystatechange" in w.document.createElement("script")) {
-  options_default.taskScheduler = function(callback) {
-    var script = document.createElement("script");
-    script.onreadystatechange = function() {
-      script.onreadystatechange = null;
-      document.documentElement.removeChild(script);
-      script = null;
-      callback();
-    };
-    document.documentElement.appendChild(script);
-  };
+  })(scheduledProcess);
 } else {
   options_default.taskScheduler = function(callback) {
     setTimeout(callback, 0);
@@ -1146,8 +1185,8 @@ if (w && w.MutationObserver && !(w.navigator && w.navigator.standalone)) {
 }
 function processTasks() {
   if (taskQueueLength) {
-    var mark = taskQueueLength, countMarks = 0;
-    for (var task; nextIndexToProcess < taskQueueLength; ) {
+    let mark = taskQueueLength, countMarks = 0;
+    for (let task; nextIndexToProcess < taskQueueLength; ) {
       if (task = taskQueue[nextIndexToProcess++]) {
         if (nextIndexToProcess > mark) {
           if (++countMarks >= 5e3) {
@@ -1181,13 +1220,13 @@ function schedule(func) {
   return nextHandle++;
 }
 function cancel(handle) {
-  var index = handle - (nextHandle - taskQueueLength);
+  const index = handle - (nextHandle - taskQueueLength);
   if (index >= nextIndexToProcess && index < taskQueueLength) {
     taskQueue[index] = null;
   }
 }
 function resetForTesting() {
-  var length = taskQueueLength - nextIndexToProcess;
+  const length = taskQueueLength - nextIndexToProcess;
   nextIndexToProcess = taskQueueLength = taskQueue.length = 0;
   return length;
 }
@@ -1206,13 +1245,13 @@ __export(dependencyDetection_exports, {
 });
 
 // ../observable/dist/subscribableSymbol.js
-var SUBSCRIBABLE_SYM = Symbol("Knockout Subscribable");
+var SUBSCRIBABLE_SYM = /* @__PURE__ */ Symbol("Knockout Subscribable");
 function isSubscribable(instance) {
   return instance && instance[SUBSCRIBABLE_SYM] || false;
 }
 
 // ../observable/dist/dependencyDetection.js
-var outerFrames = [];
+var outerFrames = new Array();
 var currentFrame;
 var lastId = 0;
 function getId() {
@@ -1230,7 +1269,11 @@ function registerDependency(subscribable2) {
     if (!isSubscribable(subscribable2)) {
       throw new Error("Only subscribable things can act as dependencies");
     }
-    currentFrame.callback.call(currentFrame.callbackTarget, subscribable2, subscribable2._id || (subscribable2._id = getId()));
+    currentFrame.callback.call(
+      currentFrame.callbackTarget,
+      subscribable2,
+      subscribable2._id || (subscribable2._id = getId())
+    );
   }
 }
 function ignore(callback, callbackTarget, callbackArgs) {
@@ -1245,16 +1288,19 @@ function getDependenciesCount() {
   if (currentFrame) {
     return currentFrame.computed.getDependenciesCount();
   }
+  return void 0;
 }
 function getDependencies() {
   if (currentFrame) {
     return currentFrame.computed.getDependencies();
   }
+  return void 0;
 }
 function isInitial() {
   if (currentFrame) {
     return currentFrame.isInitial;
   }
+  return void 0;
 }
 
 // ../observable/dist/defer.js
@@ -1301,6 +1347,7 @@ var Subscription = class {
     this._node = node;
     addDisposeCallback(node, this._domNodeDisposalCallback = this.dispose.bind(this));
   }
+  // TC39 Observable API
   unsubscribe() {
     this.dispose();
   }
@@ -1310,21 +1357,16 @@ var Subscription = class {
 };
 
 // ../observable/dist/extenders.js
-var primitiveTypes = {
-  "undefined": 1,
-  "boolean": 1,
-  "number": 1,
-  "string": 1
-};
+var primitiveTypes = { undefined: 1, boolean: 1, number: 1, string: 1 };
 function valuesArePrimitiveAndEqual(a, b) {
-  var oldValueIsPrimitive = a === null || typeof a in primitiveTypes;
+  const oldValueIsPrimitive = a === null || typeof a in primitiveTypes;
   return oldValueIsPrimitive ? a === b : false;
 }
 function applyExtenders(requestedExtenders) {
-  var target = this;
+  let target = this;
   if (requestedExtenders) {
     objectForEach(requestedExtenders, function(key, value2) {
-      var extenderHandler = extenders[key];
+      const extenderHandler = extenders[key];
       if (typeof extenderHandler === "function") {
         target = extenderHandler(target, value2) || target;
       } else {
@@ -1339,12 +1381,14 @@ function notify(target, notifyWhen) {
 }
 function deferred(target, option) {
   if (option !== true) {
-    throw new Error("The 'deferred' extender only accepts the value 'true', because it is not supported to turn deferral off once enabled.");
+    throw new Error(
+      "The 'deferred' extender only accepts the value 'true', because it is not supported to turn deferral off once enabled."
+    );
   }
   deferUpdates(target);
 }
 function rateLimit(target, options22) {
-  var timeout, method, limitFunction;
+  let timeout, method, limitFunction;
   if (typeof options22 === "number") {
     timeout = options22;
   } else {
@@ -1357,21 +1401,17 @@ function rateLimit(target, options22) {
     return limitFunction(callback, timeout);
   });
 }
-var extenders = {
-  notify,
-  deferred,
-  rateLimit
-};
+var extenders = { notify, deferred, rateLimit };
 
 // ../observable/dist/subscribable.js
-var LATEST_VALUE = Symbol("Knockout latest value");
+var LATEST_VALUE = /* @__PURE__ */ Symbol("Knockout latest value");
 if (!Symbol.observable) {
-  Symbol.observable = Symbol.for("@tko/Symbol.observable");
+  Symbol.observable = /* @__PURE__ */ Symbol.for("@tko/Symbol.observable");
 }
-function subscribable() {
+var subscribable = function subscribableFactory() {
   Object.setPrototypeOf(this, ko_subscribable_fn);
   ko_subscribable_fn.init(this);
-}
+};
 var defaultEvent = "change";
 var ko_subscribable_fn = {
   [SUBSCRIBABLE_SYM]: true,
@@ -1385,9 +1425,7 @@ var ko_subscribable_fn = {
   subscribe(callback, callbackTarget, event) {
     const isTC39Callback = typeof callback === "object" && callback.next;
     event = event || defaultEvent;
-    const observer = isTC39Callback ? callback : {
-      next: callbackTarget ? callback.bind(callbackTarget) : callback
-    };
+    const observer = isTC39Callback ? callback : { next: callbackTarget ? callback.bind(callbackTarget) : callback };
     const subscriptionInstance = new Subscription(this, observer, () => {
       arrayRemoveItem(this._subscriptions[event], subscriptionInstance);
       if (this.afterSubscriptionRemove) {
@@ -1398,7 +1436,7 @@ var ko_subscribable_fn = {
       this.beforeSubscriptionAdd(event);
     }
     if (!this._subscriptions[event]) {
-      this._subscriptions[event] = [];
+      this._subscriptions[event] = new Array();
     }
     this._subscriptions[event].push(subscriptionInstance);
     if (isTC39Callback && LATEST_VALUE in this) {
@@ -1441,7 +1479,7 @@ var ko_subscribable_fn = {
     if (event) {
       return this._subscriptions[event] && this._subscriptions[event].length || 0;
     } else {
-      var total = 0;
+      let total = 0;
       objectForEach(this._subscriptions, function(eventName, subscriptions) {
         if (eventName !== "dirty") {
           total += subscriptions.length;
@@ -1496,6 +1534,7 @@ function observable(initialValue) {
   function Observable() {
     if (arguments.length > 0) {
       if (Observable.isDifferent(Observable[LATEST_VALUE], arguments[0])) {
+        ;
         Observable.valueWillMutate();
         Observable[LATEST_VALUE] = arguments[0];
         Observable.valueHasMutated();
@@ -1516,20 +1555,43 @@ function observable(initialValue) {
   return Observable;
 }
 observable.fn = {
+  /**
+   * Compares two values for equality.
+   * @param a The first value.
+   * @param b The second value.
+   * @returns True if the values are equal, otherwise false.
+   */
   equalityComparer: valuesArePrimitiveAndEqual,
+  /**
+   * Returns the current value of the observable without creating a dependency.
+   * @returns The current value.
+   */
   peek() {
     return this[LATEST_VALUE];
   },
+  /**
+   * Notifies subscribers that the value has changed.
+   */
   valueHasMutated() {
     this.notifySubscribers(this[LATEST_VALUE], "spectate");
     this.notifySubscribers(this[LATEST_VALUE]);
   },
+  /**
+   * Notifies subscribers that the value is about to change.
+   */
   valueWillMutate() {
     this.notifySubscribers(this[LATEST_VALUE], "beforeChange");
   },
+  /**
+   * Modifies the value of the observable using a function.
+   * @param fn The function to modify the value.
+   * @param peek Whether to use the current value without creating a dependency.
+   * @returns The modified observable.
+   */
   modify(fn, peek22 = true) {
-    return this(fn(peek22 ? this.peek() : this()));
+    this(fn(peek22 ? this.peek() : this()));
   },
+  // Some observables may not always be writeable, notably computeds.
   isWriteable: true
 };
 function limitNotifySubscribers(value2, event) {
@@ -1542,15 +1604,15 @@ function limitNotifySubscribers(value2, event) {
   }
 }
 subscribable.fn.limit = function limit(limitFunction) {
-  var self = this;
-  var selfIsObservable = isObservable(self);
-  var beforeChange = "beforeChange";
-  var ignoreBeforeChange, notifyNextChange, previousValue, pendingValue, didUpdate;
+  const self = this;
+  const selfIsObservable = isObservable(self);
+  const beforeChange = "beforeChange";
+  let ignoreBeforeChange, notifyNextChange, previousValue, pendingValue, didUpdate;
   if (!self._origNotifySubscribers) {
     self._origNotifySubscribers = self.notifySubscribers;
     self.notifySubscribers = limitNotifySubscribers;
   }
-  var finish = limitFunction(function() {
+  const finish = limitFunction(function() {
     self._notificationIsPending = false;
     if (selfIsObservable && pendingValue === self) {
       pendingValue = self._evalIfChanged ? self._evalIfChanged() : self();
@@ -1578,7 +1640,10 @@ subscribable.fn.limit = function limit(limitFunction) {
       }
     },
     _notifyNextChangeIfValueIsDifferent() {
-      if (self.isDifferent(previousValue, self.peek(true))) {
+      if (self.isDifferent(previousValue, self.peek(
+        true
+        /* evaluate */
+      ))) {
         notifyNextChange = true;
       }
     },
@@ -1621,8 +1686,8 @@ function trackArrayChanges(target, options3) {
   let arrayChangeSubscription;
   let pendingNotifications = 0;
   let underlyingNotifySubscribersFunction;
-  let underlyingBeforeSubscriptionAddFunction = target.beforeSubscriptionAdd;
-  let underlyingAfterSubscriptionRemoveFunction = target.afterSubscriptionRemove;
+  const underlyingBeforeSubscriptionAddFunction = target.beforeSubscriptionAdd;
+  const underlyingAfterSubscriptionRemoveFunction = target.afterSubscriptionRemove;
   target.beforeSubscriptionAdd = function(event) {
     if (underlyingBeforeSubscriptionAddFunction) {
       underlyingBeforeSubscriptionAddFunction.call(target, event);
@@ -1659,11 +1724,11 @@ function trackArrayChanges(target, options3) {
       }
       return underlyingNotifySubscribersFunction.apply(this, arguments);
     };
-    var previousContents = [].concat(target.peek() === void 0 ? [] : target.peek());
+    let previousContents = new Array().concat(target.peek() === void 0 ? [] : target.peek());
     cachedDiff = null;
     arrayChangeSubscription = target.subscribe(function(currentContents) {
       let changes;
-      currentContents = [].concat(currentContents || []);
+      currentContents = new Array().concat(currentContents || []);
       if (target.hasSubscriptionsForEvent(arrayChangeEventName)) {
         changes = getChanges(previousContents, currentContents);
       }
@@ -1685,9 +1750,9 @@ function trackArrayChanges(target, options3) {
     if (!trackingChanges || pendingNotifications) {
       return;
     }
-    var diff = [], arrayLength = rawArray.length, argsLength = args.length, offset = 0;
+    let diff = new Array(), arrayLength = rawArray.length, argsLength = args.length, offset = 0;
     function pushDiff(status, value2, index) {
-      return diff[diff.length] = { "status": status, "value": value2, "index": index };
+      return diff[diff.length] = { status, value: value2, index };
     }
     switch (operationName) {
       case "push":
@@ -1705,16 +1770,18 @@ function trackArrayChanges(target, options3) {
         }
         break;
       case "splice":
-        var startIndex = Math.min(Math.max(0, args[0] < 0 ? arrayLength + args[0] : args[0]), arrayLength), endDeleteIndex = argsLength === 1 ? arrayLength : Math.min(startIndex + (args[1] || 0), arrayLength), endAddIndex = startIndex + argsLength - 2, endIndex = Math.max(endDeleteIndex, endAddIndex), additions = [], deletions = [];
-        for (let index = startIndex, argsIndex = 2; index < endIndex; ++index, ++argsIndex) {
-          if (index < endDeleteIndex) {
-            deletions.push(pushDiff("deleted", rawArray[index], index));
-          }
-          if (index < endAddIndex) {
-            additions.push(pushDiff("added", args[argsIndex], index));
+        {
+          const startIndex = Math.min(Math.max(0, args[0] < 0 ? arrayLength + args[0] : args[0]), arrayLength), endDeleteIndex = argsLength === 1 ? arrayLength : Math.min(startIndex + (args[1] || 0), arrayLength), endAddIndex = startIndex + argsLength - 2, endIndex = Math.max(endDeleteIndex, endAddIndex), additions = new Array(), deletions = new Array();
+          for (let index = startIndex, argsIndex = 2; index < endIndex; ++index, ++argsIndex) {
+            if (index < endDeleteIndex) {
+              deletions.push(pushDiff("deleted", rawArray[index], index));
+            }
+            if (index < endAddIndex) {
+              additions.push(pushDiff("added", args[argsIndex], index));
+            }
           }
+          findMovesInArrayComparison(deletions, additions);
         }
-        findMovesInArrayComparison(deletions, additions);
         break;
       default:
         return;
@@ -1729,23 +1796,27 @@ extenders.trackArrayChanges = trackArrayChanges;
 function observableArray(initialValues) {
   initialValues = initialValues || [];
   if (typeof initialValues !== "object" || !("length" in initialValues)) {
-    throw new Error("The argument passed when initializing an observable array must be an array, or null, or undefined.");
+    throw new Error(
+      "The argument passed when initializing an observable array must be an array, or null, or undefined."
+    );
   }
-  var result = observable(initialValues);
-  Object.setPrototypeOf(result, observableArray.fn);
+  const result = Object.setPrototypeOf(observable(initialValues), observableArray.fn);
   trackArrayChanges(result);
-  overwriteLengthPropertyIfSupported(result, { get: () => result().length });
+  overwriteLengthPropertyIfSupported(result, { get: () => {
+    var _a;
+    return (_a = result()) == null ? void 0 : _a.length;
+  } });
   return result;
 }
 observableArray.fn = {
   remove(valueOrPredicate) {
-    var underlyingArray = this.peek();
-    var removedValues = [];
-    var predicate = typeof valueOrPredicate === "function" && !isObservable(valueOrPredicate) ? valueOrPredicate : function(value22) {
-      return value22 === valueOrPredicate;
+    const underlyingArray = this.peek();
+    const removedValues = new Array();
+    const predicate = typeof valueOrPredicate === "function" && !isObservable(valueOrPredicate) ? valueOrPredicate : function(value2) {
+      return value2 === valueOrPredicate;
     };
-    for (var i = 0; i < underlyingArray.length; i++) {
-      var value2 = underlyingArray[i];
+    for (let i = 0; i < underlyingArray.length; i++) {
+      const value2 = underlyingArray[i];
       if (predicate(value2)) {
         if (removedValues.length === 0) {
           this.valueWillMutate();
@@ -1765,8 +1836,8 @@ observableArray.fn = {
   },
   removeAll(arrayOfValues) {
     if (arrayOfValues === void 0) {
-      var underlyingArray = this.peek();
-      var allValues = underlyingArray.slice(0);
+      const underlyingArray = this.peek();
+      const allValues = underlyingArray.slice(0);
       this.valueWillMutate();
       underlyingArray.splice(0, underlyingArray.length);
       this.valueHasMutated();
@@ -1780,13 +1851,13 @@ observableArray.fn = {
     });
   },
   destroy(valueOrPredicate) {
-    var underlyingArray = this.peek();
-    var predicate = typeof valueOrPredicate === "function" && !isObservable(valueOrPredicate) ? valueOrPredicate : function(value22) {
-      return value22 === valueOrPredicate;
+    const underlyingArray = this.peek();
+    const predicate = typeof valueOrPredicate === "function" && !isObservable(valueOrPredicate) ? valueOrPredicate : function(value2) {
+      return value2 === valueOrPredicate;
     };
     this.valueWillMutate();
-    for (var i = underlyingArray.length - 1; i >= 0; i--) {
-      var value2 = underlyingArray[i];
+    for (let i = underlyingArray.length - 1; i >= 0; i--) {
+      const value2 = underlyingArray[i];
       if (predicate(value2)) {
         value2["_destroy"] = true;
       }
@@ -1810,7 +1881,7 @@ observableArray.fn = {
     return arrayIndexOf(this(), item);
   },
   replace(oldItem, newItem) {
-    var index = this.indexOf(oldItem);
+    const index = this.indexOf(oldItem);
     if (index >= 0) {
       this.valueWillMutate();
       this.peek()[index] = newItem;
@@ -1824,23 +1895,23 @@ observableArray.fn = {
     return [...this()].reverse();
   },
   [Symbol.iterator]: function* () {
-    yield* this();
+    yield* __yieldStar(this());
   }
 };
 Object.setPrototypeOf(observableArray.fn, observable.fn);
 arrayForEach(["pop", "push", "reverse", "shift", "sort", "splice", "unshift"], function(methodName) {
   observableArray.fn[methodName] = function() {
-    var underlyingArray = this.peek();
+    const underlyingArray = this.peek();
     this.valueWillMutate();
     this.cacheDiffForKnownOperation(underlyingArray, methodName, arguments);
-    var methodCallResult = underlyingArray[methodName].apply(underlyingArray, arguments);
+    const methodCallResult = underlyingArray[methodName].apply(underlyingArray, arguments);
     this.valueHasMutated();
     return methodCallResult === underlyingArray ? this : methodCallResult;
   };
 });
 arrayForEach(["slice"], function(methodName) {
   observableArray.fn[methodName] = function() {
-    var underlyingArray = this();
+    const underlyingArray = this();
     return underlyingArray[methodName].apply(underlyingArray, arguments);
   };
 });
@@ -1848,12 +1919,12 @@ observableArray.trackArrayChanges = trackArrayChanges;
 
 // src/attr.ts
 var attr = {
-  update: function(element, valueAccessor, allBindings) {
-    var value2 = unwrap(valueAccessor()) || {};
+  update: function(element, valueAccessor, _allBindings) {
+    const value2 = unwrap(valueAccessor()) || {};
     objectForEach(value2, function(attrName, attrValue) {
       attrValue = unwrap(attrValue);
-      var prefixLen = attrName.indexOf(":");
-      var namespace = prefixLen > 0 && element.lookupNamespaceURI(attrName.substr(0, prefixLen));
+      const prefixLen = attrName.indexOf(":");
+      const namespace = prefixLen > 0 && element.lookupNamespaceURI(attrName.substr(0, prefixLen));
       const toRemove = attrValue === false || attrValue === null || attrValue === void 0;
       if (toRemove) {
         if (namespace) {
@@ -1870,7 +1941,7 @@ var attr = {
         }
       }
       if (attrName === "name") {
-        setElementName(element, toRemove ? "" : attrValue);
+        element.name = toRemove ? "" : attrValue;
       }
     });
   }
@@ -1898,11 +1969,11 @@ function computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget, options22
       options22.read = evaluatorFunctionOrOptions;
     }
   }
-  if (typeof options22.read !== "function") {
+  if (typeof (options22 == null ? void 0 : options22.read) !== "function") {
     throw Error("Pass a function that returns the value of the computed");
   }
-  var writeFunction = options22.write;
-  var state = {
+  const writeFunction = options22.write;
+  const state = {
     latestValue: void 0,
     isStale: true,
     isDirty: true,
@@ -1913,8 +1984,8 @@ function computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget, options22
     isSleeping: false,
     readFunction: options22.read,
     evaluatorFunctionTarget: evaluatorFunctionTarget || options22.owner,
-    disposeWhenNodeIsRemoved: options22.disposeWhenNodeIsRemoved || options22.disposeWhenNodeIsRemoved || null,
-    disposeWhen: options22.disposeWhen || options22.disposeWhen,
+    disposeWhenNodeIsRemoved: options22.disposeWhenNodeIsRemoved || null,
+    disposeWhen: options22.disposeWhen,
     domNodeDisposalCallback: null,
     dependencyTracking: {},
     dependenciesCount: 0,
@@ -1925,7 +1996,9 @@ function computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget, options22
       if (typeof writeFunction === "function") {
         writeFunction.apply(state.evaluatorFunctionTarget, arguments);
       } else {
-        throw new Error("Cannot write a value to a computed unless you specify a 'write' option. If you wish to read the current value, don't pass any parameters.");
+        throw new Error(
+          "Cannot write a value to a computed unless you specify a 'write' option. If you wish to read the current value, don't pass any parameters."
+        );
       }
       return this;
     } else {
@@ -1933,6 +2006,7 @@ function computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget, options22
         dependencyDetection_exports.registerDependency(computedObservable);
       }
       if (state.isDirty || state.isSleeping && computedObservable.haveDependenciesChanged()) {
+        ;
         computedObservable.evaluateImmediate();
       }
       return state.latestValue;
@@ -1962,12 +2036,17 @@ function computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget, options22
     }
   }
   if (!state.isSleeping && !options22.deferEvaluation) {
+    ;
     computedObservable.evaluateImmediate();
   }
   if (state.disposeWhenNodeIsRemoved && computedObservable.isActive()) {
-    addDisposeCallback(state.disposeWhenNodeIsRemoved, state.domNodeDisposalCallback = function() {
-      computedObservable.dispose();
-    });
+    addDisposeCallback(
+      state.disposeWhenNodeIsRemoved,
+      state.domNodeDisposalCallback = function() {
+        ;
+        computedObservable.dispose();
+      }
+    );
   }
   return computedObservable;
 }
@@ -1977,14 +2056,18 @@ function computedDisposeDependencyCallback(id, entryToDispose) {
   }
 }
 function computedBeginDependencyDetectionCallback(subscribable2, id) {
-  var computedObservable = this.computedObservable, state = computedObservable[computedState];
+  const computedObservable = this.computedObservable, state = computedObservable[computedState];
   if (!state.isDisposed) {
     if (this.disposalCount && this.disposalCandidates[id]) {
       computedObservable.addDependencyTracking(id, subscribable2, this.disposalCandidates[id]);
       this.disposalCandidates[id] = null;
       --this.disposalCount;
     } else if (!state.dependencyTracking[id]) {
-      computedObservable.addDependencyTracking(id, subscribable2, state.isSleeping ? { _target: subscribable2 } : computedObservable.subscribeToDependency(subscribable2));
+      computedObservable.addDependencyTracking(
+        id,
+        subscribable2,
+        state.isSleeping ? { _target: subscribable2 } : computedObservable.subscribeToDependency(subscribable2)
+      );
     }
     if (subscribable2._notificationIsPending) {
       subscribable2._notifyNextChangeIfValueIsDifferent();
@@ -1998,7 +2081,7 @@ computed.fn = {
   },
   getDependencies() {
     const dependencyTracking = this[computedState].dependencyTracking;
-    const dependentObservables = [];
+    const dependentObservables = new Array();
     objectForEach(dependencyTracking, function(id, dependency) {
       dependentObservables[dependency._order] = dependency._target;
     });
@@ -2013,7 +2096,7 @@ computed.fn = {
     trackingObj._version = target.getVersion();
   },
   haveDependenciesChanged() {
-    var id, dependency, dependencyTracking = this[computedState].dependencyTracking;
+    let id, dependency, dependencyTracking = this[computedState].dependencyTracking;
     for (id in dependencyTracking) {
       if (hasOwnProperty(dependencyTracking, id)) {
         dependency = dependencyTracking[id];
@@ -2022,10 +2105,14 @@ computed.fn = {
         }
       }
     }
+    return false;
   },
   markDirty() {
     if (this._evalDelayed && !this[computedState].isBeingEvaluated) {
-      this._evalDelayed(false);
+      this._evalDelayed(
+        false
+        /* notifyChange */
+      );
     }
   },
   isActive() {
@@ -2041,7 +2128,7 @@ computed.fn = {
   },
   subscribeToDependency(target) {
     if (target._deferUpdates) {
-      var dirtySub = target.subscribe(this.markDirty, this, "dirty"), changeSub = target.subscribe(this.respondToChange, this);
+      const dirtySub = target.subscribe(this.markDirty, this, "dirty"), changeSub = target.subscribe(this.respondToChange, this);
       return {
         _target: target,
         dispose() {
@@ -2054,20 +2141,29 @@ computed.fn = {
     }
   },
   evaluatePossiblyAsync() {
-    var computedObservable = this, throttleEvaluationTimeout = computedObservable.throttleEvaluation;
+    const computedObservable = this, throttleEvaluationTimeout = computedObservable.throttleEvaluation;
     if (throttleEvaluationTimeout && throttleEvaluationTimeout >= 0) {
       clearTimeout(this[computedState].evaluationTimeoutInstance);
       this[computedState].evaluationTimeoutInstance = safeSetTimeout(function() {
-        computedObservable.evaluateImmediate(true);
+        computedObservable.evaluateImmediate(
+          true
+          /* notifyChange */
+        );
       }, throttleEvaluationTimeout);
     } else if (computedObservable._evalDelayed) {
-      computedObservable._evalDelayed(true);
+      computedObservable._evalDelayed(
+        true
+        /* notifyChange */
+      );
     } else {
-      computedObservable.evaluateImmediate(true);
+      computedObservable.evaluateImmediate(
+        true
+        /* notifyChange */
+      );
     }
   },
   evaluateImmediate(notifyChange) {
-    var computedObservable = this, state = computedObservable[computedState], disposeWhen = state.disposeWhen, changed = false;
+    let computedObservable = this, state = computedObservable[computedState], disposeWhen = state.disposeWhen, changed = false;
     if (state.isBeingEvaluated) {
       return;
     }
@@ -2091,8 +2187,8 @@ computed.fn = {
     return changed;
   },
   evaluateImmediate_CallReadWithDependencyDetection(notifyChange) {
-    var computedObservable = this, state = computedObservable[computedState], changed = false;
-    var isInitial2 = state.pure ? void 0 : !state.dependenciesCount, dependencyDetectionContext = {
+    let computedObservable = this, state = computedObservable[computedState], changed = false;
+    const isInitial2 = state.pure ? void 0 : !state.dependenciesCount, dependencyDetectionContext = {
       computedObservable,
       disposalCandidates: state.dependencyTracking,
       disposalCount: state.dependenciesCount
@@ -2105,7 +2201,7 @@ computed.fn = {
     });
     state.dependencyTracking = {};
     state.dependenciesCount = 0;
-    var newValue = this.evaluateImmediate_CallReadThenEndDependencyDetection(state, dependencyDetectionContext);
+    const newValue = this.evaluateImmediate_CallReadThenEndDependencyDetection(state, dependencyDetectionContext);
     if (!state.dependenciesCount) {
       computedObservable.dispose();
       changed = true;
@@ -2137,7 +2233,7 @@ computed.fn = {
   },
   evaluateImmediate_CallReadThenEndDependencyDetection(state, dependencyDetectionContext) {
     try {
-      var readFunction = state.readFunction;
+      const readFunction = state.readFunction;
       return state.evaluatorFunctionTarget ? readFunction.call(state.evaluatorFunctionTarget) : readFunction();
     } finally {
       dependencyDetection_exports.end();
@@ -2177,12 +2273,16 @@ computed.fn = {
         if (isChange) {
           state.isStale = true;
         }
-        this._limitChange(this, !isChange);
+        this._limitChange(
+          this,
+          !isChange
+          /* isDirty */
+        );
       }
     });
   },
   dispose() {
-    var state = this[computedState];
+    const state = this[computedState];
     if (!state.isSleeping && state.dependencyTracking) {
       objectForEach(state.dependencyTracking, function(id, dependency) {
         if (dependency.dispose) {
@@ -2198,7 +2298,7 @@ computed.fn = {
 };
 var pureComputedOverrides = {
   beforeSubscriptionAdd(event) {
-    var computedObservable = this, state = computedObservable[computedState];
+    const computedObservable = this, state = computedObservable[computedState];
     if (!state.isDisposed && state.isSleeping && event === "change") {
       state.isSleeping = false;
       if (state.isStale || computedObservable.haveDependenciesChanged()) {
@@ -2208,12 +2308,12 @@ var pureComputedOverrides = {
           computedObservable.updateVersion();
         }
       } else {
-        var dependenciesOrder = [];
+        const dependenciesOrder = new Array();
         objectForEach(state.dependencyTracking, function(id, dependency) {
           dependenciesOrder[dependency._order] = id;
         });
         arrayForEach(dependenciesOrder, function(id, order) {
-          var dependency = state.dependencyTracking[id], subscription = computedObservable.subscribeToDependency(dependency._target);
+          const dependency = state.dependencyTracking[id], subscription = computedObservable.subscribeToDependency(dependency._target);
           subscription._order = order;
           subscription._version = dependency._version;
           state.dependencyTracking[id] = subscription;
@@ -2230,7 +2330,7 @@ var pureComputedOverrides = {
     }
   },
   afterSubscriptionRemove(event) {
-    var state = this[computedState];
+    const state = this[computedState];
     if (!state.isDisposed && event === "change" && !this.hasSubscriptionsForEvent("change")) {
       objectForEach(state.dependencyTracking, function(id, dependency) {
         if (dependency.dispose) {
@@ -2247,7 +2347,7 @@ var pureComputedOverrides = {
     }
   },
   getVersion() {
-    var state = this[computedState];
+    const state = this[computedState];
     if (state.isSleeping && (state.isStale || this.haveDependenciesChanged())) {
       this.evaluateImmediate();
     }
@@ -2267,18 +2367,20 @@ computed.fn[protoProp] = computed;
 observable.observablePrototypes.add(computed);
 function pureComputed(evaluatorFunctionOrOptions, evaluatorFunctionTarget) {
   if (typeof evaluatorFunctionOrOptions === "function") {
-    return computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget, { "pure": true });
+    const evaluator = evaluatorFunctionOrOptions;
+    return computed(evaluator, evaluatorFunctionTarget, { pure: true });
   } else {
-    evaluatorFunctionOrOptions = extend({}, evaluatorFunctionOrOptions);
-    evaluatorFunctionOrOptions.pure = true;
-    return computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget);
+    let options22 = evaluatorFunctionOrOptions;
+    options22 = extend({}, options22);
+    options22.pure = true;
+    return computed(options22, evaluatorFunctionTarget);
   }
 }
 
 // ../computed/dist/throttleExtender.js
 function throttleExtender(target, timeout) {
   target.throttleEvaluation = timeout;
-  var writeTimeoutInstance = null;
+  let writeTimeoutInstance = void 0;
   return computed({
     read: target,
     write: function(value2) {
@@ -2289,11 +2391,12 @@ function throttleExtender(target, timeout) {
     }
   });
 }
-extenders.throttle = throttleExtender;
+var extenders2 = extenders;
+extenders2.throttle = throttleExtender;
 
 // ../computed/dist/proxy.js
-var PROXY_SYM = Symbol("Knockout Proxied Object");
-var MIRROR_SYM = Symbol("Knockout Proxied Observables");
+var PROXY_SYM = /* @__PURE__ */ Symbol("Knockout Proxied Object");
+var MIRROR_SYM = /* @__PURE__ */ Symbol("Knockout Proxied Observables");
 function makeComputed(proxy2, fn) {
   return computed({
     owner: proxy2,
@@ -2311,14 +2414,14 @@ function setOrCreate(mirror, prop, value2, proxy2) {
     mirror[prop](value2);
   }
 }
-function assignOrUpdate(mirror, object2, proxy2) {
-  for (const key of Object.keys(object2)) {
-    setOrCreate(mirror, key, object2[key], proxy2);
+function assignOrUpdate(mirror, object, proxy2) {
+  for (const key of Object.keys(object)) {
+    setOrCreate(mirror, key, object[key], proxy2);
   }
-  return object2;
+  return object;
 }
-function proxy(object2) {
-  const mirror = { [PROXY_SYM]: object2 };
+function proxy(object) {
+  const mirror = { [PROXY_SYM]: object };
   mirror[MIRROR_SYM] = mirror;
   const proxy2 = new Proxy(function() {
   }, {
@@ -2330,43 +2433,40 @@ function proxy(object2) {
     },
     set(target, prop, value2, receiver) {
       setOrCreate(mirror, prop, value2, proxy2);
-      object2[prop] = value2;
+      object[prop] = value2;
       return true;
     },
     deleteProperty(property) {
       delete mirror[property];
-      return delete object2[property];
+      return delete object[property];
     },
     apply(target, thisArg, [props]) {
       if (props) {
         assignOrUpdate(mirror, props, proxy2);
-        return Object.assign(object2, props);
+        return Object.assign(object, props);
       }
-      return object2;
+      return object;
     },
     getPrototypeOf() {
-      return Object.getPrototypeOf(object2);
+      return Object.getPrototypeOf(object);
     },
     setPrototypeOf(target, proto) {
-      return Object.setPrototypeOf(object2, proto);
+      return Object.setPrototypeOf(object, proto);
     },
     defineProperty(target, prop, desc) {
-      return Object.defineProperty(object2, prop, desc);
+      return Object.defineProperty(object, prop, desc);
     },
     preventExtensions() {
-      return Object.preventExtensions(object2);
+      return Object.preventExtensions(object);
     },
     isExtensible() {
-      return Object.isExtensible(object2);
+      return Object.isExtensible(object);
     },
     ownKeys() {
-      return [
-        ...Object.getOwnPropertyNames(object2),
-        ...Object.getOwnPropertySymbols(object2)
-      ];
+      return [...Object.getOwnPropertyNames(object), ...Object.getOwnPropertySymbols(object)];
     }
   });
-  assignOrUpdate(mirror, object2, proxy2);
+  assignOrUpdate(mirror, object, proxy2);
   return proxy2;
 }
 function getObservable(proxied, prop) {
@@ -2384,7 +2484,7 @@ Object.assign(proxy, { getObservable, peek: peek2, isProxied });
 var checked = {
   after: ["value", "attr"],
   init: function(element, valueAccessor, allBindings) {
-    var checkedValue2 = pureComputed(function() {
+    const checkedValue2 = pureComputed(function() {
       if (allBindings.has("checkedValue")) {
         return unwrap(allBindings.get("checkedValue"));
       } else if (useElementValue) {
@@ -2396,16 +2496,16 @@ var checked = {
       }
     });
     function updateModel() {
-      var isChecked = element.checked, elemValue = checkedValue2();
+      let isChecked = element.checked, elemValue = checkedValue2();
       if (dependencyDetection_exports.isInitial()) {
         return;
       }
       if (!isChecked && (isRadio || dependencyDetection_exports.getDependenciesCount())) {
         return;
       }
-      var modelValue = dependencyDetection_exports.ignore(valueAccessor);
+      const modelValue = dependencyDetection_exports.ignore(valueAccessor);
       if (valueIsArray) {
-        var writableValue = rawValueIsNonArrayObservable ? modelValue.peek() : modelValue, saveOldValue = oldElemValue;
+        const writableValue = rawValueIsNonArrayObservable ? modelValue.peek() : modelValue, saveOldValue = oldElemValue;
         oldElemValue = elemValue;
         if (saveOldValue !== elemValue) {
           if (isChecked) {
@@ -2427,13 +2527,15 @@ var checked = {
             elemValue = void 0;
           }
         }
-        valueAccessor(elemValue, { onlyIfChanged: true });
+        const modelValue2 = valueAccessor(elemValue, { onlyIfChanged: true });
+        if (isWriteableObservable(modelValue2) && modelValue2.peek() !== elemValue) {
+          modelValue2(elemValue);
+        }
       }
     }
-    ;
     function updateView() {
-      var modelValue = modelValue = unwrap(valueAccessor());
-      var elemValue = checkedValue2();
+      const modelValue = unwrap(valueAccessor());
+      const elemValue = checkedValue2();
       if (valueIsArray) {
         element.checked = arrayIndexOf(modelValue, elemValue) >= 0;
         oldElemValue = elemValue;
@@ -2443,12 +2545,11 @@ var checked = {
         element.checked = checkedValue2() === modelValue;
       }
     }
-    ;
-    var isCheckbox = element.type == "checkbox", isRadio = element.type == "radio";
+    const isCheckbox = element.type == "checkbox", isRadio = element.type == "radio";
     if (!isCheckbox && !isRadio) {
       return;
     }
-    var rawValue = valueAccessor(), valueIsArray = isCheckbox && unwrap(rawValue) instanceof Array, rawValueIsNonArrayObservable = !(valueIsArray && rawValue.push && rawValue.splice), useElementValue = isRadio || valueIsArray, oldElemValue = valueIsArray ? checkedValue2() : void 0;
+    let rawValue = valueAccessor(), valueIsArray = isCheckbox && unwrap(rawValue) instanceof Array, rawValueIsNonArrayObservable = !(valueIsArray && rawValue.push && rawValue.splice), useElementValue = isRadio || valueIsArray, oldElemValue = valueIsArray ? checkedValue2() : void 0;
     computed(updateModel, null, { disposeWhenNodeIsRemoved: element });
     registerEventHandler(element, "click", updateModel);
     computed(updateView, null, { disposeWhenNodeIsRemoved: element });
@@ -2465,8 +2566,8 @@ var checkedValue = {
 function makeEventHandlerShortcut(eventName) {
   return {
     init: function(element, valueAccessor, allBindings, viewModel, bindingContext2) {
-      var newValueAccessor = function() {
-        var result = {};
+      const newValueAccessor = function() {
+        const result = {};
         result[eventName] = valueAccessor();
         return result;
       };
@@ -2479,18 +2580,18 @@ function makeDescriptor(handlerOrObject) {
 }
 var eventHandler = {
   init: function(element, valueAccessor, allBindings, viewModel, bindingContext2) {
-    var eventsToHandle = valueAccessor() || {};
+    const eventsToHandle = valueAccessor() || {};
     objectForEach(eventsToHandle, function(eventName, descriptor) {
       const { passive, capture, once, debounce: debounce2, throttle: throttle2 } = makeDescriptor(descriptor);
       const eventOptions = (capture || passive || once) && { capture, passive, once };
       let eventHandlerFn = (event, ...more) => {
-        var handlerReturnValue;
-        const { handler: handler2, passive: passive2, bubble, preventDefault } = makeDescriptor(valueAccessor()[eventName]);
+        let handlerReturnValue;
+        const { handler, passive: passive2, bubble, preventDefault } = makeDescriptor(valueAccessor()[eventName]);
         try {
-          if (handler2) {
+          if (handler) {
             const possiblyUpdatedViewModel = bindingContext2.$data;
             const argsForHandler = [possiblyUpdatedViewModel, event, ...more];
-            handlerReturnValue = handler2.apply(possiblyUpdatedViewModel, argsForHandler);
+            handlerReturnValue = handler.apply(possiblyUpdatedViewModel, argsForHandler);
           }
         } finally {
           if (preventDefault !== void 0) {
@@ -2535,7 +2636,7 @@ var click = makeEventHandlerShortcut("click");
 var css = {
   aliases: ["class"],
   update: function(element, valueAccessor) {
-    var value2 = unwrap(valueAccessor());
+    let value2 = unwrap(valueAccessor());
     if (value2 !== null && typeof value2 === "object") {
       objectForEach(value2, function(className, shouldHaveClass) {
         shouldHaveClass = unwrap(shouldHaveClass);
@@ -2552,22 +2653,24 @@ var css = {
 };
 
 // ../bind/dist/bindingEvent.js
-var contextAncestorBindingInfo = Symbol("_ancestorBindingInfo");
+var contextAncestorBindingInfo = /* @__PURE__ */ Symbol("_ancestorBindingInfo");
 var boundElementDomDataKey = data_exports.nextKey();
 var bindingEvent = {
+  //TODO better: String-Enum "BindingEventEnum"
   childrenComplete: "childrenComplete",
   descendantsComplete: "descendantsComplete",
-  subscribe(node, event, callback, context) {
+  subscribe(node, event, callback, callbackContext) {
     const bindingInfo = data_exports.getOrSet(node, boundElementDomDataKey, {});
     if (!bindingInfo.eventSubscribable) {
       bindingInfo.eventSubscribable = new subscribable();
     }
-    return bindingInfo.eventSubscribable.subscribe(callback, context, event);
+    return bindingInfo.eventSubscribable.subscribe(callback, callbackContext, event);
   },
   notify(node, event) {
     const bindingInfo = data_exports.get(node, boundElementDomDataKey);
     if (bindingInfo) {
       if (bindingInfo.eventSubscribable) {
+        ;
         bindingInfo.eventSubscribable.notifySubscribers(node, event);
       }
     }
@@ -2576,15 +2679,14 @@ var bindingEvent = {
 
 // ../bind/dist/bindingContext.js
 var boundElementDomDataKey2 = data_exports.nextKey();
-var contextSubscribeSymbol = Symbol("Knockout Context Subscription");
-var inheritParentIndicator = Symbol("Knockout Parent Indicator");
-function bindingContext(dataItemOrAccessor, parentContext, dataItemAlias, extendCallback, settings) {
+var contextSubscribeSymbol = /* @__PURE__ */ Symbol("Knockout Context Subscription");
+var inheritParentIndicator = /* @__PURE__ */ Symbol("Knockout Parent Indicator");
+var bindingContext = function bindingContextFactory(dataItemOrAccessor, parentContext, dataItemAlias, extendCallback, settings) {
   const self = this;
   const shouldInheritData = dataItemOrAccessor === inheritParentIndicator;
   const realDataItemOrAccessor = shouldInheritData ? void 0 : dataItemOrAccessor;
   const isFunc = typeof realDataItemOrAccessor === "function" && !isObservable(realDataItemOrAccessor);
   self.ko = options_default.knockoutInstance;
-  let nodes;
   let subscribable2;
   function updateContext() {
     const dataItemOrObservable = isFunc ? realDataItemOrAccessor() : realDataItemOrAccessor;
@@ -2598,7 +2700,7 @@ function bindingContext(dataItemOrAccessor, parentContext, dataItemAlias, extend
         self[contextAncestorBindingInfo] = parentContext[contextAncestorBindingInfo];
       }
     } else {
-      self.$parents = [];
+      self.$parents = new Array();
       self.$root = dataItem;
     }
     self[contextSubscribeSymbol] = subscribable2;
@@ -2628,7 +2730,7 @@ function bindingContext(dataItemOrAccessor, parentContext, dataItemAlias, extend
       self[contextSubscribeSymbol] = void 0;
     }
   }
-}
+};
 Object.assign(bindingContext.prototype, {
   lookup(token, globals, node) {
     switch (token) {
@@ -2652,24 +2754,39 @@ Object.assign(bindingContext.prototype, {
     }
     throw new Error(`The variable "${token}" was not found on $data, $context, or globals.`);
   },
+  // Extend the binding context hierarchy with a new view model object. If the parent context is watching
+  // any observables, the new child context will automatically get a dependency on the parent context.
+  // But this does not mean that the $data value of the child context will also get updated. If the child
+  // view model also depends on the parent view model, you must provide a function that returns the correct
+  // view model on each update.
   createChildContext(dataItemOrAccessor, dataItemAlias, extendCallback, settings) {
-    return new bindingContext(dataItemOrAccessor, this, dataItemAlias, function(self, parentContext) {
-      self.$parentContext = parentContext;
-      self.$parent = parentContext.$data;
-      self.$parents = (parentContext.$parents || []).slice(0);
-      self.$parents.unshift(self.$parent);
-      if (extendCallback) {
-        extendCallback(self);
-      }
-    }, settings);
+    return new bindingContext(
+      dataItemOrAccessor,
+      this,
+      dataItemAlias,
+      function(self, parentContext) {
+        var _a;
+        self.$parentContext = parentContext;
+        self.$parent = parentContext == null ? void 0 : parentContext.$data;
+        self.$parents = ((_a = parentContext == null ? void 0 : parentContext.$parents) != null ? _a : []).slice(0);
+        self.$parents.unshift(self.$parent);
+        if (extendCallback) {
+          extendCallback(self);
+        }
+      },
+      settings
+    );
   },
+  // Extend the binding context with new custom properties. This doesn't change the context hierarchy.
+  // Similarly to "child" contexts, provide a function here to make sure that the correct values are set
+  // when an observable view model is updated.
   extend(properties) {
-    return new bindingContext(inheritParentIndicator, this, null, function(self, parentContext) {
+    return new bindingContext(inheritParentIndicator, this, void 0, function(self, parentContext) {
       extend(self, typeof properties === "function" ? properties.call(self) : properties);
     });
   },
   createStaticChildContext(dataItemOrAccessor, dataItemAlias) {
-    return this.createChildContext(dataItemOrAccessor, dataItemAlias, null, { "exportDependencies": true });
+    return this.createChildContext(dataItemOrAccessor, dataItemAlias, null, { exportDependencies: true });
   }
 });
 function storedBindingContextForNode(node) {
@@ -2677,44 +2794,22 @@ function storedBindingContextForNode(node) {
   return bindingInfo && bindingInfo.context;
 }
 function contextFor(node) {
-  if (node && (node.nodeType === 1 || node.nodeType === 8)) {
+  if (node && (node.nodeType === Node.ELEMENT_NODE || node.nodeType === Node.COMMENT_NODE)) {
     return storedBindingContextForNode(node);
   }
 }
 function dataFor(node) {
-  var context = contextFor(node);
+  const context = contextFor(node);
   return context ? context.$data : void 0;
 }
 
 // ../bind/dist/BindingResult.js
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value2) => {
-      try {
-        step(generator.next(value2));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value2) => {
-      try {
-        step(generator.throw(value2));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
 var BindingResult = class {
   constructor({ asyncBindingsApplied, rootNode, bindingContext: bindingContext2 }) {
-    Object.assign(this, {
-      rootNode,
-      bindingContext: bindingContext2,
-      isSync: asyncBindingsApplied.size === 0,
-      isComplete: this.isSync
-    });
+    this.rootNode = rootNode;
+    this.bindingContext = bindingContext2;
+    this.isSync = asyncBindingsApplied.size === 0;
+    this.isComplete = this.isSync;
     if (!this.isSync) {
       this.completionPromise = this.completeWhenBindingsFinish(asyncBindingsApplied);
     }
@@ -2731,11 +2826,18 @@ var BindingResult = class {
 // ../lifecycle/dist/LifeCycle.js
 var SUBSCRIPTIONS = createSymbolOrString("LifeCycle Subscriptions List");
 var ANCHOR_NODE = createSymbolOrString("LifeCycle Anchor Node");
-var LifeCycle = class {
+var LifeCycle = class _LifeCycle {
+  // NOTE: For more advanced integration as an ES6 mixin, see e.g.:
+  // http://justinfagnani.com/2015/12/21/real-mixins-with-javascript-classes/
+  /**
+   * Copy the properties of the LifeCycle class to the target (or its prototype)
+   *
+   * NOTE: getOwnPropertyNames is needed to copy the non-enumerable properties.
+   */
   static mixInto(Constructor) {
     const target = Constructor.prototype || Constructor;
-    const mixin = LifeCycle.prototype;
-    for (let prop of Object.getOwnPropertyNames(mixin)) {
+    const mixin = _LifeCycle.prototype;
+    for (const prop of Object.getOwnPropertyNames(mixin)) {
       target[prop] = mixin[prop];
     }
   }
@@ -2763,16 +2865,23 @@ var LifeCycle = class {
     params.disposeWhenNodeIsRemoved = this[ANCHOR_NODE];
     return this.addDisposable(computed(params));
   }
+  /**
+   * Add an event listener for the given or anchored node.
+   * @param {node} [node] (optional) The target node (otherwise the anchored node)
+   * @param {string} [type] Event type
+   * @param {function|string} [action] Either call the given function or `this[action]`
+   * @param {object} [options] (optional) Passed as `options` to `node.addEventListener`
+   */
   addEventListener(...args) {
     const node = args[0].nodeType ? args.shift() : this[ANCHOR_NODE];
     const [type, act, options3] = args;
-    const handler2 = typeof act === "string" ? this[act].bind(this) : act;
-    this.__addEventListener(node, type, handler2, options3);
+    const handler = typeof act === "string" ? this[act].bind(this) : act;
+    this.__addEventListener(node, type, handler, options3);
   }
-  __addEventListener(node, eventType, handler2, options3) {
-    node.addEventListener(eventType, handler2, options3);
+  __addEventListener(node, eventType, handler, options3) {
+    node.addEventListener(eventType, handler, options3);
     function dispose() {
-      node.removeEventListener(eventType, handler2);
+      node.removeEventListener(eventType, handler);
     }
     addDisposeCallback(node, dispose);
     this.addDisposable({ dispose });
@@ -2789,7 +2898,7 @@ var LifeCycle = class {
   dispose() {
     const subscriptions = this[SUBSCRIPTIONS] || [];
     subscriptions.forEach((s) => s.dispose());
-    this[SUBSCRIPTIONS] = [];
+    this[SUBSCRIPTIONS] = new Array();
     this[ANCHOR_NODE] = null;
   }
   addDisposable(subscription) {
@@ -2810,13 +2919,11 @@ var BindingHandler = class extends LifeCycle {
   constructor(params) {
     super();
     const { $element, valueAccessor, allBindings, $context } = params;
-    Object.assign(this, {
-      valueAccessor,
-      allBindings,
-      $element,
-      $context,
-      $data: $context.$data
-    });
+    this.$element = $element;
+    this.valueAccessor = valueAccessor;
+    this.allBindings = allBindings;
+    this.$context = $context;
+    this.$data = $context.$data;
     this.anchorTo($element);
   }
   get value() {
@@ -2839,91 +2946,105 @@ var BindingHandler = class extends LifeCycle {
   static get isBindingHandlerClass() {
     return true;
   }
+  /* Overload this for asynchronous bindings or bindings that recursively
+       apply bindings (e.g. components, foreach, template).
+  
+       A binding should be complete when it has run through once, notably
+       in server-side bindings for pre-rendering.
+    */
   get bindingCompleted() {
     return true;
   }
   static registerAs(name, provider = options_default.bindingProviderInstance) {
     provider.bindingHandlers.set(name, this);
   }
+  static registerBindingHandler(handler, name, provider = options_default.bindingProviderInstance) {
+    provider.bindingHandlers.set(name, handler);
+  }
 };
-var ResolveSymbol = Symbol("Async Binding Resolved");
 
 // ../bind/dist/LegacyBindingHandler.js
 var PossibleWeakMap = options_default.global.WeakMap || Map;
 var legacyBindingMap = new PossibleWeakMap();
-var LegacyBindingHandler = class extends BindingHandler {
+var LegacyBindingHandler = class _LegacyBindingHandler extends BindingHandler {
+  get handler() {
+    return void 0;
+  }
   constructor(params) {
     super(params);
-    const handler2 = this.handler;
+    const handler = this.handler;
     this.onError = params.onError;
-    if (typeof handler2.dispose === "function") {
-      this.addDisposable(handler2);
+    if (typeof handler.dispose === "function") {
+      this.addDisposable(handler);
     }
     try {
-      this.initReturn = handler2.init && handler2.init(...this.legacyArgs);
+      this.initReturn = handler.init && handler.init(...this.legacyArgs);
     } catch (e) {
       params.onError("init", e);
     }
   }
   onValueChange() {
-    const handler2 = this.handler;
-    if (typeof handler2.update !== "function") {
+    const handler = this.handler;
+    if (typeof handler.update !== "function") {
       return;
     }
     try {
-      handler2.update(...this.legacyArgs);
+      handler.update(...this.legacyArgs);
     } catch (e) {
       this.onError("update", e);
     }
   }
   get legacyArgs() {
-    return [
-      this.$element,
-      this.valueAccessor,
-      this.allBindings,
-      this.$data,
-      this.$context
-    ];
+    return [this.$element, this.valueAccessor, this.allBindings, this.$data, this.$context];
   }
   get controlsDescendants() {
     const objectToTest = this.initReturn || this.handler || {};
     return objectToTest.controlsDescendantBindings;
   }
-  static getOrCreateFor(key, handler2) {
-    if (legacyBindingMap.has(handler2)) {
-      return legacyBindingMap.get(handler2);
-    }
-    const newLegacyHandler = this.createFor(key, handler2);
-    legacyBindingMap.set(handler2, newLegacyHandler);
+  /**
+   * Create a handler instance from the `origin`, which may be:
+   *
+   * 1. an object (becomes LegacyBindingHandler)
+   * 2. a function (becomes LegacyBindingHandler with `init: function`)
+   *
+   * If given an object (the only kind supported in knockout 3.x and before), it
+   * shall draw the `init`, `update`, and `allowVirtualElements` properties
+   */
+  static getOrCreateFor(key, handler) {
+    if (legacyBindingMap.has(handler)) {
+      return legacyBindingMap.get(handler);
+    }
+    const newLegacyHandler = this.createFor(key, handler);
+    legacyBindingMap.set(handler, newLegacyHandler);
     return newLegacyHandler;
   }
-  static createFor(key, handler2) {
-    if (typeof handler2 === "function") {
-      const [initFn, disposeFn] = [handler2, handler2.dispose];
-      return class extends LegacyBindingHandler {
+  static createFor(key, handler) {
+    if (typeof handler === "function") {
+      const [initFn, disposeFn] = [handler, handler.dispose];
+      return class extends _LegacyBindingHandler {
         get handler() {
           const init = initFn.bind(this);
           const dispose = disposeFn ? disposeFn.bind(this) : null;
           return { init, dispose };
         }
         static get after() {
-          return handler2.after;
+          return handler.after;
         }
         static get allowVirtualElements() {
-          return handler2.allowVirtualElements || virtualElements_exports.allowedBindings[key];
+          return handler.allowVirtualElements || virtualElements_exports.allowedBindings[key];
         }
       };
     }
-    if (typeof handler2 === "object") {
-      return class extends LegacyBindingHandler {
+    if (typeof handler === "object") {
+      return class extends _LegacyBindingHandler {
         get handler() {
-          return handler2;
+          return handler;
         }
         static get after() {
-          return handler2.after;
+          return handler.after;
         }
         static get allowVirtualElements() {
-          return handler2.allowVirtualElements || virtualElements_exports.allowedBindings[key];
+          return handler.allowVirtualElements || virtualElements_exports.allowedBindings[key];
         }
       };
     }
@@ -2933,22 +3054,27 @@ var LegacyBindingHandler = class extends BindingHandler {
 
 // ../bind/dist/applyBindings.js
 var bindingDoesNotRecurseIntoElementTypes = {
-  "script": true,
-  "textarea": true,
-  "template": true
+  // Don't want bindings that operate on text nodes to mutate <script> and <textarea> contents,
+  // because it's unexpected and a potential XSS issue.
+  // Also bindings should not operate on <template> elements since this breaks in Internet Explorer
+  // and because such elements' contents are always intended to be bound in a different context
+  // from where they appear in the document.
+  script: true,
+  textarea: true,
+  template: true
 };
 function getBindingProvider() {
   return options_default.bindingProviderInstance.instance || options_default.bindingProviderInstance;
 }
 function isProviderForNode(provider, node) {
-  const nodeTypes = provider.FOR_NODE_TYPES || [1, 3, 8];
+  const nodeTypes = provider.FOR_NODE_TYPES || [Node.ELEMENT_NODE, Node.TEXT_NODE, Node.COMMENT_NODE];
   return nodeTypes.includes(node.nodeType);
 }
-function asProperHandlerClass(handler2, bindingKey) {
-  if (!handler2) {
+function asProperHandlerClass(handler, bindingKey) {
+  if (!handler) {
     return;
   }
-  return handler2.isBindingHandlerClass ? handler2 : LegacyBindingHandler.getOrCreateFor(bindingKey, handler2);
+  return handler.isBindingHandlerClass ? handler : LegacyBindingHandler.getOrCreateFor(bindingKey, handler);
 }
 function getBindingHandlerFromComponent(bindingKey, $component) {
   if (!$component || typeof $component.getBindingHandler !== "function") {
@@ -2992,11 +3118,11 @@ function nodeOrChildHasBindings(node) {
   return hasBindings(node) || [...node.childNodes].some((c) => nodeOrChildHasBindings(c));
 }
 function applyBindingsToNodeAndDescendantsInternal(bindingContext2, nodeVerified, asyncBindingsApplied) {
-  var isElement = nodeVerified.nodeType === 1;
+  const isElement = nodeVerified.nodeType === Node.ELEMENT_NODE;
   if (isElement) {
     virtualElements_exports.normaliseVirtualElementDomStructure(nodeVerified);
   }
-  let shouldApplyBindings = isElement || hasBindings(nodeVerified);
+  const shouldApplyBindings = isElement || hasBindings(nodeVerified);
   const { shouldBindDescendants } = shouldApplyBindings ? applyBindingsToNodeInternal(nodeVerified, null, bindingContext2, asyncBindingsApplied) : { shouldBindDescendants: true };
   if (shouldBindDescendants && !bindingDoesNotRecurseIntoElementTypes[tagNameLower(nodeVerified)]) {
     applyBindingsToDescendantsInternal(bindingContext2, nodeVerified, asyncBindingsApplied);
@@ -3005,7 +3131,7 @@ function applyBindingsToNodeAndDescendantsInternal(bindingContext2, nodeVerified
 function* topologicalSortBindings(bindings2, $component) {
   const results = [];
   const bindingsConsidered = {};
-  const cyclicDependencyStack = [];
+  const cyclicDependencyStack = new Array();
   objectForEach(bindings2, function pushBinding(bindingKey) {
     if (!bindingsConsidered[bindingKey]) {
       const binding = getBindingHandlerFromComponent(bindingKey, $component) || getBindingHandler(bindingKey);
@@ -3019,7 +3145,9 @@ function* topologicalSortBindings(bindings2, $component) {
             return;
           }
           if (arrayIndexOf(cyclicDependencyStack, bindingDependencyKey) !== -1) {
-            throw Error("Cannot combine the following bindings, because they have a cyclic dependency: " + cyclicDependencyStack.join(", "));
+            throw Error(
+              "Cannot combine the following bindings, because they have a cyclic dependency: " + cyclicDependencyStack.join(", ")
+            );
           } else {
             pushBinding(bindingDependencyKey);
           }
@@ -3055,30 +3183,32 @@ function applyBindingsToNodeInternal(node, sourceBindings, bindingContext2, asyn
   if (!alreadyBound) {
     bindingInfo.context = bindingContext2;
   }
-  var bindings2;
+  let bindings2 = null;
+  let bindingsUpdater = null;
   if (sourceBindings && typeof sourceBindings !== "function") {
     bindings2 = sourceBindings;
   } else {
     const provider = getBindingProvider();
     const getBindings = provider.getBindingAccessors;
     if (isProviderForNode(provider, node)) {
-      var bindingsUpdater = computed(function() {
-        bindings2 = sourceBindings ? sourceBindings(bindingContext2, node) : getBindings.call(provider, node, bindingContext2);
-        if (bindings2 && bindingContext2[contextSubscribeSymbol]) {
-          bindingContext2[contextSubscribeSymbol]();
-        }
-        return bindings2;
-      }, null, { disposeWhenNodeIsRemoved: node });
+      bindingsUpdater = computed(
+        function() {
+          bindings2 = sourceBindings ? sourceBindings(bindingContext2, node) : getBindings.call(provider, node, bindingContext2);
+          if (bindings2 && bindingContext2[contextSubscribeSymbol]) {
+            bindingContext2[contextSubscribeSymbol]();
+          }
+          return bindings2;
+        },
+        null,
+        { disposeWhenNodeIsRemoved: node }
+      );
       if (!bindings2 || !bindingsUpdater.isActive()) {
         bindingsUpdater = null;
       }
     }
   }
-  var bindingHandlerThatControlsDescendantBindings;
+  let bindingHandlerThatControlsDescendantBindings;
   if (bindings2) {
-    let allBindings = function() {
-      return objectMap(bindingsUpdater ? bindingsUpdater() : bindings2, evaluateValueAccessor);
-    };
     const $component = bindingContext2.$component || {};
     const allBindingHandlers = {};
     data_exports.set(node, "bindingHandlers", allBindingHandlers);
@@ -3090,24 +3220,32 @@ function applyBindingsToNodeInternal(node, sourceBindings, bindingContext2, asyn
         return valueAccessor(optionalValue);
       }
     } : (bindingKey) => bindings2[bindingKey];
+    const allBindings = function() {
+      return objectMap(bindingsUpdater ? bindingsUpdater() : bindings2, evaluateValueAccessor);
+    };
     allBindings.has = (key) => key in bindings2;
     allBindings.get = (key) => bindings2[key] && evaluateValueAccessor(getValueAccessor(key));
     if (bindingEvent.childrenComplete in bindings2) {
-      bindingEvent.subscribe(node, bindingEvent.childrenComplete, () => {
-        const callback = evaluateValueAccessor(bindings2[bindingEvent.childrenComplete]);
-        if (!callback) {
-          return;
-        }
-        const nodes = virtualElements_exports.childNodes(node);
-        if (nodes.length) {
-          callback(nodes, dataFor(nodes[0]));
-        }
-      });
+      bindingEvent.subscribe(
+        node,
+        bindingEvent.childrenComplete,
+        () => {
+          const callback = evaluateValueAccessor(bindings2[bindingEvent.childrenComplete]);
+          if (!callback) {
+            return;
+          }
+          const nodes = virtualElements_exports.childNodes(node);
+          if (nodes.length) {
+            callback(nodes, dataFor(nodes[0]));
+          }
+        },
+        null
+      );
     }
     const bindingsGenerated = topologicalSortBindings(bindings2, $component);
     const nodeAsyncBindingPromises = /* @__PURE__ */ new Set();
     for (const [key, BindingHandlerClass] of bindingsGenerated) {
-      let reportBindingError = function(during, errorCaptured) {
+      const reportBindingError = function(during, errorCaptured) {
         onBindingError({
           during,
           errorCaptured,
@@ -3119,26 +3257,30 @@ function applyBindingsToNodeInternal(node, sourceBindings, bindingContext2, asyn
           valueAccessor: getValueAccessor(key)
         });
       };
-      if (node.nodeType === 8 && !BindingHandlerClass.allowVirtualElements) {
+      if (node.nodeType === Node.COMMENT_NODE && !BindingHandlerClass.allowVirtualElements) {
         throw new Error(`The binding '${key}' cannot be used with virtual elements`);
       }
       try {
-        const bindingHandler = dependencyDetection_exports.ignore(() => new BindingHandlerClass({
-          allBindings,
-          $element: node,
-          $context: bindingContext2,
-          onError: reportBindingError,
-          valueAccessor(...v) {
-            return getValueAccessor(key)(...v);
-          }
-        }));
+        const bindingHandler = dependencyDetection_exports.ignore(
+          () => new BindingHandlerClass({
+            allBindings,
+            $element: node,
+            $context: bindingContext2,
+            onError: reportBindingError,
+            valueAccessor(...v) {
+              return getValueAccessor(key)(...v);
+            }
+          })
+        );
         if (bindingHandler.onValueChange) {
           dependencyDetection_exports.ignore(() => bindingHandler.computed("onValueChange"));
         }
         allBindingHandlers[key] = bindingHandler;
         if (bindingHandler.controlsDescendants) {
           if (bindingHandlerThatControlsDescendantBindings !== void 0) {
-            throw new Error("Multiple bindings (" + bindingHandlerThatControlsDescendantBindings + " and " + key + ") are trying to control descendant bindings of the same element. You cannot use these bindings together on the same element.");
+            throw new Error(
+              "Multiple bindings (" + bindingHandlerThatControlsDescendantBindings + " and " + key + ") are trying to control descendant bindings of the same element. You cannot use these bindings together on the same element."
+            );
           }
           bindingHandlerThatControlsDescendantBindings = key;
         }
@@ -3147,7 +3289,8 @@ function applyBindingsToNodeInternal(node, sourceBindings, bindingContext2, asyn
           nodeAsyncBindingPromises.add(bindingHandler.bindingCompleted);
         }
       } catch (err) {
-        reportBindingError("creation", err);
+        const error = err instanceof Error ? err : new Error(String(err));
+        reportBindingError("creation", error);
       }
     }
     triggerDescendantsComplete(node, bindings2, nodeAsyncBindingPromises);
@@ -3175,22 +3318,27 @@ function getBindingContext(viewModelOrBindingContext, extendContextCallback) {
   return viewModelOrBindingContext && viewModelOrBindingContext instanceof bindingContext ? viewModelOrBindingContext : new bindingContext(viewModelOrBindingContext, void 0, void 0, extendContextCallback);
 }
 function applyBindingAccessorsToNode(node, bindings2, viewModelOrBindingContext, asyncBindingsApplied) {
-  if (node.nodeType === 1) {
+  if (node.nodeType === Node.ELEMENT_NODE) {
     virtualElements_exports.normaliseVirtualElementDomStructure(node);
   }
-  return applyBindingsToNodeInternal(node, bindings2, getBindingContext(viewModelOrBindingContext), asyncBindingsApplied);
+  return applyBindingsToNodeInternal(
+    node,
+    bindings2,
+    getBindingContext(viewModelOrBindingContext),
+    asyncBindingsApplied
+  );
 }
 function applyBindingsToDescendants(viewModelOrBindingContext, rootNode) {
   const asyncBindingsApplied = /* @__PURE__ */ new Set();
-  if (rootNode.nodeType === 1 || rootNode.nodeType === 8) {
-    const bindingContext2 = getBindingContext(viewModelOrBindingContext);
+  const bindingContext2 = getBindingContext(viewModelOrBindingContext);
+  if (rootNode.nodeType === Node.ELEMENT_NODE || rootNode.nodeType === Node.COMMENT_NODE) {
     applyBindingsToDescendantsInternal(bindingContext2, rootNode, asyncBindingsApplied);
     return new BindingResult({ asyncBindingsApplied, rootNode, bindingContext: bindingContext2 });
   }
-  return new BindingResult({ asyncBindingsApplied, rootNode });
+  return new BindingResult({ asyncBindingsApplied, rootNode, bindingContext: bindingContext2 });
 }
 function onBindingError(spec) {
-  var error, bindingText;
+  let error;
   if (spec.bindingKey) {
     error = spec.errorCaptured;
     spec.message = 'Unable to process binding "' + spec.bindingKey + '" in binding "' + spec.bindingKey + '"\nMessage: ' + (error.message ? error.message : error);
@@ -3201,7 +3349,12 @@ function onBindingError(spec) {
     extend(error, spec);
   } catch (e) {
     spec.stack = error.stack;
-    error = new Error(error.message ? error.message : error);
+    const message = error.message || String(error);
+    const originalName = error.name;
+    error = new Error(message);
+    if (originalName && originalName !== "Error") {
+      error.name = originalName;
+    }
     extend(error, spec);
   }
   options_default.onError(error);
@@ -3209,21 +3362,31 @@ function onBindingError(spec) {
 
 // ../bind/dist/arrayToDomNodeChildren.js
 function mapNodeAndRefreshWhenChanged(containerNode, mapping, valueToMap, callbackAfterAddingNodes, index) {
-  var mappedNodes = [];
-  var dependentObservable = computed(function() {
-    var newMappedNodes = mapping(valueToMap, index, fixUpContinuousNodeArray(mappedNodes, containerNode)) || [];
-    if (mappedNodes.length > 0) {
-      replaceDomNodes(mappedNodes, newMappedNodes);
-      if (callbackAfterAddingNodes) {
-        dependencyDetection_exports.ignore(callbackAfterAddingNodes, null, [valueToMap, newMappedNodes, index]);
-      }
-    }
-    mappedNodes.length = 0;
-    arrayPushAll(mappedNodes, newMappedNodes);
-  }, null, { disposeWhenNodeIsRemoved: containerNode, disposeWhen: function() {
-    return !anyDomNodeIsAttachedToDocument(mappedNodes);
-  } });
-  return { mappedNodes, dependentObservable: dependentObservable.isActive() ? dependentObservable : void 0 };
+  const mappedNodes = [];
+  const dependentObservable = computed(
+    function() {
+      const newMappedNodes = mapping(valueToMap, index, fixUpContinuousNodeArray(mappedNodes, containerNode)) || [];
+      if (mappedNodes.length > 0) {
+        replaceDomNodes(mappedNodes, newMappedNodes);
+        if (callbackAfterAddingNodes) {
+          dependencyDetection_exports.ignore(callbackAfterAddingNodes, null, [valueToMap, newMappedNodes, index]);
+        }
+      }
+      mappedNodes.length = 0;
+      arrayPushAll(mappedNodes, newMappedNodes);
+    },
+    null,
+    {
+      disposeWhenNodeIsRemoved: containerNode,
+      disposeWhen: function() {
+        return !anyDomNodeIsAttachedToDocument(mappedNodes);
+      }
+    }
+  );
+  return {
+    mappedNodes,
+    dependentObservable: dependentObservable.isActive() ? dependentObservable : void 0
+  };
 }
 var lastMappingResultDomDataKey = data_exports.nextKey();
 var deletedItemDummyValue = data_exports.nextKey();
@@ -3233,17 +3396,17 @@ function setDomNodeChildrenFromArrayMapping(domNode, array, mapping, options3, c
     array = [array];
   }
   options3 = options3 || {};
-  let lastMappingResult = data_exports.get(domNode, lastMappingResultDomDataKey);
-  let isFirstExecution = !lastMappingResult;
-  var newMappingResult = [];
-  var lastMappingResultIndex = 0;
-  var newMappingResultIndex = 0;
-  var nodesToDelete = [];
-  var itemsToProcess = [];
-  var itemsForBeforeRemoveCallbacks = [];
-  var itemsForMoveCallbacks = [];
-  var itemsForAfterAddCallbacks = [];
-  var mapData;
+  const lastMappingResult = data_exports.get(domNode, lastMappingResultDomDataKey);
+  const isFirstExecution = !lastMappingResult;
+  const newMappingResult = new Array();
+  let lastMappingResultIndex = 0;
+  let newMappingResultIndex = 0;
+  const nodesToDelete = [];
+  const itemsToProcess = [];
+  const itemsForBeforeRemoveCallbacks = [];
+  const itemsForMoveCallbacks = [];
+  const itemsForAfterAddCallbacks = [];
+  let mapData;
   let countWaitingForRemove = 0;
   function itemAdded(value2) {
     mapData = { arrayEntry: value2, indexObservable: observable(newMappingResultIndex++) };
@@ -3265,9 +3428,9 @@ function setDomNodeChildrenFromArrayMapping(domNode, array, mapping, options3, c
   }
   function callCallback(callback, items) {
     if (callback) {
-      for (var i2 = 0, n = items.length; i2 < n; i2++) {
-        arrayForEach(items[i2].mappedNodes, function(node2) {
-          callback(node2, i2, items[i2].arrayEntry);
+      for (let i = 0, n = items.length; i < n; i++) {
+        arrayForEach(items[i].mappedNodes, function(node) {
+          callback(node, i, items[i].arrayEntry);
         });
       }
     }
@@ -3276,16 +3439,13 @@ function setDomNodeChildrenFromArrayMapping(domNode, array, mapping, options3, c
     arrayForEach(array, itemAdded);
   } else {
     if (!editScript || lastMappingResult && lastMappingResult["_countWaitingForRemove"]) {
-      var lastArray = isFirstExecution ? [] : arrayMap(lastMappingResult, function(x) {
+      const lastArray = arrayMap(lastMappingResult, function(x) {
         return x.arrayEntry;
       });
-      var compareOptions = {
-        "dontLimitMoves": options3["dontLimitMoves"],
-        "sparse": true
-      };
+      const compareOptions = { dontLimitMoves: options3.dontLimitMoves, sparse: true };
       editScript = compareArrays(lastArray, array, compareOptions);
     }
-    for (var i = 0, editScriptItem, movedIndex, itemIndex; editScriptItem = editScript[i]; i++) {
+    for (let i = 0, editScriptItem, movedIndex, itemIndex; editScriptItem = editScript[i]; i++) {
       movedIndex = editScriptItem["moved"];
       itemIndex = editScriptItem["index"];
       switch (editScriptItem["status"]) {
@@ -3300,7 +3460,7 @@ function setDomNodeChildrenFromArrayMapping(domNode, array, mapping, options3, c
               mapData.dependentObservable = void 0;
             }
             if (fixUpContinuousNodeArray(mapData.mappedNodes, domNode).length) {
-              if (options3["beforeRemove"]) {
+              if (options3.beforeRemove) {
                 newMappingResult.push(mapData);
                 itemsToProcess.push(mapData);
                 countWaitingForRemove++;
@@ -3310,7 +3470,7 @@ function setDomNodeChildrenFromArrayMapping(domNode, array, mapping, options3, c
                   itemsForBeforeRemoveCallbacks.push(mapData);
                 }
               }
-              if (mapData) {
+              if (mapData == null ? void 0 : mapData.mappedNodes) {
                 nodesToDelete.push.apply(nodesToDelete, mapData.mappedNodes);
               }
             }
@@ -3335,14 +3495,22 @@ function setDomNodeChildrenFromArrayMapping(domNode, array, mapping, options3, c
     newMappingResult["_countWaitingForRemove"] = countWaitingForRemove;
   }
   data_exports.set(domNode, lastMappingResultDomDataKey, newMappingResult);
-  callCallback(options3["beforeMove"], itemsForMoveCallbacks);
-  arrayForEach(nodesToDelete, options3["beforeRemove"] ? cleanNode : removeNode);
-  i = 0;
-  for (var nextNode = virtualElements_exports.firstChild(domNode), lastNode, node; mapData = itemsToProcess[i]; i++) {
+  callCallback(options3.beforeMove, itemsForMoveCallbacks);
+  arrayForEach(nodesToDelete, options3.beforeRemove ? cleanNode : removeNode);
+  for (let k = 0, nextNode = virtualElements_exports.firstChild(domNode), lastNode, node; mapData = itemsToProcess[k]; k++) {
     if (!mapData.mappedNodes) {
-      extend(mapData, mapNodeAndRefreshWhenChanged(domNode, mapping, mapData.arrayEntry, callbackAfterAddingNodes, mapData.indexObservable));
-    }
-    for (var j = 0; node = mapData.mappedNodes[j]; nextNode = node.nextSibling, lastNode = node, j++) {
+      extend(
+        mapData,
+        mapNodeAndRefreshWhenChanged(
+          domNode,
+          mapping,
+          mapData.arrayEntry,
+          callbackAfterAddingNodes,
+          mapData.indexObservable
+        )
+      );
+    }
+    for (let j = 0; node = mapData.mappedNodes[j]; nextNode = node.nextSibling, lastNode = node, j++) {
       if (node !== nextNode) {
         virtualElements_exports.insertAfter(domNode, node, lastNode);
       }
@@ -3352,12 +3520,12 @@ function setDomNodeChildrenFromArrayMapping(domNode, array, mapping, options3, c
       mapData.initialized = true;
     }
   }
-  callCallback(options3["beforeRemove"], itemsForBeforeRemoveCallbacks);
-  for (i = 0; i < itemsForBeforeRemoveCallbacks.length; ++i) {
-    itemsForBeforeRemoveCallbacks[i].arrayEntry = deletedItemDummyValue;
+  callCallback(options3.beforeRemove, itemsForBeforeRemoveCallbacks);
+  for (let x = 0; x < itemsForBeforeRemoveCallbacks.length; ++x) {
+    itemsForBeforeRemoveCallbacks[x].arrayEntry = deletedItemDummyValue;
   }
-  callCallback(options3["afterMove"], itemsForMoveCallbacks);
-  callCallback(options3["afterAdd"], itemsForAfterAddCallbacks);
+  callCallback(options3.afterMove, itemsForMoveCallbacks);
+  callCallback(options3.afterAdd, itemsForAfterAddCallbacks);
 }
 
 // src/descendantsComplete.ts
@@ -3375,7 +3543,7 @@ var DescendantsCompleteHandler = class extends BindingHandler {
 // src/enableDisable.ts
 var enable = {
   update: function(element, valueAccessor) {
-    var value2 = unwrap(valueAccessor());
+    const value2 = unwrap(valueAccessor());
     if (value2 && element.disabled) {
       element.removeAttribute("disabled");
     } else if (!value2 && !element.disabled) {
@@ -3395,12 +3563,12 @@ var disable = {
 var hasfocusUpdatingProperty = createSymbolOrString("__ko_hasfocusUpdating");
 var hasfocusLastValue = createSymbolOrString("__ko_hasfocusLastValue");
 var hasfocus = {
-  init: function(element, valueAccessor) {
-    var handleElementFocusChange = function(isFocused) {
+  init: function(element, valueAccessor, _allBindings) {
+    const handleElementFocusChange = function(isFocused) {
       element[hasfocusUpdatingProperty] = true;
-      var ownerDoc = element.ownerDocument;
+      const ownerDoc = element.ownerDocument;
       if ("activeElement" in ownerDoc) {
-        var active;
+        let active;
         try {
           active = ownerDoc.activeElement;
         } catch (e) {
@@ -3408,21 +3576,28 @@ var hasfocus = {
         }
         isFocused = active === element;
       }
-      valueAccessor(isFocused, { onlyIfChanged: true });
+      const modelValue = valueAccessor(isFocused, { onlyIfChanged: true });
+      if (isWriteableObservable(modelValue) && modelValue.peek() !== isFocused) {
+        modelValue(isFocused);
+      }
       element[hasfocusLastValue] = isFocused;
       element[hasfocusUpdatingProperty] = false;
     };
-    var handleElementFocusIn = handleElementFocusChange.bind(null, true);
-    var handleElementFocusOut = handleElementFocusChange.bind(null, false);
+    const handleElementFocusIn = handleElementFocusChange.bind(null, true);
+    const handleElementFocusOut = handleElementFocusChange.bind(null, false);
     registerEventHandler(element, "focus", handleElementFocusIn);
     registerEventHandler(element, "focusin", handleElementFocusIn);
     registerEventHandler(element, "blur", handleElementFocusOut);
     registerEventHandler(element, "focusout", handleElementFocusOut);
   },
   update: function(element, valueAccessor) {
-    var value2 = !!unwrap(valueAccessor());
+    const value2 = !!unwrap(valueAccessor());
     if (!element[hasfocusUpdatingProperty] && element[hasfocusLastValue] !== value2) {
-      value2 ? element.focus() : element.blur();
+      if (value2) {
+        element.focus();
+      } else {
+        element.blur();
+      }
       if (!value2 && element[hasfocusLastValue]) {
         element.ownerDocument.body.focus();
       }
@@ -3434,10 +3609,11 @@ var hasfocus = {
 // src/html.ts
 var html = {
   init: function() {
-    return {
-      "controlsDescendantBindings": true
-    };
+    return { controlsDescendantBindings: true };
   },
+  //
+  // Modify internal, per ko.punches and :
+  //      http://stackoverflow.com/a/15348139
   update: function(element, valueAccessor) {
     setHtml(element, valueAccessor());
   },
@@ -3446,10 +3622,10 @@ var html = {
 
 // src/let.ts
 var let_default = {
-  init: function(element, valueAccessor, allBindings, viewModel, bindingContext2) {
-    var innerContext = bindingContext2["extend"](valueAccessor);
+  init: function(element, valueAccessor, _allBindings, _viewModel, bindingContext2) {
+    const innerContext = bindingContext2["extend"](valueAccessor);
     applyBindingsToDescendants(innerContext, element);
-    return { "controlsDescendantBindings": true };
+    return { controlsDescendantBindings: true };
   },
   allowVirtualElements: true
 };
@@ -3464,7 +3640,7 @@ var options2 = {
     while (element.length > 0) {
       element.remove(0);
     }
-    return { "controlsDescendantBindings": true };
+    return { controlsDescendantBindings: true };
   },
   update: function(element, valueAccessor, allBindings) {
     function selectedOptions2() {
@@ -3472,7 +3648,7 @@ var options2 = {
         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 = [];
+    let 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 = new Array();
     if (!valueAllowUnset) {
       if (multiple) {
         previousSelectedValues = arrayMap(selectedOptions2(), selectExtensions.readValue);
@@ -3495,30 +3671,30 @@ var options2 = {
       }
     } else {
     }
-    function applyToObject(object2, predicate, defaultValue) {
-      var predicateType = typeof predicate;
+    function applyToObject(object, predicate, defaultValue) {
+      const predicateType = typeof predicate;
       if (predicateType === "function") {
-        return predicate(object2);
+        return predicate(object);
       } else if (predicateType == "string") {
-        return object2[predicate];
+        return object[predicate];
       } else {
         return defaultValue;
       }
     }
-    var itemUpdate = false;
+    let 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");
+      const option = element.ownerDocument.createElement("option");
       if (arrayEntry === captionPlaceholder) {
         setTextContent(option, allBindings.get("optionsCaption"));
         selectExtensions.writeValue(option, void 0);
       } else {
-        var optionValue = applyToObject(arrayEntry, allBindings.get("optionsValue"), arrayEntry);
+        const optionValue = applyToObject(arrayEntry, allBindings.get("optionsValue"), arrayEntry);
         selectExtensions.writeValue(option, unwrap(optionValue));
-        var optionText = applyToObject(arrayEntry, allBindings.get("optionsText"), optionValue);
+        const optionText = applyToObject(arrayEntry, allBindings.get("optionsText"), optionValue);
         setTextContent(option, optionText);
       }
       return [option];
@@ -3528,28 +3704,47 @@ var options2 = {
     };
     function setSelectionCallback(arrayEntry, newOptions) {
       if (itemUpdate && valueAllowUnset) {
-        selectExtensions.writeValue(element, unwrap(allBindings.get("value")), true);
+        selectExtensions.writeValue(
+          element,
+          unwrap(allBindings.get("value")),
+          true
+          /* allowUnset */
+        );
       } else if (previousSelectedValues.length) {
-        var isSelected = arrayIndexOf(previousSelectedValues, selectExtensions.readValue(newOptions[0])) >= 0;
+        const isSelected = arrayIndexOf(previousSelectedValues, selectExtensions.readValue(newOptions[0])) >= 0;
         setOptionNodeSelectionState(newOptions[0], isSelected);
         if (itemUpdate && !isSelected) {
           dependencyDetection_exports.ignore(triggerEvent, null, [element, "change"]);
         }
       }
     }
-    var callback = setSelectionCallback;
+    let callback = setSelectionCallback;
     if (allBindings["has"]("optionsAfterRender") && typeof allBindings.get("optionsAfterRender") === "function") {
       callback = function(arrayEntry, newOptions) {
         setSelectionCallback(arrayEntry, newOptions);
-        dependencyDetection_exports.ignore(allBindings.get("optionsAfterRender"), null, [newOptions[0], arrayEntry !== captionPlaceholder ? arrayEntry : void 0]);
+        dependencyDetection_exports.ignore(allBindings.get("optionsAfterRender"), null, [
+          newOptions[0],
+          arrayEntry !== captionPlaceholder ? arrayEntry : void 0
+        ]);
       };
     }
-    setDomNodeChildrenFromArrayMapping(element, filteredArray, optionForArrayItem, arrayToDomNodeChildrenOptions, callback);
+    setDomNodeChildrenFromArrayMapping(
+      element,
+      filteredArray,
+      optionForArrayItem,
+      arrayToDomNodeChildrenOptions,
+      callback
+    );
     dependencyDetection_exports.ignore(function() {
       if (valueAllowUnset) {
-        selectExtensions.writeValue(element, unwrap(allBindings.get("value")), true);
+        selectExtensions.writeValue(
+          element,
+          unwrap(allBindings.get("value")),
+          true
+          /* allowUnset */
+        );
       } else {
-        var selectionChanged;
+        let selectionChanged;
         if (multiple) {
           selectionChanged = previousSelectedValues.length && selectedOptions2().length < previousSelectedValues.length;
         } else {
@@ -3560,7 +3755,6 @@ var options2 = {
         }
       }
     });
-    ensureSelectElementIsRenderedCorrectly(element);
     if (previousScrollTop && Math.abs(previousScrollTop - element.scrollTop) > 20) {
       element.scrollTop = previousScrollTop;
     }
@@ -3570,9 +3764,9 @@ var options2 = {
 // src/selectedOptions.ts
 var selectedOptions = {
   after: ["options", "foreach"],
-  init: function(element, valueAccessor, allBindings) {
+  init: function(element, valueAccessor, _allBindings) {
     registerEventHandler(element, "change", function() {
-      var value2 = valueAccessor(), valueToWrite = [];
+      const value2 = valueAccessor(), valueToWrite = new Array();
       arrayForEach(element.getElementsByTagName("option"), function(node) {
         if (node.selected) {
           valueToWrite.push(selectExtensions.readValue(node));
@@ -3585,10 +3779,10 @@ var selectedOptions = {
     if (tagNameLower(element) != "select") {
       throw new Error("values binding applies only to SELECT elements");
     }
-    var newValue = unwrap(valueAccessor()), previousScrollTop = element.scrollTop;
+    const 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;
+        const isSelected = arrayIndexOf(newValue, selectExtensions.readValue(node)) >= 0;
         if (node.selected != isSelected) {
           setOptionNodeSelectionState(node, isSelected);
         }
@@ -3599,17 +3793,16 @@ var selectedOptions = {
 };
 
 // src/style.ts
-var { jQueryInstance: jQueryInstance2 } = options_default;
 var style = {
   update: function(element, valueAccessor) {
-    var value2 = unwrap(valueAccessor() || {});
+    const value2 = unwrap(valueAccessor() || {});
     objectForEach(value2, function(styleName, styleValue) {
       styleValue = unwrap(styleValue);
       if (styleValue === null || styleValue === void 0 || styleValue === false) {
         styleValue = "";
       }
-      if (jQueryInstance2) {
-        jQueryInstance2(element).css(styleName, styleValue);
+      if (options_default.jQuery) {
+        jQuery(element).css(styleName, styleValue);
       } else {
         styleName = styleName.replace(/-(\w)/g, (all, letter) => letter.toUpperCase());
         const previousStyle = element.style[styleName];
@@ -3624,13 +3817,13 @@ var style = {
 
 // src/submit.ts
 var submit = {
-  init: function(element, valueAccessor, allBindings, viewModel, bindingContext2) {
+  init: function(element, valueAccessor, _allBindings, _viewModel, bindingContext2) {
     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 value2 = valueAccessor();
+      let handlerReturnValue;
+      const value2 = valueAccessor();
       try {
         handlerReturnValue = value2.call(bindingContext2["$data"], element);
       } finally {
@@ -3658,9 +3851,11 @@ var text = {
 };
 
 // src/textInput.ts
+var MSIE_REGEX = /MSIE ([^ ;]+)|rv:([^ )]+)/;
 var operaVersion;
 var safariVersion;
 var firefoxVersion;
+var ieVersion;
 var TextInput = class extends BindingHandler {
   get aliases() {
     return "textinput";
@@ -3698,6 +3893,7 @@ var TextInput = class extends BindingHandler {
     const elementValue = element.value;
     if (this.previousElementValue !== elementValue) {
       if (options_default.debug && event) {
+        ;
         element._ko_textInputProcessedEvent = event.type;
       }
       this.previousElementValue = elementValue;
@@ -3708,8 +3904,8 @@ var TextInput = class extends BindingHandler {
     const element = this.$element;
     if (!this.timeoutHandle) {
       this.elementValueBeforeEvent = element.value;
-      const handler2 = options_default.debug ? this.updateModel.bind(this, { type: event.type }) : this.updateModel;
-      this.timeoutHandle = safeSetTimeout(handler2, 4);
+      const handler = options_default.debug ? this.updateModel.bind(this, { type: event.type }) : this.updateModel;
+      this.timeoutHandle = safeSetTimeout(handler, 4);
     }
   }
   updateView() {
@@ -3727,43 +3923,8 @@ var TextInput = class extends BindingHandler {
   }
 };
 var TextInputIE = class extends TextInput {
-  constructor(...args) {
-    super(...args);
-    if (ieVersion < 11) {
-      this.addEventListener("propertychange", (event) => event.propertyName === "value" && this.updateModel(event));
-    }
-    if (ieVersion >= 8 && ieVersion < 10) {
-      this.watchForSelectionChangeEvent();
-      this.addEventListener("dragend", "deferUpdateModel");
-    }
-  }
   eventsIndicatingSyncValueChange() {
-    return [...super.eventsIndicatingValueChange(), "keypress"];
-  }
-  selectionChangeHandler(event) {
-    const target = this.activeElement;
-    const handler2 = target && data_exports.get(target, selectionChangeHandlerName);
-    if (handler2) {
-      handler2(event);
-    }
-  }
-  watchForSelectionChangeEvent(element, ieUpdateModel) {
-    const ownerDoc = element.ownerDocument;
-    if (!data_exports.get(ownerDoc, selectionChangeRegisteredName)) {
-      data_exports.set(ownerDoc, selectionChangeRegisteredName, true);
-      registerEventHandler(ownerDoc, "selectionchange", this.selectionChangeHandler.bind(ownerDoc));
-    }
-    data_exports.set(element, selectionChangeHandlerName, handler);
-  }
-};
-var TextInputIE9 = class extends TextInputIE {
-  updateModel(...args) {
-    this.deferUpdateModel(...args);
-  }
-};
-var TextInputIE8 = class extends TextInputIE {
-  eventsIndicatingValueChange() {
-    return [...super.eventsIndicatingValueChange(), "keyup", "keydown"];
+    return [...super.eventsIndicatingSyncValueChange(), "keypress"];
   }
 };
 var TextInputLegacySafari = class extends TextInput {
@@ -3780,9 +3941,13 @@ var TextInputLegacyFirefox = class 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
     ];
   }
 };
@@ -3791,18 +3956,22 @@ if (w2.navigator) {
   const parseVersion = (matches) => matches && parseFloat(matches[1]);
   const userAgent = w2.navigator.userAgent;
   const isChrome = userAgent.match(/Chrome\/([^ ]+)/);
-  operaVersion = w2.opera && w2.opera.version && parseInt(w2.opera.version());
-  safariVersion = parseVersion(userAgent.match(/Version\/([^ ]+) Safari/));
-  firefoxVersion = parseVersion(userAgent.match(/Firefox\/([^ ]*)/));
+  if (!isChrome) {
+    operaVersion = w2.opera && w2.opera.version && parseInt(w2.opera.version());
+    safariVersion = parseVersion(userAgent.match(/Version\/([^ ]+) Safari/));
+    firefoxVersion = parseVersion(userAgent.match(/Firefox\/([^ ]*)/));
+    const ieMatch = userAgent.match(MSIE_REGEX);
+    ieVersion = ieMatch && (parseFloat(ieMatch[1]) || parseFloat(ieMatch[2]));
+  }
 }
-var textInput = ieVersion === 8 ? TextInputIE8 : ieVersion === 9 ? TextInputIE9 : ieVersion ? TextInputIE : safariVersion && safariVersion < 5 ? TextInputLegacySafari : operaVersion < 11 ? TextInputLegacyOpera : firefoxVersion && firefoxVersion < 4 ? TextInputLegacyFirefox : TextInput;
+var textInput = ieVersion && ieVersion <= 11 ? TextInputIE : safariVersion && safariVersion < 5 ? TextInputLegacySafari : operaVersion && operaVersion < 11 ? TextInputLegacyOpera : firefoxVersion && firefoxVersion < 4 ? TextInputLegacyFirefox : TextInput;
 
 // src/uniqueName.ts
 var uniqueName = {
   init: function(element, valueAccessor) {
     if (valueAccessor()) {
-      var name = "ko_unique_" + ++uniqueName.currentIndex;
-      setElementName(element, name);
+      const name = "ko_unique_" + ++uniqueName.currentIndex;
+      element.name = name;
     }
   },
   currentIndex: 0
@@ -3846,8 +4015,10 @@ var value = class extends BindingHandler {
     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");
+    return this.isInput && this.$element.type == "text" && this.$element.autocomplete != "off" && (!this.$element.form || this.$element.form.autocomplete != "off") && MSIE_REGEX.test(window.navigator.userAgent);
   }
   valueUpdateHandler() {
     this.elementValueBeforeEvent = null;
@@ -3855,18 +4026,21 @@ var value = class extends BindingHandler {
     this.value = selectExtensions.readValue(this.$element);
   }
   registerEvent(eventName) {
-    var handler2 = this.valueUpdateHandler.bind(this);
+    let handler = this.valueUpdateHandler.bind(this);
     if (stringStartsWith(eventName, "after")) {
-      handler2 = () => {
+      handler = () => {
         this.elementValueBeforeEvent = selectExtensions.readValue(this.$element);
         safeSetTimeout(this.valueUpdateHandler.bind(this), 0);
       };
-      eventName = eventName.substring(5);
+      eventName = eventName.substring(
+        5
+        /* 'after'.length */
+      );
     }
-    this.addEventListener(eventName, handler2);
+    this.addEventListener(eventName, handler);
   }
   updateFromModelForFile() {
-    var newValue = unwrap(this.value);
+    const newValue = unwrap(this.value);
     if (newValue === null || newValue === void 0 || newValue === "") {
       this.$element.value = "";
     } else {
@@ -3875,8 +4049,8 @@ var value = class extends BindingHandler {
   }
   updateFromModelForValue() {
     const element = this.$element;
-    var newValue = unwrap(this.value);
-    var elementValue = selectExtensions.readValue(element);
+    const newValue = unwrap(this.value);
+    const elementValue = selectExtensions.readValue(element);
     if (this.elementValueBeforeEvent !== null && newValue === this.elementValueBeforeEvent) {
       safeSetTimeout(this.updateFromModel.bind(this), 0);
       return;
@@ -3899,8 +4073,8 @@ var value = class extends BindingHandler {
 // src/visible.ts
 var visible = {
   update: function(element, valueAccessor) {
-    var value2 = unwrap(valueAccessor());
-    var isCurrentlyVisible = !(element.style.display === "none");
+    const value2 = unwrap(valueAccessor());
+    const isCurrentlyVisible = !(element.style.display === "none");
     if (value2 && !isCurrentlyVisible) {
       element.style.display = "";
     } else if (!value2 && isCurrentlyVisible) {
@@ -3916,8 +4090,8 @@ var hidden = {
 
 // src/using.ts
 var using = {
-  init: function(element, valueAccessor, allBindings, viewModel, bindingContext2) {
-    var innerContext = bindingContext2.createChildContext(valueAccessor);
+  init: function(element, valueAccessor, _allBindings, _viewModel, bindingContext2) {
+    const innerContext = bindingContext2.createChildContext(valueAccessor);
     applyBindingsToDescendants(innerContext, element);
     return { controlsDescendantBindings: true };
   },
@@ -3931,16 +4105,16 @@ var bindings = {
   checkedValue,
   click,
   css,
-  "class": css,
+  class: css,
   descendantsComplete: DescendantsCompleteHandler,
   enable,
-  "event": eventHandler,
+  event: eventHandler,
   disable,
   hasfocus,
   hasFocus: hasfocus,
   hidden,
   html,
-  "let": let_default,
+  let: let_default,
   on: onHandler,
   options: options2,
   selectedOptions,