@tko/utils 4.0.0-alpha7.4 → 4.0.0-beta1.3

package/dist/index.cjs

@@ -0,0 +1,1448 @@
+// @tko/utils 🥊 4.0.0-beta1.3 CommonJS
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  addCleaner: () => addCleaner,
+  addDisposeCallback: () => addDisposeCallback,
+  addOrRemoveItem: () => addOrRemoveItem,
+  anyDomNodeIsAttachedToDocument: () => anyDomNodeIsAttachedToDocument,
+  arrayFilter: () => arrayFilter,
+  arrayFirst: () => arrayFirst,
+  arrayForEach: () => arrayForEach,
+  arrayGetDistinctValues: () => arrayGetDistinctValues,
+  arrayIndexOf: () => arrayIndexOf,
+  arrayMap: () => arrayMap,
+  arrayPushAll: () => arrayPushAll,
+  arrayRemoveItem: () => arrayRemoveItem,
+  catchFunctionErrors: () => catchFunctionErrors,
+  cleanNode: () => cleanNode,
+  cleanjQueryData: () => cleanjQueryData,
+  cloneNodes: () => cloneNodes,
+  clonePlainObjectDeep: () => clonePlainObjectDeep,
+  compareArrays: () => compareArrays,
+  createSymbolOrString: () => createSymbolOrString,
+  debounce: () => debounce,
+  deferError: () => deferError,
+  domData: () => data_exports,
+  domNodeIsAttachedToDocument: () => domNodeIsAttachedToDocument,
+  domNodeIsContainedBy: () => domNodeIsContainedBy,
+  emptyDomNode: () => emptyDomNode,
+  ensureSelectElementIsRenderedCorrectly: () => ensureSelectElementIsRenderedCorrectly,
+  extend: () => extend,
+  findMovesInArrayComparison: () => findMovesInArrayComparison,
+  fixUpContinuousNodeArray: () => fixUpContinuousNodeArray,
+  forceRefresh: () => forceRefresh,
+  functionSupportsLengthOverwrite: () => functionSupportsLengthOverwrite,
+  getObjectOwnProperty: () => getObjectOwnProperty,
+  hasOwnProperty: () => hasOwnProperty,
+  ieVersion: () => ieVersion,
+  isDocumentFragment: () => isDocumentFragment,
+  isDomElement: () => isDomElement,
+  isIe6: () => isIe6,
+  isIe7: () => isIe7,
+  isObjectLike: () => isObjectLike,
+  isThenable: () => isThenable,
+  jQuerySetInstance: () => jQuerySetInstance,
+  makeArray: () => makeArray,
+  memoization: () => memoization_exports,
+  moveCleanedNodesToContainerElement: () => moveCleanedNodesToContainerElement,
+  objectForEach: () => objectForEach,
+  objectMap: () => objectMap,
+  options: () => options_default,
+  otherNodeCleanerFunctions: () => otherNodeCleanerFunctions,
+  overwriteLengthPropertyIfSupported: () => overwriteLengthPropertyIfSupported,
+  parseHtmlForTemplateNodes: () => parseHtmlForTemplateNodes,
+  parseHtmlFragment: () => parseHtmlFragment,
+  parseJson: () => parseJson,
+  range: () => range,
+  registerEventHandler: () => registerEventHandler,
+  removeCleaner: () => removeCleaner,
+  removeDisposeCallback: () => removeDisposeCallback,
+  removeNode: () => removeNode,
+  replaceDomNodes: () => replaceDomNodes,
+  safeSetTimeout: () => safeSetTimeout,
+  safeStringify: () => safeStringify,
+  selectExtensions: () => selectExtensions,
+  setDomNodeChildren: () => setDomNodeChildren,
+  setElementName: () => setElementName,
+  setHtml: () => setHtml,
+  setOptionNodeSelectionState: () => setOptionNodeSelectionState,
+  setTextContent: () => setTextContent,
+  stringStartsWith: () => stringStartsWith,
+  stringTrim: () => stringTrim,
+  tagNameLower: () => tagNameLower,
+  tasks: () => tasks_exports,
+  throttle: () => throttle,
+  toggleDomNodeCssClass: () => toggleDomNodeCssClass,
+  triggerEvent: () => triggerEvent,
+  useSymbols: () => useSymbols,
+  virtualElements: () => virtualElements_exports
+});
+module.exports = __toCommonJS(utils_exports);
+
+// src/array.ts
+var { isArray } = Array;
+function arrayForEach(array, action, thisArg) {
+  if (arguments.length > 2) {
+    action = action.bind(thisArg);
+  }
+  for (let i = 0, j = array.length; i < j; ++i) {
+    action(array[i], i, array);
+  }
+}
+function arrayIndexOf(array, item) {
+  return (isArray(array) ? array : [...array]).indexOf(item);
+}
+function arrayFirst(array, predicate, predicateOwner) {
+  return (isArray(array) ? array : [...array]).find(predicate, predicateOwner);
+}
+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);
+  if (index > 0) {
+    array.splice(index, 1);
+  } else if (index === 0) {
+    array.shift();
+  }
+}
+function arrayGetDistinctValues(array = []) {
+  const seen = /* @__PURE__ */ new Set();
+  if (array === null) {
+    return [];
+  }
+  return (isArray(array) ? array : [...array]).filter((item) => seen.has(item) ? false : seen.add(item));
+}
+function arrayFilter(array, predicate, thisArg) {
+  if (arguments.length > 2) {
+    predicate = predicate.bind(thisArg);
+  }
+  return array === null ? [] : (isArray(array) ? array : [...array]).filter(predicate);
+}
+function arrayPushAll(array, valuesToPush) {
+  if (isArray(valuesToPush)) {
+    array.push.apply(array, valuesToPush);
+  } else {
+    for (var i = 0, j = valuesToPush.length; i < j; i++) {
+      array.push(valuesToPush[i]);
+    }
+  }
+  return array;
+}
+function addOrRemoveItem(array, value, included) {
+  var existingEntryIndex = arrayIndexOf(typeof array.peek === "function" ? array.peek() : array, value);
+  if (existingEntryIndex < 0) {
+    if (included) {
+      array.push(value);
+    }
+  } else {
+    if (!included) {
+      array.splice(existingEntryIndex, 1);
+    }
+  }
+}
+function makeArray(arrayLikeObject) {
+  return Array.from(arrayLikeObject);
+}
+function range(min, max) {
+  min = typeof min === "function" ? min() : min;
+  max = typeof max === "function" ? max() : max;
+  var result = [];
+  for (var i = min; i <= max; i++) {
+    result.push(i);
+  }
+  return result;
+}
+function findMovesInArrayComparison(left, right, limitFailedCompares) {
+  if (left.length && right.length) {
+    var 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) {
+          leftItem.moved = rightItem.index;
+          rightItem.moved = leftItem.index;
+          right.splice(r, 1);
+          failedCompares = r = 0;
+          break;
+        }
+      }
+      failedCompares += r;
+    }
+  }
+}
+var statusNotInOld = "added";
+var statusNotInNew = "deleted";
+function compareArrays(oldArray, newArray, options2) {
+  options2 = typeof options2 === "boolean" ? { dontLimitMoves: options2 } : options2 || {};
+  oldArray = oldArray || [];
+  newArray = newArray || [];
+  if (oldArray.length < newArray.length) {
+    return compareSmallArrayToBigArray(oldArray, newArray, statusNotInOld, statusNotInNew, options2);
+  } else {
+    return compareSmallArrayToBigArray(newArray, oldArray, statusNotInNew, statusNotInOld, options2);
+  }
+}
+function compareSmallArrayToBigArray(smlArray, bigArray, statusNotInSml, statusNotInBig, options2) {
+  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;
+  for (smlIndex = 0; smlIndex <= smlIndexMax; smlIndex++) {
+    lastRow = thisRow;
+    editDistanceMatrix.push(thisRow = []);
+    bigIndexMaxForRow = myMin(bigIndexMax, smlIndex + compareRange);
+    bigIndexMinForRow = myMax(0, smlIndex - 1);
+    for (bigIndex = bigIndexMinForRow; bigIndex <= bigIndexMaxForRow; bigIndex++) {
+      if (!bigIndex) {
+        thisRow[bigIndex] = smlIndex + 1;
+      } else if (!smlIndex) {
+        thisRow[bigIndex] = bigIndex + 1;
+      } 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;
+        thisRow[bigIndex] = myMin(northDistance, westDistance) + 1;
+      }
+    }
+  }
+  var editScript = [], meMinusOne, notInSml = [], notInBig = [];
+  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
+      });
+    } else if (smlIndex && meMinusOne === editDistanceMatrix[smlIndex - 1][bigIndex]) {
+      notInBig.push(editScript[editScript.length] = {
+        "status": statusNotInBig,
+        "value": smlArray[--smlIndex],
+        "index": smlIndex
+      });
+    } else {
+      --bigIndex;
+      --smlIndex;
+      if (!options2.sparse) {
+        editScript.push({
+          "status": "retained",
+          "value": bigArray[bigIndex]
+        });
+      }
+    }
+  }
+  findMovesInArrayComparison(notInBig, notInSml, !options2.dontLimitMoves && smlIndexMax * 10);
+  return editScript.reverse();
+}
+
+// src/options.ts
+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, value) {
+    options[name] = value;
+  },
+  getBindingHandler() {
+  },
+  cleanExternalData() {
+  }
+};
+Object.defineProperty(options, "$", {
+  get: function() {
+    return options.jQuery;
+  }
+});
+var options_default = options;
+
+// src/error.ts
+function catchFunctionErrors(delegate) {
+  if (!options_default.onError) {
+    return delegate;
+  }
+  return (...args) => {
+    try {
+      return delegate(...args);
+    } catch (err) {
+      options_default.onError(err);
+    }
+  };
+}
+function deferError(error) {
+  safeSetTimeout(function() {
+    throw error;
+  }, 0);
+}
+function safeSetTimeout(handler, timeout) {
+  return setTimeout(catchFunctionErrors(handler), timeout);
+}
+
+// src/async.ts
+function throttle(callback, timeout) {
+  var timeoutInstance;
+  return function(...args) {
+    if (!timeoutInstance) {
+      timeoutInstance = safeSetTimeout(function() {
+        timeoutInstance = void 0;
+        callback(...args);
+      }, timeout);
+    }
+  };
+}
+function debounce(callback, timeout) {
+  var timeoutInstance;
+  return function(...args) {
+    clearTimeout(timeoutInstance);
+    timeoutInstance = safeSetTimeout(() => callback(...args), timeout);
+  };
+}
+
+// src/ie.ts
+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;
+}();
+var isIe6 = ieVersion === 6;
+var isIe7 = ieVersion === 7;
+
+// src/object.ts
+function hasOwnProperty(obj, propName) {
+  return Object.prototype.hasOwnProperty.call(obj, propName);
+}
+function isObjectLike(obj) {
+  if (obj === null) {
+    return false;
+  }
+  return typeof obj === "object" || typeof obj === "function";
+}
+function extend(target, source) {
+  if (source) {
+    for (var prop in source) {
+      if (hasOwnProperty(source, prop)) {
+        target[prop] = source[prop];
+      }
+    }
+  }
+  return target;
+}
+function objectForEach(obj, action) {
+  for (var prop in obj) {
+    if (hasOwnProperty(obj, prop)) {
+      action(prop, obj[prop]);
+    }
+  }
+}
+function objectMap(source, mapping, thisArg) {
+  if (!source) {
+    return source;
+  }
+  if (arguments.length > 2) {
+    mapping = mapping.bind(thisArg);
+  }
+  var target = {};
+  for (var prop in source) {
+    if (hasOwnProperty(source, prop)) {
+      target[prop] = mapping(source[prop], prop, source);
+    }
+  }
+  return target;
+}
+function getObjectOwnProperty(obj, propName) {
+  return hasOwnProperty(obj, propName) ? obj[propName] : void 0;
+}
+function clonePlainObjectDeep(obj, seen) {
+  if (!seen) {
+    seen = [];
+  }
+  if (!obj || typeof obj !== "object" || obj.constructor !== Object || seen.indexOf(obj) !== -1) {
+    return obj;
+  }
+  seen.push(obj);
+  var result = {};
+  for (var prop in obj) {
+    if (hasOwnProperty(obj, prop)) {
+      result[prop] = clonePlainObjectDeep(obj[prop], seen);
+    }
+  }
+  return result;
+}
+function safeStringify(value) {
+  const seen = /* @__PURE__ */ new Set();
+  return JSON.stringify(value, (k, v) => {
+    if (seen.has(v)) {
+      return "...";
+    }
+    if (typeof v === "object") {
+      seen.add(v);
+    }
+    return v;
+  });
+}
+function isThenable(object2) {
+  return isObjectLike(object2) && typeof object2.then === "function";
+}
+
+// src/function.ts
+function testOverwrite() {
+  try {
+    Object.defineProperty(function x() {
+    }, "length", {});
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+var functionSupportsLengthOverwrite = testOverwrite();
+function overwriteLengthPropertyIfSupported(fn, descriptor) {
+  if (functionSupportsLengthOverwrite) {
+    Object.defineProperty(fn, "length", descriptor);
+  }
+}
+
+// src/string.ts
+function stringTrim(string) {
+  return string === null || string === void 0 ? "" : string.trim ? string.trim() : string.toString().replace(/^[\s\xa0]+|[\s\xa0]+$/g, "");
+}
+function stringStartsWith(string, startsWith) {
+  string = string || "";
+  if (startsWith.length > string.length) {
+    return false;
+  }
+  return string.substring(0, startsWith.length) === startsWith;
+}
+function parseJson(jsonString) {
+  if (typeof jsonString === "string") {
+    jsonString = stringTrim(jsonString);
+    if (jsonString) {
+      if (JSON && JSON.parse) {
+        return JSON.parse(jsonString);
+      }
+      return new Function("return " + jsonString)();
+    }
+  }
+  return null;
+}
+
+// src/symbol.ts
+var useSymbols = typeof Symbol === "function";
+function createSymbolOrString(identifier) {
+  return useSymbols ? Symbol(identifier) : identifier;
+}
+
+// src/css.ts
+var cssClassNameRegex = /\S+/g;
+function toggleDomNodeCssClass(node, classNames, shouldHaveClass) {
+  var addOrRemoveFn;
+  if (!classNames) {
+    return;
+  }
+  if (typeof node.classList === "object") {
+    addOrRemoveFn = node.classList[shouldHaveClass ? "add" : "remove"];
+    arrayForEach(classNames.match(cssClassNameRegex), function(className) {
+      addOrRemoveFn.call(node.classList, className);
+    });
+  } else if (typeof node.className["baseVal"] === "string") {
+    toggleObjectClassPropertyString(node.className, "baseVal", classNames, shouldHaveClass);
+  } else {
+    toggleObjectClassPropertyString(node, "className", classNames, shouldHaveClass);
+  }
+}
+function toggleObjectClassPropertyString(obj, prop, classNames, shouldHaveClass) {
+  var currentClassNames = obj[prop].match(cssClassNameRegex) || [];
+  arrayForEach(classNames.match(cssClassNameRegex), function(className) {
+    addOrRemoveItem(currentClassNames, className, shouldHaveClass);
+  });
+  obj[prop] = currentClassNames.join(" ");
+}
+
+// src/jquery.ts
+var jQueryInstance = options_default.global && options_default.global.jQuery;
+function jQuerySetInstance(jquery) {
+  options_default.jQuery = jQueryInstance = jquery;
+}
+
+// src/dom/info.ts
+function domNodeIsContainedBy(node, containedByNode) {
+  if (node === containedByNode) {
+    return true;
+  }
+  if (node.nodeType === 11) {
+    return false;
+  }
+  if (containedByNode.contains) {
+    return containedByNode.contains(node.nodeType !== 1 ? node.parentNode : node);
+  }
+  if (containedByNode.compareDocumentPosition) {
+    return (containedByNode.compareDocumentPosition(node) & 16) == 16;
+  }
+  while (node && node != containedByNode) {
+    node = node.parentNode;
+  }
+  return !!node;
+}
+function domNodeIsAttachedToDocument(node) {
+  return domNodeIsContainedBy(node, node.ownerDocument.documentElement);
+}
+function anyDomNodeIsAttachedToDocument(nodes) {
+  return !!arrayFirst(nodes, domNodeIsAttachedToDocument);
+}
+function tagNameLower(element) {
+  return element && element.tagName && element.tagName.toLowerCase();
+}
+function isDomElement(obj) {
+  if (window.HTMLElement) {
+    return obj instanceof HTMLElement;
+  } else {
+    return obj && obj.tagName && obj.nodeType === 1;
+  }
+}
+function isDocumentFragment(obj) {
+  if (window.DocumentFragment) {
+    return obj instanceof DocumentFragment;
+  } else {
+    return obj && obj.nodeType === 11;
+  }
+}
+
+// src/dom/data.ts
+var data_exports = {};
+__export(data_exports, {
+  clear: () => clear,
+  get: () => get,
+  getOrSet: () => getOrSet,
+  nextKey: () => nextKey,
+  set: () => set
+});
+var datastoreTime = new Date().getTime();
+var dataStoreKeyExpandoPropertyName = `__ko__${datastoreTime}`;
+var dataStoreSymbol = Symbol("Knockout data");
+var dataStore;
+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;
+  }
+};
+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;
+  }
+};
+var { getDataForNode, clear } = ieVersion ? IE : modern;
+function nextKey() {
+  return uniqueId++ + dataStoreKeyExpandoPropertyName;
+}
+function get(node, key) {
+  const dataForNode = getDataForNode(node, false);
+  return dataForNode && dataForNode[key];
+}
+function set(node, key, value) {
+  var dataForNode = getDataForNode(node, value !== void 0);
+  dataForNode && (dataForNode[key] = value);
+}
+function getOrSet(node, key, value) {
+  const dataForNode = getDataForNode(node, true);
+  return dataForNode[key] || (dataForNode[key] = value);
+}
+
+// src/dom/disposal.ts
+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);
+  if (allDisposeCallbacks === void 0 && createIfNotFound) {
+    allDisposeCallbacks = [];
+    set(node, domDataKey, allDisposeCallbacks);
+  }
+  return allDisposeCallbacks;
+}
+function destroyCallbacksCollection(node) {
+  set(node, domDataKey, void 0);
+}
+function cleanSingleNode(node) {
+  var callbacks = getDisposeCallbacksCollection(node, false);
+  if (callbacks) {
+    callbacks = callbacks.slice(0);
+    for (let i = 0; i < callbacks.length; i++) {
+      callbacks[i](node);
+    }
+  }
+  clear(node);
+  for (let i = 0, j = otherNodeCleanerFunctions.length; i < j; ++i) {
+    otherNodeCleanerFunctions[i](node);
+  }
+  if (options_default.cleanExternalData) {
+    options_default.cleanExternalData(node);
+  }
+  if (cleanableNodeTypesWithDescendants[node.nodeType]) {
+    cleanNodesInList(node.childNodes, true);
+  }
+}
+function cleanNodesInList(nodeList, onlyComments) {
+  const cleanedNodes = [];
+  let lastCleanedNode;
+  for (var i = 0; i < nodeList.length; i++) {
+    if (!onlyComments || nodeList[i].nodeType === 8) {
+      cleanSingleNode(cleanedNodes[cleanedNodes.length] = lastCleanedNode = nodeList[i]);
+      if (nodeList[i] !== lastCleanedNode) {
+        while (i-- && arrayIndexOf(cleanedNodes, nodeList[i]) === -1) {
+        }
+      }
+    }
+  }
+}
+function addDisposeCallback(node, callback) {
+  if (typeof callback !== "function") {
+    throw new Error("Callback must be a function");
+  }
+  getDisposeCallbacksCollection(node, true).push(callback);
+}
+function removeDisposeCallback(node, callback) {
+  var callbacksCollection = getDisposeCallbacksCollection(node, false);
+  if (callbacksCollection) {
+    arrayRemoveItem(callbacksCollection, callback);
+    if (callbacksCollection.length === 0) {
+      destroyCallbacksCollection(node);
+    }
+  }
+}
+function cleanNode(node) {
+  if (cleanableNodeTypes[node.nodeType]) {
+    cleanSingleNode(node);
+    if (cleanableNodeTypesWithDescendants[node.nodeType]) {
+      cleanNodesInList(node.getElementsByTagName("*"));
+    }
+  }
+  return node;
+}
+function removeNode(node) {
+  cleanNode(node);
+  if (node.parentNode) {
+    node.parentNode.removeChild(node);
+  }
+}
+var otherNodeCleanerFunctions = [];
+function addCleaner(fn) {
+  otherNodeCleanerFunctions.push(fn);
+}
+function removeCleaner(fn) {
+  const fnIndex = otherNodeCleanerFunctions.indexOf(fn);
+  if (fnIndex >= 0) {
+    otherNodeCleanerFunctions.splice(fnIndex, 1);
+  }
+}
+function cleanjQueryData(node) {
+  var jQueryCleanNodeFn = jQueryInstance ? jQueryInstance.cleanData : null;
+  if (jQueryCleanNodeFn) {
+    jQueryCleanNodeFn([node]);
+  }
+}
+otherNodeCleanerFunctions.push(cleanjQueryData);
+
+// src/dom/event.ts
+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, handler, eventOptions = false) {
+  const wrappedHandler = catchFunctionErrors(handler);
+  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");
+  }
+}
+
+// src/dom/manipulation.ts
+function moveCleanedNodesToContainerElement(nodes) {
+  var nodesArray = makeArray(nodes);
+  var templateDocument = nodesArray[0] && nodesArray[0].ownerDocument || document;
+  var container = templateDocument.createElement("div");
+  for (var i = 0, j = nodesArray.length; i < j; i++) {
+    container.appendChild(cleanNode(nodesArray[i]));
+  }
+  return container;
+}
+function cloneNodes(nodesArray, shouldCleanNodes) {
+  for (var i = 0, j = nodesArray.length, newNodesArray = []; i < j; i++) {
+    var clonedNode = nodesArray[i].cloneNode(true);
+    newNodesArray.push(shouldCleanNodes ? cleanNode(clonedNode) : clonedNode);
+  }
+  return newNodesArray;
+}
+function setDomNodeChildren(domNode, childNodes2) {
+  emptyDomNode(domNode);
+  if (childNodes2) {
+    for (var i = 0, j = childNodes2.length; i < j; i++) {
+      domNode.appendChild(childNodes2[i]);
+    }
+  }
+}
+function replaceDomNodes(nodeToReplaceOrNodeArray, newNodesArray) {
+  var nodesToReplaceArray = nodeToReplaceOrNodeArray.nodeType ? [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);
+    }
+    for (i = 0, j = nodesToReplaceArray.length; i < j; 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);
+  }
+}
+
+// src/dom/fixes.ts
+function fixUpContinuousNodeArray(continuousNodeArray, parentNode) {
+  if (continuousNodeArray.length) {
+    parentNode = parentNode.nodeType === 8 && parentNode.parentNode || parentNode;
+    while (continuousNodeArray.length && continuousNodeArray[0].parentNode !== parentNode) {
+      continuousNodeArray.splice(0, 1);
+    }
+    while (continuousNodeArray.length > 1 && continuousNodeArray[continuousNodeArray.length - 1].parentNode !== parentNode) {
+      continuousNodeArray.length--;
+    }
+    if (continuousNodeArray.length > 1) {
+      var current = continuousNodeArray[0], last = continuousNodeArray[continuousNodeArray.length - 1];
+      continuousNodeArray.length = 0;
+      while (current !== last) {
+        continuousNodeArray.push(current);
+        current = current.nextSibling;
+      }
+      continuousNodeArray.push(last);
+    }
+  }
+  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;
+  }
+}
+
+// src/dom/virtualElements.ts
+var virtualElements_exports = {};
+__export(virtualElements_exports, {
+  allowedBindings: () => allowedBindings,
+  childNodes: () => childNodes,
+  emptyNode: () => emptyNode,
+  endCommentRegex: () => endCommentRegex,
+  firstChild: () => firstChild,
+  getVirtualChildren: () => getVirtualChildren,
+  hasBindingValue: () => hasBindingValue,
+  insertAfter: () => insertAfter,
+  isEndComment: () => isEndComment,
+  isStartComment: () => isStartComment,
+  lastChild: () => lastChild,
+  nextSibling: () => nextSibling,
+  normaliseVirtualElementDomStructure: () => normaliseVirtualElementDomStructure,
+  prepend: () => prepend,
+  previousSibling: () => previousSibling,
+  setDomNodeChildren: () => setDomNodeChildren2,
+  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 };
+function isStartComment(node) {
+  return node.nodeType == 8 && startCommentRegex.test(commentNodesHaveTextProperty ? node.text : node.nodeValue);
+}
+function isEndComment(node) {
+  return node.nodeType == 8 && endCommentRegex.test(commentNodesHaveTextProperty ? node.text : 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 = [];
+  while (currentNode = currentNode.nextSibling) {
+    if (isEndComment(currentNode)) {
+      set(currentNode, matchedEndCommentDataKey, true);
+      depth--;
+      if (depth === 0) {
+        return children;
+      }
+    }
+    children.push(currentNode);
+    if (isStartComment(currentNode)) {
+      depth++;
+    }
+  }
+  if (!allowUnbalanced) {
+    throw new Error("Cannot find closing comment tag to match: " + startComment.nodeValue);
+  }
+  return null;
+}
+function getMatchingEndComment(startComment, allowUnbalanced) {
+  var allVirtualChildren = getVirtualChildren(startComment, allowUnbalanced);
+  if (allVirtualChildren) {
+    if (allVirtualChildren.length > 0) {
+      return allVirtualChildren[allVirtualChildren.length - 1].nextSibling;
+    }
+    return startComment.nextSibling;
+  } else {
+    return null;
+  }
+}
+function getUnbalancedChildTags(node) {
+  var childNode = node.firstChild, captureRemaining = null;
+  if (childNode) {
+    do {
+      if (captureRemaining) {
+        captureRemaining.push(childNode);
+      } else if (isStartComment(childNode)) {
+        var matchingEndComment = getMatchingEndComment(childNode, true);
+        if (matchingEndComment) {
+          childNode = matchingEndComment;
+        } else {
+          captureRemaining = [childNode];
+        }
+      } else if (isEndComment(childNode)) {
+        captureRemaining = [childNode];
+      }
+    } while (childNode = childNode.nextSibling);
+  }
+  return captureRemaining;
+}
+var allowedBindings = {};
+var hasBindingValue = isStartComment;
+function childNodes(node) {
+  return isStartComment(node) ? getVirtualChildren(node) : node.childNodes;
+}
+function emptyNode(node) {
+  if (!isStartComment(node)) {
+    emptyDomNode(node);
+  } else {
+    var virtualChildren = childNodes(node);
+    for (var i = 0, j = virtualChildren.length; i < j; i++) {
+      removeNode(virtualChildren[i]);
+    }
+  }
+}
+function setDomNodeChildren2(node, childNodes2) {
+  if (!isStartComment(node)) {
+    setDomNodeChildren(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);
+    }
+  }
+}
+function prepend(containerNode, nodeToPrepend) {
+  if (!isStartComment(containerNode)) {
+    if (containerNode.firstChild) {
+      containerNode.insertBefore(nodeToPrepend, containerNode.firstChild);
+    } else {
+      containerNode.appendChild(nodeToPrepend);
+    }
+  } else {
+    containerNode.parentNode.insertBefore(nodeToPrepend, containerNode.nextSibling);
+  }
+}
+function insertAfter(containerNode, nodeToInsert, insertAfterNode) {
+  if (!insertAfterNode) {
+    prepend(containerNode, nodeToInsert);
+  } else if (!isStartComment(containerNode)) {
+    if (insertAfterNode.nextSibling) {
+      containerNode.insertBefore(nodeToInsert, insertAfterNode.nextSibling);
+    } else {
+      containerNode.appendChild(nodeToInsert);
+    }
+  } else {
+    containerNode.parentNode.insertBefore(nodeToInsert, insertAfterNode.nextSibling);
+  }
+}
+function firstChild(node) {
+  if (!isStartComment(node)) {
+    if (node.firstChild && isEndComment(node.firstChild)) {
+      throw new Error("Found invalid end comment, as the first child of " + node.outerHTML);
+    }
+    return node.firstChild;
+  }
+  if (!node.nextSibling || isEndComment(node.nextSibling)) {
+    return null;
+  }
+  return node.nextSibling;
+}
+function lastChild(node) {
+  let nextChild = firstChild(node);
+  let lastChildNode;
+  do {
+    lastChildNode = nextChild;
+  } while (nextChild = nextSibling(nextChild));
+  return lastChildNode;
+}
+function nextSibling(node) {
+  if (isStartComment(node)) {
+    node = getMatchingEndComment(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);
+    }
+    return null;
+  } else {
+    return node.nextSibling;
+  }
+}
+function previousSibling(node) {
+  var depth = 0;
+  do {
+    if (node.nodeType === 8) {
+      if (isStartComment(node)) {
+        if (--depth === 0) {
+          return node;
+        }
+      } else if (isEndComment(node)) {
+        depth++;
+      }
+    } else {
+      if (depth === 0) {
+        return node;
+      }
+    }
+  } while (node = node.previousSibling);
+}
+function virtualNodeBindingValue(node) {
+  var regexMatch = (commentNodesHaveTextProperty ? node.text : node.nodeValue).match(startCommentRegex);
+  return regexMatch ? regexMatch[1] : null;
+}
+function normaliseVirtualElementDomStructure(elementVerified) {
+  if (!htmlTagsWithOptionallyClosingChildren[tagNameLower(elementVerified)]) {
+    return;
+  }
+  var childNode = elementVerified.firstChild;
+  if (childNode) {
+    do {
+      if (childNode.nodeType === 1) {
+        var unbalancedTags = getUnbalancedChildTags(childNode);
+        if (unbalancedTags) {
+          var nodeToInsertBefore = childNode.nextSibling;
+          for (var i = 0; i < unbalancedTags.length; i++) {
+            if (nodeToInsertBefore) {
+              elementVerified.insertBefore(unbalancedTags[i], nodeToInsertBefore);
+            } else {
+              elementVerified.appendChild(unbalancedTags[i]);
+            }
+          }
+        }
+      }
+    } while (childNode = childNode.nextSibling);
+  }
+}
+
+// src/dom/html.ts
+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;
+}
+function simpleHtmlParse(html, documentContext) {
+  documentContext || (documentContext = document);
+  var windowContext = documentContext["parentWindow"] || documentContext["defaultView"] || window;
+  var tags = stringTrim(html).toLowerCase(), div = documentContext.createElement("div"), wrap = getWrap(tags), depth = wrap[0];
+  var markup = "ignored<div>" + wrap[1] + html + wrap[2] + "</div>";
+  if (typeof windowContext["innerShiv"] === "function") {
+    div.appendChild(windowContext["innerShiv"](markup));
+  } else {
+    div.innerHTML = markup;
+  }
+  while (depth--) {
+    div = div.lastChild;
+  }
+  return makeArray(div.lastChild.childNodes);
+}
+function templateHtmlParse(html, documentContext) {
+  if (!documentContext) {
+    documentContext = document;
+  }
+  var template = documentContext.createElement("template");
+  template.innerHTML = html;
+  return makeArray(template.content.childNodes);
+}
+function jQueryHtmlParse(html, documentContext) {
+  if (jQueryInstance.parseHTML) {
+    return jQueryInstance.parseHTML(html, documentContext) || [];
+  } else {
+    var elems = jQueryInstance.clean([html], 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;
+  }
+}
+function parseHtmlFragment(html, documentContext) {
+  return supportsTemplateTag ? templateHtmlParse(html, documentContext) : jQueryInstance ? jQueryHtmlParse(html, documentContext) : simpleHtmlParse(html, documentContext);
+}
+function parseHtmlForTemplateNodes(html, documentContext) {
+  const nodes = parseHtmlFragment(html, documentContext);
+  return nodes.length && nodes[0].parentElement || moveCleanedNodesToContainerElement(nodes);
+}
+function setHtml(node, html) {
+  emptyDomNode(node);
+  if (typeof html === "function") {
+    html = html();
+  }
+  if (html !== null && html !== void 0) {
+    if (typeof html !== "string") {
+      html = html.toString();
+    }
+    if (jQueryInstance && !supportsTemplateTag) {
+      jQueryInstance(node).html(html);
+    } else {
+      var parsedNodes = parseHtmlFragment(html, node.ownerDocument);
+      if (node.nodeType === 8) {
+        if (html === null) {
+          emptyNode(node);
+        } else {
+          setDomNodeChildren2(node, parsedNodes);
+        }
+      } else {
+        for (var i = 0; i < parsedNodes.length; i++) {
+          node.appendChild(parsedNodes[i]);
+        }
+      }
+    }
+  }
+}
+function setTextContent(element, textContent) {
+  var value = typeof textContent === "function" ? textContent() : textContent;
+  if (value === null || value === void 0) {
+    value = "";
+  }
+  var innerTextNode = firstChild(element);
+  if (!innerTextNode || innerTextNode.nodeType != 3 || nextSibling(innerTextNode)) {
+    setDomNodeChildren2(element, [element.ownerDocument.createTextNode(value)]);
+  } else {
+    innerTextNode.data = value;
+  }
+  forceRefresh(element);
+}
+
+// src/dom/selectExtensions.ts
+var hasDomDataExpandoProperty = Symbol("Knockout selectExtensions hasDomDataProperty");
+var selectExtensions = {
+  optionValueDomDataKey: nextKey(),
+  readValue: function(element) {
+    switch (tagNameLower(element)) {
+      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;
+      default:
+        return element.value;
+    }
+  },
+  writeValue: function(element, value, allowUnset) {
+    switch (tagNameLower(element)) {
+      case "option":
+        if (typeof value === "string") {
+          set(element, selectExtensions.optionValueDomDataKey, void 0);
+          if (hasDomDataExpandoProperty in element) {
+            delete element[hasDomDataExpandoProperty];
+          }
+          element.value = value;
+        } else {
+          set(element, selectExtensions.optionValueDomDataKey, value);
+          element[hasDomDataExpandoProperty] = true;
+          element.value = typeof value === "number" ? value : "";
+        }
+        break;
+      case "select":
+        if (value === "" || value === null) {
+          value = 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 === value;
+          const blankEqual = optionValue === "" && value === void 0;
+          const numericEqual = typeof value === "number" && Number(optionValue) === value;
+          if (strictEqual || blankEqual || numericEqual) {
+            selection = i;
+            break;
+          }
+        }
+        if (allowUnset || selection >= 0 || value === void 0 && element.size > 1) {
+          element.selectedIndex = selection;
+        }
+        break;
+      default:
+        if (value === null || value === void 0) {
+          value = "";
+        }
+        element.value = value;
+        break;
+    }
+  }
+};
+
+// src/memoization.ts
+var memoization_exports = {};
+__export(memoization_exports, {
+  memoize: () => memoize,
+  parseMemoText: () => parseMemoText,
+  unmemoize: () => unmemoize,
+  unmemoizeDomNodeAndDescendants: () => unmemoizeDomNodeAndDescendants
+});
+var memos = {};
+function randomMax8HexChars() {
+  return ((1 + Math.random()) * 4294967296 | 0).toString(16).substring(1);
+}
+function generateRandomId() {
+  return randomMax8HexChars() + randomMax8HexChars();
+}
+function findMemoNodes(rootNode, appendToArray) {
+  if (!rootNode) {
+    return;
+  }
+  if (rootNode.nodeType == 8) {
+    var memoId = parseMemoText(rootNode.nodeValue);
+    if (memoId != null) {
+      appendToArray.push({ domNode: rootNode, memoId });
+    }
+  } else if (rootNode.nodeType == 1) {
+    for (var i = 0, childNodes2 = rootNode.childNodes, j = childNodes2.length; i < j; i++) {
+      findMemoNodes(childNodes2[i], appendToArray);
+    }
+  }
+}
+function memoize(callback) {
+  if (typeof callback !== "function") {
+    throw new Error("You can only pass a function to memoization.memoize()");
+  }
+  var memoId = generateRandomId();
+  memos[memoId] = callback;
+  return "<!--[ko_memo:" + memoId + "]-->";
+}
+function unmemoize(memoId, callbackParams) {
+  var callback = memos[memoId];
+  if (callback === void 0) {
+    throw new Error("Couldn't find any memo with ID " + memoId + ". Perhaps it's already been unmemoized.");
+  }
+  try {
+    callback.apply(null, callbackParams || []);
+    return true;
+  } finally {
+    delete memos[memoId];
+  }
+}
+function unmemoizeDomNodeAndDescendants(domNode, extraCallbackParamsArray) {
+  var memos2 = [];
+  findMemoNodes(domNode, memos2);
+  for (var i = 0, j = memos2.length; i < j; i++) {
+    var node = memos2[i].domNode;
+    var combinedParams = [node];
+    if (extraCallbackParamsArray) {
+      arrayPushAll(combinedParams, extraCallbackParamsArray);
+    }
+    unmemoize(memos2[i].memoId, combinedParams);
+    node.nodeValue = "";
+    if (node.parentNode) {
+      node.parentNode.removeChild(node);
+    }
+  }
+}
+function parseMemoText(memoText) {
+  var match = memoText.match(/^\[ko_memo\:(.*?)\]$/);
+  return match ? match[1] : null;
+}
+
+// src/tasks.ts
+var tasks_exports = {};
+__export(tasks_exports, {
+  cancel: () => cancel,
+  resetForTesting: () => resetForTesting,
+  runEarly: () => processTasks,
+  schedule: () => schedule
+});
+var taskQueue = [];
+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");
+    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);
+  };
+} else {
+  options_default.taskScheduler = function(callback) {
+    setTimeout(callback, 0);
+  };
+}
+function processTasks() {
+  if (taskQueueLength) {
+    var mark = taskQueueLength, countMarks = 0;
+    for (var task; nextIndexToProcess < taskQueueLength; ) {
+      if (task = taskQueue[nextIndexToProcess++]) {
+        if (nextIndexToProcess > mark) {
+          if (++countMarks >= 5e3) {
+            nextIndexToProcess = taskQueueLength;
+            deferError(Error("'Too much recursion' after processing " + countMarks + " task groups."));
+            break;
+          }
+          mark = taskQueueLength;
+        }
+        try {
+          task();
+        } catch (ex) {
+          deferError(ex);
+        }
+      }
+    }
+  }
+}
+function scheduledProcess() {
+  processTasks();
+  nextIndexToProcess = taskQueueLength = taskQueue.length = 0;
+}
+function scheduleTaskProcessing() {
+  options_default.taskScheduler(scheduledProcess);
+}
+function schedule(func) {
+  if (!taskQueueLength) {
+    scheduleTaskProcessing();
+  }
+  taskQueue[taskQueueLength++] = func;
+  return nextHandle++;
+}
+function cancel(handle) {
+  var index = handle - (nextHandle - taskQueueLength);
+  if (index >= nextIndexToProcess && index < taskQueueLength) {
+    taskQueue[index] = null;
+  }
+}
+function resetForTesting() {
+  var length = taskQueueLength - nextIndexToProcess;
+  nextIndexToProcess = taskQueueLength = taskQueue.length = 0;
+  return length;
+}