@tko/builder 4.0.0-alpha9.0 → 4.0.0-beta1.0

package/dist/index.cjs

@@ -0,0 +1,4232 @@
+// @tko/builder 🥊 4.0.0-beta1.0 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 = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
+
+// index.ts
+var builder_exports = {};
+__export(builder_exports, {
+  Builder: () => Builder
+});
+module.exports = __toCommonJS(builder_exports);
+
+// ../utils/dist/array.js
+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();
+}
+
+// ../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, value) {
+    options[name] = value;
+  },
+  getBindingHandler() {
+  },
+  cleanExternalData() {
+  }
+};
+Object.defineProperty(options, "$", {
+  get: function() {
+    return options.jQuery;
+  }
+});
+var options_default = options;
+
+// ../utils/dist/error.js
+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);
+}
+
+// ../utils/dist/async.js
+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);
+  };
+}
+
+// ../utils/dist/ie.js
+var ieVersion = options_default.document && function() {
+  var version = 3, div2 = options_default.document.createElement("div"), iElems = div2.getElementsByTagName("i");
+  while (div2.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);
+}
+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;
+}
+
+// ../utils/dist/function.js
+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);
+  }
+}
+
+// ../utils/dist/string.js
+function stringTrim(string) {
+  return string === null || string === void 0 ? "" : string.trim ? string.trim() : string.toString().replace(/^[\s\xa0]+|[\s\xa0]+$/g, "");
+}
+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;
+}
+
+// ../utils/dist/symbol.js
+var useSymbols = typeof Symbol === "function";
+function createSymbolOrString(identifier) {
+  return useSymbols ? Symbol(identifier) : identifier;
+}
+
+// ../utils/dist/css.js
+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(" ");
+}
+
+// ../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) {
+    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();
+}
+
+// ../utils/dist/dom/data.js
+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);
+}
+
+// ../utils/dist/dom/disposal.js
+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);
+
+// ../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, 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");
+  }
+}
+
+// ../utils/dist/dom/manipulation.js
+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 emptyDomNode(domNode) {
+  while (domNode.firstChild) {
+    removeNode(domNode.firstChild);
+  }
+}
+
+// ../utils/dist/dom/fixes.js
+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 forceRefresh(node) {
+  if (ieVersion >= 9) {
+    var elem = node.nodeType == 1 ? node : node.parentNode;
+    if (elem.style) {
+      elem.style.zoom = elem.style.zoom;
+    }
+  }
+}
+
+// ../utils/dist/dom/virtualElements.js
+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);
+  }
+}
+
+// ../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;
+}
+function simpleHtmlParse(html, documentContext) {
+  documentContext || (documentContext = document);
+  var windowContext = documentContext["parentWindow"] || documentContext["defaultView"] || window;
+  var tags = stringTrim(html).toLowerCase(), div2 = documentContext.createElement("div"), wrap = getWrap(tags), depth = wrap[0];
+  var markup = "ignored<div>" + wrap[1] + html + wrap[2] + "</div>";
+  if (typeof windowContext["innerShiv"] === "function") {
+    div2.appendChild(windowContext["innerShiv"](markup));
+  } else {
+    div2.innerHTML = markup;
+  }
+  while (depth--) {
+    div2 = div2.lastChild;
+  }
+  return makeArray(div2.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);
+}
+
+// ../utils/dist/dom/selectExtensions.js
+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;
+    }
+  }
+};
+
+// ../utils/dist/memoization.js
+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;
+}
+
+// ../utils/dist/tasks.js
+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 div2 = w.document.createElement("div");
+    new w.MutationObserver(callback).observe(div2, { attributes: true });
+    return function() {
+      div2.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;
+}
+
+// ../observable/dist/dependencyDetection.js
+var dependencyDetection_exports = {};
+__export(dependencyDetection_exports, {
+  begin: () => begin,
+  end: () => end,
+  getDependencies: () => getDependencies,
+  getDependenciesCount: () => getDependenciesCount,
+  ignore: () => ignore,
+  ignoreDependencies: () => ignore,
+  isInitial: () => isInitial,
+  registerDependency: () => registerDependency
+});
+
+// ../observable/dist/subscribableSymbol.js
+var SUBSCRIBABLE_SYM = Symbol("Knockout Subscribable");
+function isSubscribable(instance) {
+  return instance && instance[SUBSCRIBABLE_SYM] || false;
+}
+
+// ../observable/dist/dependencyDetection.js
+var outerFrames = [];
+var currentFrame;
+var lastId = 0;
+function getId() {
+  return ++lastId;
+}
+function begin(options2) {
+  outerFrames.push(currentFrame);
+  currentFrame = options2;
+}
+function end() {
+  currentFrame = outerFrames.pop();
+}
+function registerDependency(subscribable2) {
+  if (currentFrame) {
+    if (!isSubscribable(subscribable2)) {
+      throw new Error("Only subscribable things can act as dependencies");
+    }
+    currentFrame.callback.call(currentFrame.callbackTarget, subscribable2, subscribable2._id || (subscribable2._id = getId()));
+  }
+}
+function ignore(callback, callbackTarget, callbackArgs) {
+  try {
+    begin();
+    return callback.apply(callbackTarget, callbackArgs || []);
+  } finally {
+    end();
+  }
+}
+function getDependenciesCount() {
+  if (currentFrame) {
+    return currentFrame.computed.getDependenciesCount();
+  }
+}
+function getDependencies() {
+  if (currentFrame) {
+    return currentFrame.computed.getDependencies();
+  }
+}
+function isInitial() {
+  if (currentFrame) {
+    return currentFrame.isInitial;
+  }
+}
+
+// ../observable/dist/defer.js
+function deferUpdates(target) {
+  if (target._deferUpdates) {
+    return;
+  }
+  target._deferUpdates = true;
+  target.limit(function(callback) {
+    let handle;
+    let ignoreUpdates = false;
+    return function() {
+      if (!ignoreUpdates) {
+        tasks_exports.cancel(handle);
+        handle = tasks_exports.schedule(callback);
+        try {
+          ignoreUpdates = true;
+          target.notifySubscribers(void 0, "dirty");
+        } finally {
+          ignoreUpdates = false;
+        }
+      }
+    };
+  });
+}
+
+// ../observable/dist/Subscription.js
+var Subscription = class {
+  constructor(target, observer, disposeCallback) {
+    this._target = target;
+    this._callback = observer.next;
+    this._disposeCallback = disposeCallback;
+    this._isDisposed = false;
+    this._domNodeDisposalCallback = null;
+  }
+  dispose() {
+    if (this._domNodeDisposalCallback) {
+      removeDisposeCallback(this._node, this._domNodeDisposalCallback);
+    }
+    this._isDisposed = true;
+    this._disposeCallback();
+  }
+  disposeWhenNodeIsRemoved(node) {
+    this._node = node;
+    addDisposeCallback(node, this._domNodeDisposalCallback = this.dispose.bind(this));
+  }
+  unsubscribe() {
+    this.dispose();
+  }
+  get closed() {
+    return this._isDisposed;
+  }
+};
+
+// ../observable/dist/extenders.js
+var primitiveTypes = {
+  "undefined": 1,
+  "boolean": 1,
+  "number": 1,
+  "string": 1
+};
+function valuesArePrimitiveAndEqual(a, b) {
+  var oldValueIsPrimitive = a === null || typeof a in primitiveTypes;
+  return oldValueIsPrimitive ? a === b : false;
+}
+function applyExtenders(requestedExtenders) {
+  var target = this;
+  if (requestedExtenders) {
+    objectForEach(requestedExtenders, function(key, value) {
+      var extenderHandler = extenders[key];
+      if (typeof extenderHandler === "function") {
+        target = extenderHandler(target, value) || target;
+      } else {
+        options_default.onError(new Error("Extender not found: " + key));
+      }
+    });
+  }
+  return target;
+}
+function notify(target, notifyWhen) {
+  target.equalityComparer = notifyWhen == "always" ? null : valuesArePrimitiveAndEqual;
+}
+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.");
+  }
+  deferUpdates(target);
+}
+function rateLimit(target, options2) {
+  var timeout, method, limitFunction;
+  if (typeof options2 === "number") {
+    timeout = options2;
+  } else {
+    timeout = options2.timeout;
+    method = options2.method;
+  }
+  target._deferUpdates = false;
+  limitFunction = method === "notifyWhenChangesStop" ? debounce : throttle;
+  target.limit(function(callback) {
+    return limitFunction(callback, timeout);
+  });
+}
+var extenders = {
+  notify,
+  deferred,
+  rateLimit
+};
+
+// ../observable/dist/subscribable.js
+var LATEST_VALUE = Symbol("Knockout latest value");
+if (!Symbol.observable) {
+  Symbol.observable = Symbol.for("@tko/Symbol.observable");
+}
+function subscribable() {
+  Object.setPrototypeOf(this, ko_subscribable_fn);
+  ko_subscribable_fn.init(this);
+}
+var defaultEvent = "change";
+var ko_subscribable_fn = {
+  [SUBSCRIBABLE_SYM]: true,
+  [Symbol.observable]() {
+    return this;
+  },
+  init(instance) {
+    instance._subscriptions = { change: [] };
+    instance._versionNumber = 1;
+  },
+  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 subscriptionInstance = new Subscription(this, observer, () => {
+      arrayRemoveItem(this._subscriptions[event], subscriptionInstance);
+      if (this.afterSubscriptionRemove) {
+        this.afterSubscriptionRemove(event);
+      }
+    });
+    if (this.beforeSubscriptionAdd) {
+      this.beforeSubscriptionAdd(event);
+    }
+    if (!this._subscriptions[event]) {
+      this._subscriptions[event] = [];
+    }
+    this._subscriptions[event].push(subscriptionInstance);
+    if (isTC39Callback && LATEST_VALUE in this) {
+      observer.next(this[LATEST_VALUE]);
+    }
+    return subscriptionInstance;
+  },
+  notifySubscribers(valueToNotify, event) {
+    event = event || defaultEvent;
+    if (event === defaultEvent) {
+      this.updateVersion();
+    }
+    if (this.hasSubscriptionsForEvent(event)) {
+      const subs = event === defaultEvent && this._changeSubscriptions || [...this._subscriptions[event]];
+      try {
+        begin();
+        for (let i = 0, subscriptionInstance; subscriptionInstance = subs[i]; ++i) {
+          if (!subscriptionInstance._isDisposed) {
+            subscriptionInstance._callback(valueToNotify);
+          }
+        }
+      } finally {
+        end();
+      }
+    }
+  },
+  getVersion() {
+    return this._versionNumber;
+  },
+  hasChanged(versionToCheck) {
+    return this.getVersion() !== versionToCheck;
+  },
+  updateVersion() {
+    ++this._versionNumber;
+  },
+  hasSubscriptionsForEvent(event) {
+    return this._subscriptions[event] && this._subscriptions[event].length;
+  },
+  getSubscriptionsCount(event) {
+    if (event) {
+      return this._subscriptions[event] && this._subscriptions[event].length || 0;
+    } else {
+      var total = 0;
+      objectForEach(this._subscriptions, function(eventName, subscriptions) {
+        if (eventName !== "dirty") {
+          total += subscriptions.length;
+        }
+      });
+      return total;
+    }
+  },
+  isDifferent(oldValue, newValue) {
+    return !this.equalityComparer || !this.equalityComparer(oldValue, newValue);
+  },
+  once(cb) {
+    const subs = this.subscribe((nv) => {
+      subs.dispose();
+      cb(nv);
+    });
+  },
+  when(test, returnValue) {
+    const current = this.peek();
+    const givenRv = arguments.length > 1;
+    const testFn = typeof test === "function" ? test : (v) => v === test;
+    if (testFn(current)) {
+      return options_default.Promise.resolve(givenRv ? returnValue : current);
+    }
+    return new options_default.Promise((resolve, reject) => {
+      const subs = this.subscribe((newValue) => {
+        if (testFn(newValue)) {
+          subs.dispose();
+          resolve(givenRv ? returnValue : newValue);
+        }
+      });
+    });
+  },
+  yet(test, ...args) {
+    const testFn = typeof test === "function" ? test : (v) => v === test;
+    const negated = (v) => !testFn(v);
+    return this.when(negated, ...args);
+  },
+  next() {
+    return new Promise((resolve) => this.once(resolve));
+  },
+  toString() {
+    return "[object Object]";
+  },
+  extend: applyExtenders
+};
+Object.setPrototypeOf(ko_subscribable_fn, Function.prototype);
+subscribable.fn = ko_subscribable_fn;
+
+// ../observable/dist/observable.js
+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();
+      }
+      return this;
+    } else {
+      registerDependency(Observable);
+      return Observable[LATEST_VALUE];
+    }
+  }
+  overwriteLengthPropertyIfSupported(Observable, { value: void 0 });
+  Observable[LATEST_VALUE] = initialValue;
+  subscribable.fn.init(Observable);
+  Object.setPrototypeOf(Observable, observable.fn);
+  if (options_default.deferUpdates) {
+    deferUpdates(Observable);
+  }
+  return Observable;
+}
+observable.fn = {
+  equalityComparer: valuesArePrimitiveAndEqual,
+  peek() {
+    return this[LATEST_VALUE];
+  },
+  valueHasMutated() {
+    this.notifySubscribers(this[LATEST_VALUE], "spectate");
+    this.notifySubscribers(this[LATEST_VALUE]);
+  },
+  valueWillMutate() {
+    this.notifySubscribers(this[LATEST_VALUE], "beforeChange");
+  },
+  modify(fn, peek22 = true) {
+    return this(fn(peek22 ? this.peek() : this()));
+  },
+  isWriteable: true
+};
+function limitNotifySubscribers(value, event) {
+  if (!event || event === defaultEvent) {
+    this._limitChange(value);
+  } else if (event === "beforeChange") {
+    this._limitBeforeChange(value);
+  } else {
+    this._origNotifySubscribers(value, event);
+  }
+}
+subscribable.fn.limit = function limit(limitFunction) {
+  var self = this;
+  var selfIsObservable = isObservable(self);
+  var beforeChange = "beforeChange";
+  var ignoreBeforeChange, notifyNextChange, previousValue, pendingValue, didUpdate;
+  if (!self._origNotifySubscribers) {
+    self._origNotifySubscribers = self.notifySubscribers;
+    self.notifySubscribers = limitNotifySubscribers;
+  }
+  var finish = limitFunction(function() {
+    self._notificationIsPending = false;
+    if (selfIsObservable && pendingValue === self) {
+      pendingValue = self._evalIfChanged ? self._evalIfChanged() : self();
+    }
+    const shouldNotify = notifyNextChange || didUpdate && self.isDifferent(previousValue, pendingValue);
+    self._notifyNextChange = didUpdate = ignoreBeforeChange = false;
+    if (shouldNotify) {
+      self._origNotifySubscribers(previousValue = pendingValue);
+    }
+  });
+  Object.assign(self, {
+    _limitChange(value, isDirty) {
+      if (!isDirty || !self._notificationIsPending) {
+        didUpdate = !isDirty;
+      }
+      self._changeSubscriptions = [...self._subscriptions[defaultEvent]];
+      self._notificationIsPending = ignoreBeforeChange = true;
+      pendingValue = value;
+      finish();
+    },
+    _limitBeforeChange(value) {
+      if (!ignoreBeforeChange) {
+        previousValue = value;
+        self._origNotifySubscribers(value, beforeChange);
+      }
+    },
+    _notifyNextChangeIfValueIsDifferent() {
+      if (self.isDifferent(previousValue, self.peek(true))) {
+        notifyNextChange = true;
+      }
+    },
+    _recordUpdate() {
+      didUpdate = true;
+    }
+  });
+};
+Object.setPrototypeOf(observable.fn, subscribable.fn);
+var protoProperty = observable.protoProperty = options_default.protoProperty;
+observable.fn[protoProperty] = observable;
+observable.observablePrototypes = /* @__PURE__ */ new Set([observable]);
+function isObservable(instance) {
+  const proto = typeof instance === "function" && instance[protoProperty];
+  if (proto && !observable.observablePrototypes.has(proto)) {
+    throw Error("Invalid object that looks like an observable; possibly from another Knockout instance");
+  }
+  return !!proto;
+}
+function unwrap(value) {
+  return isObservable(value) ? value() : value;
+}
+function peek(value) {
+  return isObservable(value) ? value.peek() : value;
+}
+function isWriteableObservable(instance) {
+  return isObservable(instance) && instance.isWriteable;
+}
+
+// ../observable/dist/observableArray.changeTracking.js
+var arrayChangeEventName = "arrayChange";
+function trackArrayChanges(target, options2) {
+  target.compareArrayOptions = {};
+  if (options2 && typeof options2 === "object") {
+    extend(target.compareArrayOptions, options2);
+  }
+  target.compareArrayOptions.sparse = true;
+  if (target.cacheDiffForKnownOperation) {
+    return;
+  }
+  let trackingChanges = false;
+  let cachedDiff = null;
+  let arrayChangeSubscription;
+  let pendingNotifications = 0;
+  let underlyingNotifySubscribersFunction;
+  let underlyingBeforeSubscriptionAddFunction = target.beforeSubscriptionAdd;
+  let underlyingAfterSubscriptionRemoveFunction = target.afterSubscriptionRemove;
+  target.beforeSubscriptionAdd = function(event) {
+    if (underlyingBeforeSubscriptionAddFunction) {
+      underlyingBeforeSubscriptionAddFunction.call(target, event);
+    }
+    if (event === arrayChangeEventName) {
+      trackChanges();
+    }
+  };
+  target.afterSubscriptionRemove = function(event) {
+    if (underlyingAfterSubscriptionRemoveFunction) {
+      underlyingAfterSubscriptionRemoveFunction.call(target, event);
+    }
+    if (event === arrayChangeEventName && !target.hasSubscriptionsForEvent(arrayChangeEventName)) {
+      if (underlyingNotifySubscribersFunction) {
+        target.notifySubscribers = underlyingNotifySubscribersFunction;
+        underlyingNotifySubscribersFunction = void 0;
+      }
+      if (arrayChangeSubscription) {
+        arrayChangeSubscription.dispose();
+      }
+      arrayChangeSubscription = null;
+      trackingChanges = false;
+    }
+  };
+  function trackChanges() {
+    if (trackingChanges) {
+      return;
+    }
+    trackingChanges = true;
+    underlyingNotifySubscribersFunction = target["notifySubscribers"];
+    target.notifySubscribers = function(valueToNotify, event) {
+      if (!event || event === defaultEvent) {
+        ++pendingNotifications;
+      }
+      return underlyingNotifySubscribersFunction.apply(this, arguments);
+    };
+    var previousContents = [].concat(target.peek() === void 0 ? [] : target.peek());
+    cachedDiff = null;
+    arrayChangeSubscription = target.subscribe(function(currentContents) {
+      let changes;
+      currentContents = [].concat(currentContents || []);
+      if (target.hasSubscriptionsForEvent(arrayChangeEventName)) {
+        changes = getChanges(previousContents, currentContents);
+      }
+      previousContents = currentContents;
+      cachedDiff = null;
+      pendingNotifications = 0;
+      if (changes && changes.length) {
+        target.notifySubscribers(changes, arrayChangeEventName);
+      }
+    });
+  }
+  function getChanges(previousContents, currentContents) {
+    if (!cachedDiff || pendingNotifications > 1) {
+      cachedDiff = trackArrayChanges.compareArrays(previousContents, currentContents, target.compareArrayOptions);
+    }
+    return cachedDiff;
+  }
+  target.cacheDiffForKnownOperation = function(rawArray, operationName, args) {
+    if (!trackingChanges || pendingNotifications) {
+      return;
+    }
+    var diff = [], arrayLength = rawArray.length, argsLength = args.length, offset = 0;
+    function pushDiff(status, value, index) {
+      return diff[diff.length] = { "status": status, "value": value, "index": index };
+    }
+    switch (operationName) {
+      case "push":
+        offset = arrayLength;
+      case "unshift":
+        for (let index = 0; index < argsLength; index++) {
+          pushDiff("added", args[index], offset + index);
+        }
+        break;
+      case "pop":
+        offset = arrayLength - 1;
+      case "shift":
+        if (arrayLength) {
+          pushDiff("deleted", rawArray[offset], offset);
+        }
+        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));
+          }
+        }
+        findMovesInArrayComparison(deletions, additions);
+        break;
+      default:
+        return;
+    }
+    cachedDiff = diff;
+  };
+}
+trackArrayChanges.compareArrays = compareArrays;
+extenders.trackArrayChanges = trackArrayChanges;
+
+// ../observable/dist/observableArray.js
+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.");
+  }
+  var result = observable(initialValues);
+  Object.setPrototypeOf(result, observableArray.fn);
+  trackArrayChanges(result);
+  overwriteLengthPropertyIfSupported(result, { get: () => result().length });
+  return result;
+}
+function isObservableArray(instance) {
+  return isObservable(instance) && typeof instance.remove === "function" && typeof instance.push === "function";
+}
+observableArray.fn = {
+  remove(valueOrPredicate) {
+    var underlyingArray = this.peek();
+    var removedValues = [];
+    var predicate = typeof valueOrPredicate === "function" && !isObservable(valueOrPredicate) ? valueOrPredicate : function(value2) {
+      return value2 === valueOrPredicate;
+    };
+    for (var i = 0; i < underlyingArray.length; i++) {
+      var value = underlyingArray[i];
+      if (predicate(value)) {
+        if (removedValues.length === 0) {
+          this.valueWillMutate();
+        }
+        if (underlyingArray[i] !== value) {
+          throw Error("Array modified during remove; cannot remove item");
+        }
+        removedValues.push(value);
+        underlyingArray.splice(i, 1);
+        i--;
+      }
+    }
+    if (removedValues.length) {
+      this.valueHasMutated();
+    }
+    return removedValues;
+  },
+  removeAll(arrayOfValues) {
+    if (arrayOfValues === void 0) {
+      var underlyingArray = this.peek();
+      var allValues = underlyingArray.slice(0);
+      this.valueWillMutate();
+      underlyingArray.splice(0, underlyingArray.length);
+      this.valueHasMutated();
+      return allValues;
+    }
+    if (!arrayOfValues) {
+      return [];
+    }
+    return this["remove"](function(value) {
+      return arrayIndexOf(arrayOfValues, value) >= 0;
+    });
+  },
+  destroy(valueOrPredicate) {
+    var underlyingArray = this.peek();
+    var predicate = typeof valueOrPredicate === "function" && !isObservable(valueOrPredicate) ? valueOrPredicate : function(value2) {
+      return value2 === valueOrPredicate;
+    };
+    this.valueWillMutate();
+    for (var i = underlyingArray.length - 1; i >= 0; i--) {
+      var value = underlyingArray[i];
+      if (predicate(value)) {
+        value["_destroy"] = true;
+      }
+    }
+    this.valueHasMutated();
+  },
+  destroyAll(arrayOfValues) {
+    if (arrayOfValues === void 0) {
+      return this.destroy(function() {
+        return true;
+      });
+    }
+    if (!arrayOfValues) {
+      return [];
+    }
+    return this.destroy(function(value) {
+      return arrayIndexOf(arrayOfValues, value) >= 0;
+    });
+  },
+  indexOf(item) {
+    return arrayIndexOf(this(), item);
+  },
+  replace(oldItem, newItem) {
+    var index = this.indexOf(oldItem);
+    if (index >= 0) {
+      this.valueWillMutate();
+      this.peek()[index] = newItem;
+      this.valueHasMutated();
+    }
+  },
+  sorted(compareFn) {
+    return [...this()].sort(compareFn);
+  },
+  reversed() {
+    return [...this()].reverse();
+  },
+  [Symbol.iterator]: function* () {
+    yield* 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();
+    this.valueWillMutate();
+    this.cacheDiffForKnownOperation(underlyingArray, methodName, arguments);
+    var methodCallResult = underlyingArray[methodName].apply(underlyingArray, arguments);
+    this.valueHasMutated();
+    return methodCallResult === underlyingArray ? this : methodCallResult;
+  };
+});
+arrayForEach(["slice"], function(methodName) {
+  observableArray.fn[methodName] = function() {
+    var underlyingArray = this();
+    return underlyingArray[methodName].apply(underlyingArray, arguments);
+  };
+});
+observableArray.trackArrayChanges = trackArrayChanges;
+
+// ../observable/dist/mappingHelpers.js
+var maxNestedObservableDepth = 10;
+function toJS(rootObject) {
+  if (arguments.length == 0) {
+    throw new Error("When calling ko.toJS, pass the object you want to convert.");
+  }
+  return mapJsObjectGraph(rootObject, function(valueToMap) {
+    for (var i = 0; isObservable(valueToMap) && i < maxNestedObservableDepth; i++) {
+      valueToMap = valueToMap();
+    }
+    return valueToMap;
+  });
+}
+function toJSON(rootObject, replacer, space) {
+  var plainJavaScriptObject = toJS(rootObject);
+  return JSON.stringify(plainJavaScriptObject, replacer, space);
+}
+function mapJsObjectGraph(rootObject, mapInputCallback, visitedObjects = /* @__PURE__ */ new Map()) {
+  rootObject = mapInputCallback(rootObject);
+  var canHaveProperties = typeof rootObject === "object" && rootObject !== null && rootObject !== void 0 && !(rootObject instanceof RegExp) && !(rootObject instanceof Date) && !(rootObject instanceof String) && !(rootObject instanceof Number) && !(rootObject instanceof Boolean);
+  if (!canHaveProperties) {
+    return rootObject;
+  }
+  var outputProperties = rootObject instanceof Array ? [] : {};
+  visitedObjects.set(rootObject, outputProperties);
+  visitPropertiesOrArrayEntries(rootObject, function(indexer) {
+    var propertyValue = mapInputCallback(rootObject[indexer]);
+    switch (typeof propertyValue) {
+      case "boolean":
+      case "number":
+      case "string":
+      case "function":
+        outputProperties[indexer] = propertyValue;
+        break;
+      case "object":
+      case "undefined":
+        var previouslyMappedValue = visitedObjects.get(propertyValue);
+        outputProperties[indexer] = previouslyMappedValue !== void 0 ? previouslyMappedValue : mapJsObjectGraph(propertyValue, mapInputCallback, visitedObjects);
+        break;
+    }
+  });
+  return outputProperties;
+}
+function visitPropertiesOrArrayEntries(rootObject, visitorCallback) {
+  if (rootObject instanceof Array) {
+    for (var i = 0; i < rootObject.length; i++) {
+      visitorCallback(i);
+    }
+    if (typeof rootObject["toJSON"] === "function") {
+      visitorCallback("toJSON");
+    }
+  } else {
+    for (var propertyName in rootObject) {
+      visitorCallback(propertyName);
+    }
+  }
+}
+
+// ../utils.parser/dist/operators.js
+function LAMBDA() {
+}
+function unwrapOrCall(a, b) {
+  while (typeof b === "function") {
+    b = b();
+  }
+  return b;
+}
+var operators = {
+  "@": unwrapOrCall,
+  "#": (a, b) => () => unwrap(b),
+  "=>": LAMBDA,
+  "!": function not(a, b) {
+    return !b;
+  },
+  "!!": function notnot(a, b) {
+    return !!b;
+  },
+  "++": function preinc(a, b) {
+    return ++b;
+  },
+  "--": function preinc2(a, b) {
+    return --b;
+  },
+  "*": function mul(a, b) {
+    return a * b;
+  },
+  "/": function div(a, b) {
+    return a / b;
+  },
+  "%": function mod(a, b) {
+    return a % b;
+  },
+  "+": function add(a, b) {
+    return a + b;
+  },
+  "-": function sub(a, b) {
+    return (a || 0) - (b || 0);
+  },
+  "&-": function neg(a, b) {
+    return -1 * b;
+  },
+  "<": function lt(a, b) {
+    return a < b;
+  },
+  "<=": function le(a, b) {
+    return a <= b;
+  },
+  ">": function gt(a, b) {
+    return a > b;
+  },
+  ">=": function ge(a, b) {
+    return a >= b;
+  },
+  "==": function equal(a, b) {
+    return a === b;
+  },
+  "!=": function ne(a, b) {
+    return a !== b;
+  },
+  "===": function sequal(a, b) {
+    return a === b;
+  },
+  "!==": function sne(a, b) {
+    return a !== b;
+  },
+  "&": function bitAnd(a, b) {
+    return a & b;
+  },
+  "^": function xor(a, b) {
+    return a ^ b;
+  },
+  "|": function bitOr(a, b) {
+    return a | b;
+  },
+  "&&": function logicAnd(a, b) {
+    return a && b;
+  },
+  "||": function logicOr(a, b) {
+    return a || b;
+  },
+  ".": function member(a, b) {
+    return a[b];
+  },
+  "[": function member2(a, b) {
+    return a[b];
+  },
+  ",": function comma(a, b) {
+    return b;
+  },
+  "call": function callOp(a, b) {
+    return a.apply(null, b);
+  }
+};
+operators["@"].precedence = 21;
+operators["#"].precedence = 21;
+operators["."].precedence = 19;
+operators["["].precedence = 19;
+operators["!"].precedence = 16;
+operators["!!"].precedence = 16;
+operators["++"].precedence = 16;
+operators["--"].precedence = 16;
+operators["&-"].precedence = 16;
+operators["%"].precedence = 14;
+operators["*"].precedence = 14;
+operators["/"].precedence = 14;
+operators["+"].precedence = 13;
+operators["-"].precedence = 13;
+operators["|"].precedence = 12;
+operators["^"].precedence = 11;
+operators["&"].precedence = 10;
+operators["<"].precedence = 11;
+operators["<="].precedence = 11;
+operators[">"].precedence = 11;
+operators[">="].precedence = 11;
+operators["=="].precedence = 10;
+operators["!="].precedence = 10;
+operators["==="].precedence = 10;
+operators["!=="].precedence = 10;
+operators["&&"].precedence = 6;
+operators["||"].precedence = 5;
+operators["&&"].earlyOut = (a) => !a;
+operators["||"].earlyOut = (a) => a;
+operators[","].precedence = 2;
+operators["call"].precedence = 1;
+operators["=>"].precedence = 1;
+
+// ../utils.parser/dist/Node.js
+var IS_EXPR_OR_IDENT = Symbol("Node - Is Expression Or Identifier");
+var Node = class {
+  constructor(lhs, op, rhs) {
+    this.lhs = lhs;
+    this.op = op;
+    this.rhs = rhs;
+  }
+  static get operators() {
+    return operators;
+  }
+  get_leaf_value(leaf, context, globals, node) {
+    if (typeof leaf === "function") {
+      return unwrap(leaf());
+    }
+    if (typeof leaf !== "object" || leaf === null) {
+      return leaf;
+    }
+    if (leaf[Node.isExpressionOrIdentifierSymbol]) {
+      return unwrap(leaf.get_value(void 0, context, globals, node));
+    }
+    return leaf;
+  }
+  get_value(notused, context, globals, node) {
+    var node = this;
+    if (node.op === LAMBDA) {
+      return (...args) => {
+        let lambdaContext = context;
+        if (node.lhs) {
+          lambdaContext = node.lhs.extendContext(context, args);
+        }
+        return node.get_leaf_value(node.rhs, lambdaContext, globals, node);
+      };
+    }
+    const lhv = node.get_leaf_value(node.lhs, context, globals, node);
+    const earlyOut = node.op.earlyOut;
+    if (earlyOut && earlyOut(lhv)) {
+      return lhv;
+    }
+    const rhv = node.get_leaf_value(node.rhs, context, globals, node);
+    return node.op(lhv, rhv, context, globals);
+  }
+  static get isExpressionOrIdentifierSymbol() {
+    return IS_EXPR_OR_IDENT;
+  }
+  get [IS_EXPR_OR_IDENT]() {
+    return true;
+  }
+  static value_of(item, context, globals, node) {
+    if (item && item[Node.isExpressionOrIdentifierSymbol]) {
+      return item.get_value(item, context, globals, node);
+    }
+    return item;
+  }
+  static create_root(nodes, debug = false) {
+    const out = [];
+    const ops = [];
+    for (let i = 0; i < nodes.length; i += 2) {
+      out.push(nodes[i]);
+      const op = nodes[i + 1];
+      const prec = (op == null ? void 0 : op.precedence) || 0;
+      while (ops.length && prec <= ops[ops.length - 1].precedence) {
+        const rhs = out.pop();
+        const lhs = out.pop();
+        out.push(new Node(lhs, ops.pop(), rhs));
+      }
+      ops.push(op);
+    }
+    if (out.length !== 1) {
+      throw new Error(`unexpected nodes remain in shunting yard output stack: ${out}`);
+    }
+    return out[0];
+  }
+};
+operators["?"] = function ternary(a, b, context, globals, node) {
+  return Node.value_of(a ? b.yes : b.no, context, globals, node);
+};
+operators["?"].precedence = 4;
+
+// ../utils.parser/dist/Expression.js
+var Expression = class {
+  constructor(nodes) {
+    this.nodes = nodes;
+    this.root = Node.create_root(nodes);
+  }
+  get_value(parent, context, globals, node) {
+    if (!this.root) {
+      this.root = Node.create_root(this.nodes);
+    }
+    return this.root.get_value(parent, context, globals, node);
+  }
+};
+Expression.prototype[Node.isExpressionOrIdentifierSymbol] = true;
+
+// ../utils.parser/dist/Arguments.js
+var Arguments = class {
+  constructor(parser, args) {
+    this.parser = parser;
+    this.args = args;
+  }
+  get_value(parent, context, globals, node) {
+    var deReffedArgs = [];
+    for (var i = 0, j = this.args.length; i < j; ++i) {
+      deReffedArgs.push(Node.value_of(this.args[i], context, globals, node));
+    }
+    return deReffedArgs;
+  }
+  get [Node.isExpressionOrIdentifierSymbol]() {
+    return true;
+  }
+};
+
+// ../utils.parser/dist/identifierExpressions.js
+var IDStart = /[\$A-Z_a-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/;
+var IDContinue = /[\$0-9A-Z_a-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B4\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/;
+
+// ../utils.parser/dist/Identifier.js
+var Identifier = class {
+  constructor(parser, token, dereferences) {
+    this.token = token;
+    this.dereferences = dereferences;
+    this.parser = parser;
+  }
+  dereference(value, $context, globals, node) {
+    let member3;
+    let refs = this.dereferences || [];
+    const $data = $context.$data || {};
+    let lastValue;
+    let i, n;
+    for (i = 0, n = refs.length; i < n; ++i) {
+      member3 = Node.value_of(refs[i], $context, globals, node);
+      if (typeof value === "function" && refs[i] instanceof Arguments) {
+        value = value.apply(lastValue || $data, member3);
+        lastValue = value;
+      } else if (value === null || value === void 0) {
+        throw new Error(`dereference of null value in ${JSON.stringify(this, null, 2)} context: ${JSON.stringify($context, null, 2)}`);
+      } else {
+        lastValue = value;
+        value = Node.value_of(value[member3], $context, globals, node);
+      }
+    }
+    if (typeof value === "function" && n > 0 && lastValue !== value && !hasOwnProperty(lastValue, member3)) {
+      return value.bind(lastValue);
+    }
+    return value;
+  }
+  get_value(parent, context, globals, node) {
+    const intermediate = parent && !(parent instanceof Identifier) ? Node.value_of(parent, context, globals, node)[this.token] : context.lookup(this.token, globals, node);
+    return this.dereference(intermediate, context, globals, node);
+  }
+  assign(object2, property, value) {
+    if (isWriteableObservable(object2[property])) {
+      object2[property](value);
+    } else if (!isObservable(object2[property])) {
+      object2[property] = value;
+    }
+  }
+  set_value(new_value, $context, globals) {
+    const $data = $context.$data || {};
+    const refs = this.dereferences || [];
+    let leaf = this.token;
+    let i, n, root;
+    if (isObjectLike($data) && leaf in $data) {
+      root = $data;
+    } else if (leaf in $context) {
+      root = $context;
+    } else if (leaf in globals) {
+      root = globals;
+    } else {
+      throw new Error("Identifier::set_value -- The property '" + leaf + "' does not exist on the $data, $context, or globals.");
+    }
+    n = refs.length;
+    if (n === 0) {
+      this.assign(root, leaf, new_value);
+      return;
+    }
+    root = root[leaf];
+    for (i = 0; i < n - 1; ++i) {
+      leaf = refs[i];
+      if (leaf instanceof Arguments) {
+        root = root();
+      } else {
+        root = root[Node.value_of(leaf)];
+      }
+    }
+    if (refs[i] === true) {
+      throw new Error("Cannot assign a value to a function.");
+    }
+    if (refs[i]) {
+      this.assign(root, Node.value_of(refs[i]), new_value);
+    }
+  }
+  static is_valid_start_char(ch) {
+    return IDStart.test(ch);
+  }
+  static is_valid_continue_char(ch) {
+    return IDContinue.test(ch);
+  }
+  get [Node.isExpressionOrIdentifierSymbol]() {
+    return true;
+  }
+};
+
+// ../utils.parser/dist/Parameters.js
+var Parameters = class {
+  constructor(parser, node) {
+    if (node instanceof Expression) {
+      node = node.root;
+    }
+    try {
+      this.names = Parameters.nodeTreeToNames(node);
+    } catch (e) {
+      parser.error(e);
+    }
+  }
+  extendContext(context, args) {
+    if (!this.names) {
+      return context;
+    } else {
+      const newValues = {};
+      this.names.forEach((name, index) => {
+        newValues[name] = args[index];
+      });
+      return context.extend(newValues);
+    }
+  }
+  get [Node.isExpressionOrIdentifierSymbol]() {
+    return true;
+  }
+  static nodeTreeToNames(node) {
+    const names = [];
+    while (node) {
+      if (node instanceof Identifier) {
+        names.push(node.token);
+        node = null;
+      } else if (this.isCommaNode(node)) {
+        names.push(node.rhs.token);
+        node = node.lhs;
+      } else {
+        throw new Error(`only simple identifiers allowed in lambda parameter list but found ${JSON.stringify(node, null, 2)}`);
+      }
+    }
+    names.reverse();
+    return names;
+  }
+  static isCommaNode(node) {
+    return node instanceof Node && node.op === operators[","] && node.rhs instanceof Identifier;
+  }
+};
+
+// ../utils.parser/dist/Ternary.js
+var Ternary = class {
+  constructor(yes, no) {
+    Object.assign(this, { yes, no });
+  }
+  get_value() {
+    return this;
+  }
+  get [Node.isExpressionOrIdentifierSymbol]() {
+    return true;
+  }
+};
+
+// ../utils.parser/dist/preparse.js
+var specials = ",\"'`{}()/:[\\]";
+var bindingToken = RegExp([
+  '"(?:\\\\.|[^"])*"',
+  "'(?:\\\\.|[^'])*'",
+  "`(?:\\\\.|[^`])*`",
+  "/\\*(?:[^*]|\\*+[^*/])*\\*+/",
+  "//.*\n",
+  "/(?:\\\\.|[^/])+/\\w*",
+  "[^\\s:,/][^" + specials + "]*[^\\s" + specials + "]",
+  "[^\\s]"
+].join("|"), "g");
+var divisionLookBehind = /[\])"'A-Za-z0-9_$]+$/;
+var keywordRegexLookBehind = { "in": 1, "return": 1, "typeof": 1 };
+function parseObjectLiteral(objectLiteralString) {
+  var str = stringTrim(objectLiteralString);
+  if (str.charCodeAt(0) === 123)
+    str = str.slice(1, -1);
+  str += "\n,";
+  var result = [];
+  var toks = str.match(bindingToken);
+  var key;
+  var values = [];
+  var depth = 0;
+  if (toks.length <= 1) {
+    return [];
+  }
+  for (var i = 0, tok; tok = toks[i]; ++i) {
+    var c = tok.charCodeAt(0);
+    if (c === 44) {
+      if (depth <= 0) {
+        result.push(key && values.length ? {
+          key,
+          value: values.join("")
+        } : {
+          "unknown": key || values.join("")
+        });
+        key = depth = 0;
+        values = [];
+        continue;
+      }
+    } else if (c === 58) {
+      if (!depth && !key && values.length === 1) {
+        key = values.pop();
+        continue;
+      }
+    } else if (c === 47 && tok.length > 1 && (tok.charCodeAt(1) === 47 || tok.charCodeAt(1) === 42)) {
+      continue;
+    } else if (c === 47 && i && tok.length > 1) {
+      var match = toks[i - 1].match(divisionLookBehind);
+      if (match && !keywordRegexLookBehind[match[0]]) {
+        str = str.substr(str.indexOf(tok) + 1);
+        toks = str.match(bindingToken);
+        i = -1;
+        tok = "/";
+      }
+    } else if (c === 40 || c === 123 || c === 91) {
+      ++depth;
+    } else if (c === 41 || c === 125 || c === 93) {
+      --depth;
+    } else if (!key && !values.length && (c === 34 || c === 39)) {
+      tok = tok.slice(1, -1);
+    }
+    values.push(tok);
+  }
+  return result;
+}
+
+// ../computed/dist/computed.js
+var computedState = createSymbolOrString("_state");
+var DISPOSED_STATE = {
+  dependencyTracking: null,
+  dependenciesCount: 0,
+  isDisposed: true,
+  isStale: false,
+  isDirty: false,
+  isSleeping: false,
+  disposeWhenNodeIsRemoved: null,
+  readFunction: null,
+  _options: null
+};
+function computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget, options2) {
+  if (typeof evaluatorFunctionOrOptions === "object") {
+    options2 = evaluatorFunctionOrOptions;
+  } else {
+    options2 = options2 || {};
+    if (evaluatorFunctionOrOptions) {
+      options2.read = evaluatorFunctionOrOptions;
+    }
+  }
+  if (typeof options2.read !== "function") {
+    throw Error("Pass a function that returns the value of the computed");
+  }
+  var writeFunction = options2.write;
+  var state = {
+    latestValue: void 0,
+    isStale: true,
+    isDirty: true,
+    isBeingEvaluated: false,
+    suppressDisposalUntilDisposeWhenReturnsFalse: false,
+    isDisposed: false,
+    pure: false,
+    isSleeping: false,
+    readFunction: options2.read,
+    evaluatorFunctionTarget: evaluatorFunctionTarget || options2.owner,
+    disposeWhenNodeIsRemoved: options2.disposeWhenNodeIsRemoved || options2.disposeWhenNodeIsRemoved || null,
+    disposeWhen: options2.disposeWhen || options2.disposeWhen,
+    domNodeDisposalCallback: null,
+    dependencyTracking: {},
+    dependenciesCount: 0,
+    evaluationTimeoutInstance: null
+  };
+  function computedObservable() {
+    if (arguments.length > 0) {
+      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.");
+      }
+      return this;
+    } else {
+      if (!state.isDisposed) {
+        dependencyDetection_exports.registerDependency(computedObservable);
+      }
+      if (state.isDirty || state.isSleeping && computedObservable.haveDependenciesChanged()) {
+        computedObservable.evaluateImmediate();
+      }
+      return state.latestValue;
+    }
+  }
+  computedObservable[computedState] = state;
+  computedObservable.isWriteable = typeof writeFunction === "function";
+  subscribable.fn.init(computedObservable);
+  Object.setPrototypeOf(computedObservable, computed.fn);
+  if (options2.pure) {
+    state.pure = true;
+    state.isSleeping = true;
+    extend(computedObservable, pureComputedOverrides);
+  } else if (options2.deferEvaluation) {
+    extend(computedObservable, deferEvaluationOverrides);
+  }
+  if (options_default.deferUpdates) {
+    extenders.deferred(computedObservable, true);
+  }
+  if (options_default.debug) {
+    computedObservable._options = options2;
+  }
+  if (state.disposeWhenNodeIsRemoved) {
+    state.suppressDisposalUntilDisposeWhenReturnsFalse = true;
+    if (!state.disposeWhenNodeIsRemoved.nodeType) {
+      state.disposeWhenNodeIsRemoved = null;
+    }
+  }
+  if (!state.isSleeping && !options2.deferEvaluation) {
+    computedObservable.evaluateImmediate();
+  }
+  if (state.disposeWhenNodeIsRemoved && computedObservable.isActive()) {
+    addDisposeCallback(state.disposeWhenNodeIsRemoved, state.domNodeDisposalCallback = function() {
+      computedObservable.dispose();
+    });
+  }
+  return computedObservable;
+}
+function computedDisposeDependencyCallback(id, entryToDispose) {
+  if (entryToDispose !== null && entryToDispose.dispose) {
+    entryToDispose.dispose();
+  }
+}
+function computedBeginDependencyDetectionCallback(subscribable2, id) {
+  var 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));
+    }
+    if (subscribable2._notificationIsPending) {
+      subscribable2._notifyNextChangeIfValueIsDifferent();
+    }
+  }
+}
+computed.fn = {
+  equalityComparer: valuesArePrimitiveAndEqual,
+  getDependenciesCount() {
+    return this[computedState].dependenciesCount;
+  },
+  getDependencies() {
+    const dependencyTracking = this[computedState].dependencyTracking;
+    const dependentObservables = [];
+    objectForEach(dependencyTracking, function(id, dependency) {
+      dependentObservables[dependency._order] = dependency._target;
+    });
+    return dependentObservables;
+  },
+  addDependencyTracking(id, target, trackingObj) {
+    if (this[computedState].pure && target === this) {
+      throw Error("A 'pure' computed must not be called recursively");
+    }
+    this[computedState].dependencyTracking[id] = trackingObj;
+    trackingObj._order = this[computedState].dependenciesCount++;
+    trackingObj._version = target.getVersion();
+  },
+  haveDependenciesChanged() {
+    var id, dependency, dependencyTracking = this[computedState].dependencyTracking;
+    for (id in dependencyTracking) {
+      if (hasOwnProperty(dependencyTracking, id)) {
+        dependency = dependencyTracking[id];
+        if (this._evalDelayed && dependency._target._notificationIsPending || dependency._target.hasChanged(dependency._version)) {
+          return true;
+        }
+      }
+    }
+  },
+  markDirty() {
+    if (this._evalDelayed && !this[computedState].isBeingEvaluated) {
+      this._evalDelayed(false);
+    }
+  },
+  isActive() {
+    const state = this[computedState];
+    return state.isDirty || state.dependenciesCount > 0;
+  },
+  respondToChange() {
+    if (!this._notificationIsPending) {
+      this.evaluatePossiblyAsync();
+    } else if (this[computedState].isDirty) {
+      this[computedState].isStale = true;
+    }
+  },
+  subscribeToDependency(target) {
+    if (target._deferUpdates) {
+      var dirtySub = target.subscribe(this.markDirty, this, "dirty"), changeSub = target.subscribe(this.respondToChange, this);
+      return {
+        _target: target,
+        dispose() {
+          dirtySub.dispose();
+          changeSub.dispose();
+        }
+      };
+    } else {
+      return target.subscribe(this.evaluatePossiblyAsync, this);
+    }
+  },
+  evaluatePossiblyAsync() {
+    var computedObservable = this, throttleEvaluationTimeout = computedObservable.throttleEvaluation;
+    if (throttleEvaluationTimeout && throttleEvaluationTimeout >= 0) {
+      clearTimeout(this[computedState].evaluationTimeoutInstance);
+      this[computedState].evaluationTimeoutInstance = safeSetTimeout(function() {
+        computedObservable.evaluateImmediate(true);
+      }, throttleEvaluationTimeout);
+    } else if (computedObservable._evalDelayed) {
+      computedObservable._evalDelayed(true);
+    } else {
+      computedObservable.evaluateImmediate(true);
+    }
+  },
+  evaluateImmediate(notifyChange) {
+    var computedObservable = this, state = computedObservable[computedState], disposeWhen = state.disposeWhen, changed = false;
+    if (state.isBeingEvaluated) {
+      return;
+    }
+    if (state.isDisposed) {
+      return;
+    }
+    if (state.disposeWhenNodeIsRemoved && !domNodeIsAttachedToDocument(state.disposeWhenNodeIsRemoved) || disposeWhen && disposeWhen()) {
+      if (!state.suppressDisposalUntilDisposeWhenReturnsFalse) {
+        computedObservable.dispose();
+        return;
+      }
+    } else {
+      state.suppressDisposalUntilDisposeWhenReturnsFalse = false;
+    }
+    state.isBeingEvaluated = true;
+    try {
+      changed = this.evaluateImmediate_CallReadWithDependencyDetection(notifyChange);
+    } finally {
+      state.isBeingEvaluated = false;
+    }
+    return changed;
+  },
+  evaluateImmediate_CallReadWithDependencyDetection(notifyChange) {
+    var computedObservable = this, state = computedObservable[computedState], changed = false;
+    var isInitial2 = state.pure ? void 0 : !state.dependenciesCount, dependencyDetectionContext = {
+      computedObservable,
+      disposalCandidates: state.dependencyTracking,
+      disposalCount: state.dependenciesCount
+    };
+    dependencyDetection_exports.begin({
+      callbackTarget: dependencyDetectionContext,
+      callback: computedBeginDependencyDetectionCallback,
+      computed: computedObservable,
+      isInitial: isInitial2
+    });
+    state.dependencyTracking = {};
+    state.dependenciesCount = 0;
+    var newValue = this.evaluateImmediate_CallReadThenEndDependencyDetection(state, dependencyDetectionContext);
+    if (!state.dependenciesCount) {
+      computedObservable.dispose();
+      changed = true;
+    } else {
+      changed = computedObservable.isDifferent(state.latestValue, newValue);
+    }
+    if (changed) {
+      if (!state.isSleeping) {
+        computedObservable.notifySubscribers(state.latestValue, "beforeChange");
+      } else {
+        computedObservable.updateVersion();
+      }
+      state.latestValue = newValue;
+      if (options_default.debug) {
+        computedObservable._latestValue = newValue;
+      }
+      computedObservable.notifySubscribers(state.latestValue, "spectate");
+      if (!state.isSleeping && notifyChange) {
+        computedObservable.notifySubscribers(state.latestValue);
+      }
+      if (computedObservable._recordUpdate) {
+        computedObservable._recordUpdate();
+      }
+    }
+    if (isInitial2) {
+      computedObservable.notifySubscribers(state.latestValue, "awake");
+    }
+    return changed;
+  },
+  evaluateImmediate_CallReadThenEndDependencyDetection(state, dependencyDetectionContext) {
+    try {
+      var readFunction = state.readFunction;
+      return state.evaluatorFunctionTarget ? readFunction.call(state.evaluatorFunctionTarget) : readFunction();
+    } finally {
+      dependencyDetection_exports.end();
+      if (dependencyDetectionContext.disposalCount && !state.isSleeping) {
+        objectForEach(dependencyDetectionContext.disposalCandidates, computedDisposeDependencyCallback);
+      }
+      state.isStale = state.isDirty = false;
+    }
+  },
+  peek(forceEvaluate) {
+    const state = this[computedState];
+    if (state.isDirty && (forceEvaluate || !state.dependenciesCount) || state.isSleeping && this.haveDependenciesChanged()) {
+      this.evaluateImmediate();
+    }
+    return state.latestValue;
+  },
+  get [LATEST_VALUE]() {
+    return this.peek();
+  },
+  limit(limitFunction) {
+    const state = this[computedState];
+    subscribable.fn.limit.call(this, limitFunction);
+    Object.assign(this, {
+      _evalIfChanged() {
+        if (!this[computedState].isSleeping) {
+          if (this[computedState].isStale) {
+            this.evaluateImmediate();
+          } else {
+            this[computedState].isDirty = false;
+          }
+        }
+        return state.latestValue;
+      },
+      _evalDelayed(isChange) {
+        this._limitBeforeChange(state.latestValue);
+        state.isDirty = true;
+        if (isChange) {
+          state.isStale = true;
+        }
+        this._limitChange(this, !isChange);
+      }
+    });
+  },
+  dispose() {
+    var state = this[computedState];
+    if (!state.isSleeping && state.dependencyTracking) {
+      objectForEach(state.dependencyTracking, function(id, dependency) {
+        if (dependency.dispose) {
+          dependency.dispose();
+        }
+      });
+    }
+    if (state.disposeWhenNodeIsRemoved && state.domNodeDisposalCallback) {
+      removeDisposeCallback(state.disposeWhenNodeIsRemoved, state.domNodeDisposalCallback);
+    }
+    Object.assign(state, DISPOSED_STATE);
+  }
+};
+var pureComputedOverrides = {
+  beforeSubscriptionAdd(event) {
+    var computedObservable = this, state = computedObservable[computedState];
+    if (!state.isDisposed && state.isSleeping && event === "change") {
+      state.isSleeping = false;
+      if (state.isStale || computedObservable.haveDependenciesChanged()) {
+        state.dependencyTracking = null;
+        state.dependenciesCount = 0;
+        if (computedObservable.evaluateImmediate()) {
+          computedObservable.updateVersion();
+        }
+      } else {
+        var dependenciesOrder = [];
+        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);
+          subscription._order = order;
+          subscription._version = dependency._version;
+          state.dependencyTracking[id] = subscription;
+        });
+        if (computedObservable.haveDependenciesChanged()) {
+          if (computedObservable.evaluateImmediate()) {
+            computedObservable.updateVersion();
+          }
+        }
+      }
+      if (!state.isDisposed) {
+        computedObservable.notifySubscribers(state.latestValue, "awake");
+      }
+    }
+  },
+  afterSubscriptionRemove(event) {
+    var state = this[computedState];
+    if (!state.isDisposed && event === "change" && !this.hasSubscriptionsForEvent("change")) {
+      objectForEach(state.dependencyTracking, function(id, dependency) {
+        if (dependency.dispose) {
+          state.dependencyTracking[id] = {
+            _target: dependency._target,
+            _order: dependency._order,
+            _version: dependency._version
+          };
+          dependency.dispose();
+        }
+      });
+      state.isSleeping = true;
+      this.notifySubscribers(void 0, "asleep");
+    }
+  },
+  getVersion() {
+    var state = this[computedState];
+    if (state.isSleeping && (state.isStale || this.haveDependenciesChanged())) {
+      this.evaluateImmediate();
+    }
+    return subscribable.fn.getVersion.call(this);
+  }
+};
+var deferEvaluationOverrides = {
+  beforeSubscriptionAdd(event) {
+    if (event === "change" || event === "beforeChange") {
+      this.peek();
+    }
+  }
+};
+Object.setPrototypeOf(computed.fn, subscribable.fn);
+var protoProp = observable.protoProperty;
+computed.fn[protoProp] = computed;
+observable.observablePrototypes.add(computed);
+function isComputed(instance) {
+  return typeof instance === "function" && instance[protoProp] === computed;
+}
+function isPureComputed(instance) {
+  return isComputed(instance) && instance[computedState] && instance[computedState].pure;
+}
+function pureComputed(evaluatorFunctionOrOptions, evaluatorFunctionTarget) {
+  if (typeof evaluatorFunctionOrOptions === "function") {
+    return computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget, { "pure": true });
+  } else {
+    evaluatorFunctionOrOptions = extend({}, evaluatorFunctionOrOptions);
+    evaluatorFunctionOrOptions.pure = true;
+    return computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget);
+  }
+}
+
+// ../computed/dist/throttleExtender.js
+function throttleExtender(target, timeout) {
+  target.throttleEvaluation = timeout;
+  var writeTimeoutInstance = null;
+  return computed({
+    read: target,
+    write: function(value) {
+      clearTimeout(writeTimeoutInstance);
+      writeTimeoutInstance = setTimeout(function() {
+        target(value);
+      }, timeout);
+    }
+  });
+}
+extenders.throttle = throttleExtender;
+
+// ../computed/dist/proxy.js
+var PROXY_SYM = Symbol("Knockout Proxied Object");
+var MIRROR_SYM = Symbol("Knockout Proxied Observables");
+function makeComputed(proxy2, fn) {
+  return computed({
+    owner: proxy2,
+    read: fn,
+    write: fn,
+    pure: "pure" in fn ? fn.pure : true,
+    deferEvaluation: "deferEvaluation" in fn ? fn.deferEvaluation : true
+  }).extend({ deferred: true });
+}
+function setOrCreate(mirror, prop, value, proxy2) {
+  if (!mirror[prop]) {
+    const ctr = Array.isArray(value) ? observableArray : typeof value === "function" ? makeComputed.bind(null, proxy2) : observable;
+    mirror[prop] = ctr(value);
+  } else {
+    mirror[prop](value);
+  }
+}
+function assignOrUpdate(mirror, object2, proxy2) {
+  for (const key of Object.keys(object2)) {
+    setOrCreate(mirror, key, object2[key], proxy2);
+  }
+  return object2;
+}
+function proxy(object2) {
+  const mirror = { [PROXY_SYM]: object2 };
+  mirror[MIRROR_SYM] = mirror;
+  const proxy2 = new Proxy(function() {
+  }, {
+    has(target, prop) {
+      return prop in mirror;
+    },
+    get(target, prop) {
+      return unwrap(mirror[prop]);
+    },
+    set(target, prop, value, receiver) {
+      setOrCreate(mirror, prop, value, proxy2);
+      object2[prop] = value;
+      return true;
+    },
+    deleteProperty(property) {
+      delete mirror[property];
+      return delete object2[property];
+    },
+    apply(target, thisArg, [props]) {
+      if (props) {
+        assignOrUpdate(mirror, props, proxy2);
+        return Object.assign(object2, props);
+      }
+      return object2;
+    },
+    getPrototypeOf() {
+      return Object.getPrototypeOf(object2);
+    },
+    setPrototypeOf(target, proto) {
+      return Object.setPrototypeOf(object2, proto);
+    },
+    defineProperty(target, prop, desc) {
+      return Object.defineProperty(object2, prop, desc);
+    },
+    preventExtensions() {
+      return Object.preventExtensions(object2);
+    },
+    isExtensible() {
+      return Object.isExtensible(object2);
+    },
+    ownKeys() {
+      return [
+        ...Object.getOwnPropertyNames(object2),
+        ...Object.getOwnPropertySymbols(object2)
+      ];
+    }
+  });
+  assignOrUpdate(mirror, object2, proxy2);
+  return proxy2;
+}
+function getObservable(proxied, prop) {
+  return proxied[MIRROR_SYM][prop];
+}
+function peek2(proxied, prop) {
+  return getObservable(proxied, prop).peek();
+}
+function isProxied(proxied) {
+  return PROXY_SYM in proxied;
+}
+Object.assign(proxy, { getObservable, peek: peek2, isProxied });
+
+// ../computed/dist/when.js
+function kowhen(predicate, context, resolve) {
+  const observable2 = pureComputed(predicate, context).extend({ notify: "always" });
+  const subscription = observable2.subscribe((value) => {
+    if (value) {
+      subscription.dispose();
+      resolve(value);
+    }
+  });
+  observable2.notifySubscribers(observable2.peek());
+  return subscription;
+}
+function when(predicate, callback, context) {
+  const whenFn = kowhen.bind(null, predicate, context);
+  return callback ? whenFn(callback.bind(context)) : new Promise(whenFn);
+}
+
+// ../lifecycle/dist/LifeCycle.js
+var SUBSCRIPTIONS = createSymbolOrString("LifeCycle Subscriptions List");
+var ANCHOR_NODE = createSymbolOrString("LifeCycle Anchor Node");
+var LifeCycle = class {
+  static mixInto(Constructor) {
+    const target = Constructor.prototype || Constructor;
+    const mixin = LifeCycle.prototype;
+    for (let prop of Object.getOwnPropertyNames(mixin)) {
+      target[prop] = mixin[prop];
+    }
+  }
+  subscribe(observable2, action, subscriptionType) {
+    if (typeof action === "string") {
+      action = this[action];
+    }
+    this.addDisposable(observable2.subscribe(action, this, subscriptionType));
+  }
+  computed(params) {
+    if (typeof params === "string") {
+      params = { read: this[params], write: this[params] };
+    }
+    if (typeof params === "object") {
+      params = Object.assign({ owner: this }, params);
+    } else if (typeof params === "function") {
+      const proto = Object.getPrototypeOf(this);
+      if (proto && proto[params.name] === params) {
+        params = params.bind(this);
+      }
+      params = { read: params, write: params };
+    } else {
+      throw new Error("LifeCycle::computed not given a valid type.");
+    }
+    params.disposeWhenNodeIsRemoved = this[ANCHOR_NODE];
+    return this.addDisposable(computed(params));
+  }
+  addEventListener(...args) {
+    const node = args[0].nodeType ? args.shift() : this[ANCHOR_NODE];
+    const [type, act, options2] = args;
+    const handler = typeof act === "string" ? this[act].bind(this) : act;
+    this.__addEventListener(node, type, handler, options2);
+  }
+  __addEventListener(node, eventType, handler, options2) {
+    node.addEventListener(eventType, handler, options2);
+    function dispose() {
+      node.removeEventListener(eventType, handler);
+    }
+    addDisposeCallback(node, dispose);
+    this.addDisposable({ dispose });
+  }
+  anchorTo(nodeOrLifeCycle) {
+    if ("addDisposable" in nodeOrLifeCycle) {
+      nodeOrLifeCycle.addDisposable(this);
+      this[ANCHOR_NODE] = null;
+    } else {
+      this[ANCHOR_NODE] = nodeOrLifeCycle;
+      addDisposeCallback(nodeOrLifeCycle, () => this[ANCHOR_NODE] === nodeOrLifeCycle && this.dispose());
+    }
+  }
+  dispose() {
+    const subscriptions = this[SUBSCRIPTIONS] || [];
+    subscriptions.forEach((s) => s.dispose());
+    this[SUBSCRIPTIONS] = [];
+    this[ANCHOR_NODE] = null;
+  }
+  addDisposable(subscription) {
+    const subscriptions = this[SUBSCRIPTIONS] || [];
+    if (!this[SUBSCRIPTIONS]) {
+      this[SUBSCRIPTIONS] = subscriptions;
+    }
+    if (typeof subscription.dispose !== "function") {
+      throw new Error("Lifecycle::addDisposable argument missing `dispose`.");
+    }
+    subscriptions.push(subscription);
+    return subscription;
+  }
+};
+
+// ../bind/dist/bindingEvent.js
+var contextAncestorBindingInfo = Symbol("_ancestorBindingInfo");
+var boundElementDomDataKey = data_exports.nextKey();
+var bindingEvent = {
+  childrenComplete: "childrenComplete",
+  descendantsComplete: "descendantsComplete",
+  subscribe(node, event, callback, context) {
+    const bindingInfo = data_exports.getOrSet(node, boundElementDomDataKey, {});
+    if (!bindingInfo.eventSubscribable) {
+      bindingInfo.eventSubscribable = new subscribable();
+    }
+    return bindingInfo.eventSubscribable.subscribe(callback, context, event);
+  },
+  notify(node, event) {
+    const bindingInfo = data_exports.get(node, boundElementDomDataKey);
+    if (bindingInfo) {
+      if (bindingInfo.eventSubscribable) {
+        bindingInfo.eventSubscribable.notifySubscribers(node, event);
+      }
+    }
+  }
+};
+
+// ../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) {
+  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;
+    let dataItem = unwrap(dataItemOrObservable);
+    if (parentContext) {
+      if (parentContext[contextSubscribeSymbol]) {
+        parentContext[contextSubscribeSymbol]();
+      }
+      extend(self, parentContext);
+      if (contextAncestorBindingInfo in parentContext) {
+        self[contextAncestorBindingInfo] = parentContext[contextAncestorBindingInfo];
+      }
+    } else {
+      self.$parents = [];
+      self.$root = dataItem;
+    }
+    self[contextSubscribeSymbol] = subscribable2;
+    if (shouldInheritData) {
+      dataItem = self.$data;
+    } else {
+      self.$rawData = dataItemOrObservable;
+      self.$data = dataItem;
+    }
+    if (dataItemAlias) {
+      self[dataItemAlias] = dataItem;
+    }
+    if (extendCallback) {
+      extendCallback(self, parentContext, dataItem);
+    }
+    return self.$data;
+  }
+  if (settings && settings.exportDependencies) {
+    updateContext();
+  } else {
+    subscribable2 = pureComputed(updateContext);
+    subscribable2.peek();
+    if (subscribable2.isActive()) {
+      self[contextSubscribeSymbol] = subscribable2;
+      subscribable2["equalityComparer"] = null;
+    } else {
+      self[contextSubscribeSymbol] = void 0;
+    }
+  }
+}
+Object.assign(bindingContext.prototype, {
+  lookup(token, globals, node) {
+    switch (token) {
+      case "$element":
+        return node;
+      case "$context":
+        return this;
+      case "this":
+      case "$data":
+        return this.$data;
+    }
+    const $data = this.$data;
+    if (isObjectLike($data) && token in $data) {
+      return $data[token];
+    }
+    if (token in this) {
+      return this[token];
+    }
+    if (token in globals) {
+      return globals[token];
+    }
+    throw new Error(`The variable "${token}" was not found on $data, $context, or globals.`);
+  },
+  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);
+  },
+  extend(properties) {
+    return new bindingContext(inheritParentIndicator, this, null, function(self, parentContext) {
+      extend(self, typeof properties === "function" ? properties.call(self) : properties);
+    });
+  },
+  createStaticChildContext(dataItemOrAccessor, dataItemAlias) {
+    return this.createChildContext(dataItemOrAccessor, dataItemAlias, null, { "exportDependencies": true });
+  }
+});
+function storedBindingContextForNode(node) {
+  const bindingInfo = data_exports.get(node, boundElementDomDataKey2);
+  return bindingInfo && bindingInfo.context;
+}
+function contextFor(node) {
+  if (node && (node.nodeType === 1 || node.nodeType === 8)) {
+    return storedBindingContextForNode(node);
+  }
+}
+function dataFor(node) {
+  var 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 = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } 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
+    });
+    if (!this.isSync) {
+      this.completionPromise = this.completeWhenBindingsFinish(asyncBindingsApplied);
+    }
+  }
+  completeWhenBindingsFinish(asyncBindingsApplied) {
+    return __async(this, null, function* () {
+      yield Promise.all(asyncBindingsApplied);
+      this.isComplete = true;
+      return this;
+    });
+  }
+};
+
+// ../bind/dist/BindingHandler.js
+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.anchorTo($element);
+  }
+  get value() {
+    return this.valueAccessor();
+  }
+  set value(v) {
+    const va = this.valueAccessor();
+    if (isWriteableObservable(va)) {
+      va(v);
+    } else {
+      this.valueAccessor(v);
+    }
+  }
+  get controlsDescendants() {
+    return false;
+  }
+  static get allowVirtualElements() {
+    return false;
+  }
+  static get isBindingHandlerClass() {
+    return true;
+  }
+  get bindingCompleted() {
+    return true;
+  }
+  static registerAs(name, provider = options_default.bindingProviderInstance) {
+    provider.bindingHandlers.set(name, this);
+  }
+};
+var ResolveSymbol = Symbol("Async Binding Resolved");
+var AsyncBindingHandler = class extends BindingHandler {
+  constructor(params) {
+    super(params);
+    this.bindingCompletion = new Promise((resolve) => {
+      this[ResolveSymbol] = resolve;
+    });
+    this.completeBinding = (bindingResult) => this[ResolveSymbol](bindingResult);
+  }
+  get bindingCompleted() {
+    return this.bindingCompletion;
+  }
+};
+
+// ../bind/dist/LegacyBindingHandler.js
+var PossibleWeakMap = options_default.global.WeakMap || Map;
+var legacyBindingMap = new PossibleWeakMap();
+var LegacyBindingHandler = class extends BindingHandler {
+  constructor(params) {
+    super(params);
+    const handler = this.handler;
+    this.onError = params.onError;
+    if (typeof handler.dispose === "function") {
+      this.addDisposable(handler);
+    }
+    try {
+      this.initReturn = handler.init && handler.init(...this.legacyArgs);
+    } catch (e) {
+      params.onError("init", e);
+    }
+  }
+  onValueChange() {
+    const handler = this.handler;
+    if (typeof handler.update !== "function") {
+      return;
+    }
+    try {
+      handler.update(...this.legacyArgs);
+    } catch (e) {
+      this.onError("update", e);
+    }
+  }
+  get legacyArgs() {
+    return [
+      this.$element,
+      this.valueAccessor,
+      this.allBindings,
+      this.$data,
+      this.$context
+    ];
+  }
+  get controlsDescendants() {
+    const objectToTest = this.initReturn || this.handler || {};
+    return objectToTest.controlsDescendantBindings;
+  }
+  static getOrCreateFor(key, handler) {
+    if (legacyBindingMap.has(handler)) {
+      return legacyBindingMap.get(handler);
+    }
+    const newLegacyHandler = this.createFor(key, handler);
+    legacyBindingMap.set(handler, newLegacyHandler);
+    return newLegacyHandler;
+  }
+  static createFor(key, handler) {
+    if (typeof handler === "function") {
+      const [initFn, disposeFn] = [handler, handler.dispose];
+      return class extends LegacyBindingHandler {
+        get handler() {
+          const init = initFn.bind(this);
+          const dispose = disposeFn ? disposeFn.bind(this) : null;
+          return { init, dispose };
+        }
+        static get after() {
+          return handler.after;
+        }
+        static get allowVirtualElements() {
+          return handler.allowVirtualElements || virtualElements_exports.allowedBindings[key];
+        }
+      };
+    }
+    if (typeof handler === "object") {
+      return class extends LegacyBindingHandler {
+        get handler() {
+          return handler;
+        }
+        static get after() {
+          return handler.after;
+        }
+        static get allowVirtualElements() {
+          return handler.allowVirtualElements || virtualElements_exports.allowedBindings[key];
+        }
+      };
+    }
+    throw new Error("The given handler is not an appropriate type.");
+  }
+};
+
+// ../bind/dist/applyBindings.js
+var bindingDoesNotRecurseIntoElementTypes = {
+  "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];
+  return nodeTypes.includes(node.nodeType);
+}
+function asProperHandlerClass(handler, bindingKey) {
+  if (!handler) {
+    return;
+  }
+  return handler.isBindingHandlerClass ? handler : LegacyBindingHandler.getOrCreateFor(bindingKey, handler);
+}
+function getBindingHandlerFromComponent(bindingKey, $component) {
+  if (!$component || typeof $component.getBindingHandler !== "function") {
+    return;
+  }
+  return asProperHandlerClass($component.getBindingHandler(bindingKey));
+}
+function getBindingHandler(bindingKey) {
+  const bindingDefinition = options_default.getBindingHandler(bindingKey) || getBindingProvider().bindingHandlers.get(bindingKey);
+  return asProperHandlerClass(bindingDefinition, bindingKey);
+}
+function evaluateValueAccessor(valueAccessor) {
+  return valueAccessor();
+}
+function applyBindingsToDescendantsInternal(bindingContext2, elementOrVirtualElement, asyncBindingsApplied) {
+  let nextInQueue = virtualElements_exports.firstChild(elementOrVirtualElement);
+  if (!nextInQueue) {
+    return;
+  }
+  let currentChild;
+  const provider = getBindingProvider();
+  const preprocessNode = provider.preprocessNode;
+  if (preprocessNode) {
+    while (currentChild = nextInQueue) {
+      nextInQueue = virtualElements_exports.nextSibling(currentChild);
+      preprocessNode.call(provider, currentChild);
+    }
+    nextInQueue = virtualElements_exports.firstChild(elementOrVirtualElement);
+  }
+  while (currentChild = nextInQueue) {
+    nextInQueue = virtualElements_exports.nextSibling(currentChild);
+    applyBindingsToNodeAndDescendantsInternal(bindingContext2, currentChild, asyncBindingsApplied);
+  }
+  bindingEvent.notify(elementOrVirtualElement, bindingEvent.childrenComplete);
+}
+function hasBindings(node) {
+  const provider = getBindingProvider();
+  return isProviderForNode(provider, node) && provider.nodeHasBindings(node);
+}
+function nodeOrChildHasBindings(node) {
+  return hasBindings(node) || [...node.childNodes].some((c) => nodeOrChildHasBindings(c));
+}
+function applyBindingsToNodeAndDescendantsInternal(bindingContext2, nodeVerified, asyncBindingsApplied) {
+  var isElement = nodeVerified.nodeType === 1;
+  if (isElement) {
+    virtualElements_exports.normaliseVirtualElementDomStructure(nodeVerified);
+  }
+  let shouldApplyBindings = isElement || hasBindings(nodeVerified);
+  const { shouldBindDescendants } = shouldApplyBindings ? applyBindingsToNodeInternal(nodeVerified, null, bindingContext2, asyncBindingsApplied) : { shouldBindDescendants: true };
+  if (shouldBindDescendants && !bindingDoesNotRecurseIntoElementTypes[tagNameLower(nodeVerified)]) {
+    applyBindingsToDescendantsInternal(bindingContext2, nodeVerified, asyncBindingsApplied);
+  }
+}
+function* topologicalSortBindings(bindings, $component) {
+  const results = [];
+  const bindingsConsidered = {};
+  const cyclicDependencyStack = [];
+  objectForEach(bindings, function pushBinding(bindingKey) {
+    if (!bindingsConsidered[bindingKey]) {
+      const binding = getBindingHandlerFromComponent(bindingKey, $component) || getBindingHandler(bindingKey);
+      if (!binding) {
+        return;
+      }
+      if (binding.after) {
+        cyclicDependencyStack.push(bindingKey);
+        arrayForEach(binding.after, function(bindingDependencyKey) {
+          if (!bindings[bindingDependencyKey]) {
+            return;
+          }
+          if (arrayIndexOf(cyclicDependencyStack, bindingDependencyKey) !== -1) {
+            throw Error("Cannot combine the following bindings, because they have a cyclic dependency: " + cyclicDependencyStack.join(", "));
+          } else {
+            pushBinding(bindingDependencyKey);
+          }
+        });
+        cyclicDependencyStack.length--;
+      }
+      results.push([bindingKey, binding]);
+    }
+    bindingsConsidered[bindingKey] = true;
+  });
+  for (const result of results) {
+    yield result;
+  }
+}
+function applyBindingsToNodeInternal(node, sourceBindings, bindingContext2, asyncBindingsApplied) {
+  const bindingInfo = data_exports.getOrSet(node, boundElementDomDataKey2, {});
+  const alreadyBound = bindingInfo.alreadyBound;
+  if (!sourceBindings) {
+    if (alreadyBound) {
+      if (!nodeOrChildHasBindings(node)) {
+        return false;
+      }
+      onBindingError({
+        during: "apply",
+        errorCaptured: new Error("You cannot apply bindings multiple times to the same element."),
+        element: node,
+        bindingContext: bindingContext2
+      });
+      return false;
+    }
+    bindingInfo.alreadyBound = true;
+  }
+  if (!alreadyBound) {
+    bindingInfo.context = bindingContext2;
+  }
+  var bindings;
+  if (sourceBindings && typeof sourceBindings !== "function") {
+    bindings = sourceBindings;
+  } else {
+    const provider = getBindingProvider();
+    const getBindings = provider.getBindingAccessors;
+    if (isProviderForNode(provider, node)) {
+      var bindingsUpdater = computed(function() {
+        bindings = sourceBindings ? sourceBindings(bindingContext2, node) : getBindings.call(provider, node, bindingContext2);
+        if (bindings && bindingContext2[contextSubscribeSymbol]) {
+          bindingContext2[contextSubscribeSymbol]();
+        }
+        return bindings;
+      }, null, { disposeWhenNodeIsRemoved: node });
+      if (!bindings || !bindingsUpdater.isActive()) {
+        bindingsUpdater = null;
+      }
+    }
+  }
+  var bindingHandlerThatControlsDescendantBindings;
+  if (bindings) {
+    let allBindings = function() {
+      return objectMap(bindingsUpdater ? bindingsUpdater() : bindings, evaluateValueAccessor);
+    };
+    const $component = bindingContext2.$component || {};
+    const allBindingHandlers = {};
+    data_exports.set(node, "bindingHandlers", allBindingHandlers);
+    const getValueAccessor = bindingsUpdater ? (bindingKey) => function(optionalValue) {
+      const valueAccessor = bindingsUpdater()[bindingKey];
+      if (arguments.length === 0) {
+        return evaluateValueAccessor(valueAccessor);
+      } else {
+        return valueAccessor(optionalValue);
+      }
+    } : (bindingKey) => bindings[bindingKey];
+    allBindings.has = (key) => key in bindings;
+    allBindings.get = (key) => bindings[key] && evaluateValueAccessor(getValueAccessor(key));
+    if (bindingEvent.childrenComplete in bindings) {
+      bindingEvent.subscribe(node, bindingEvent.childrenComplete, () => {
+        const callback = evaluateValueAccessor(bindings[bindingEvent.childrenComplete]);
+        if (!callback) {
+          return;
+        }
+        const nodes = virtualElements_exports.childNodes(node);
+        if (nodes.length) {
+          callback(nodes, dataFor(nodes[0]));
+        }
+      });
+    }
+    const bindingsGenerated = topologicalSortBindings(bindings, $component);
+    const nodeAsyncBindingPromises = /* @__PURE__ */ new Set();
+    for (const [key, BindingHandlerClass] of bindingsGenerated) {
+      let reportBindingError = function(during, errorCaptured) {
+        onBindingError({
+          during,
+          errorCaptured,
+          bindings,
+          allBindings,
+          bindingKey: key,
+          bindingContext: bindingContext2,
+          element: node,
+          valueAccessor: getValueAccessor(key)
+        });
+      };
+      if (node.nodeType === 8 && !BindingHandlerClass.allowVirtualElements) {
+        throw new Error(`The binding '${key}' cannot be used with virtual elements`);
+      }
+      try {
+        const bindingHandler = dependencyDetection_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.");
+          }
+          bindingHandlerThatControlsDescendantBindings = key;
+        }
+        if (bindingHandler.bindingCompleted instanceof Promise) {
+          asyncBindingsApplied.add(bindingHandler.bindingCompleted);
+          nodeAsyncBindingPromises.add(bindingHandler.bindingCompleted);
+        }
+      } catch (err) {
+        reportBindingError("creation", err);
+      }
+    }
+    triggerDescendantsComplete(node, bindings, nodeAsyncBindingPromises);
+  }
+  const shouldBindDescendants = bindingHandlerThatControlsDescendantBindings === void 0;
+  return { shouldBindDescendants };
+}
+function triggerDescendantsComplete(node, bindings, nodeAsyncBindingPromises) {
+  const hasBindingHandler = bindingEvent.descendantsComplete in bindings;
+  const hasFirstChild = virtualElements_exports.firstChild(node);
+  const accessor = hasBindingHandler && evaluateValueAccessor(bindings[bindingEvent.descendantsComplete]);
+  const callback = () => {
+    bindingEvent.notify(node, bindingEvent.descendantsComplete);
+    if (accessor && hasFirstChild) {
+      accessor(node);
+    }
+  };
+  if (nodeAsyncBindingPromises.size) {
+    Promise.all(nodeAsyncBindingPromises).then(callback);
+  } else {
+    callback();
+  }
+}
+function getBindingContext(viewModelOrBindingContext, extendContextCallback) {
+  return viewModelOrBindingContext && viewModelOrBindingContext instanceof bindingContext ? viewModelOrBindingContext : new bindingContext(viewModelOrBindingContext, void 0, void 0, extendContextCallback);
+}
+function applyBindingAccessorsToNode(node, bindings, viewModelOrBindingContext, asyncBindingsApplied) {
+  if (node.nodeType === 1) {
+    virtualElements_exports.normaliseVirtualElementDomStructure(node);
+  }
+  return applyBindingsToNodeInternal(node, bindings, getBindingContext(viewModelOrBindingContext), asyncBindingsApplied);
+}
+function applyBindingsToNode(node, bindings, viewModelOrBindingContext) {
+  const asyncBindingsApplied = /* @__PURE__ */ new Set();
+  const bindingContext2 = getBindingContext(viewModelOrBindingContext);
+  const bindingAccessors = getBindingProvider().makeBindingAccessors(bindings, bindingContext2, node);
+  applyBindingAccessorsToNode(node, bindingAccessors, bindingContext2, asyncBindingsApplied);
+  return new BindingResult({ asyncBindingsApplied, rootNode: node, bindingContext: bindingContext2 });
+}
+function applyBindingsToDescendants(viewModelOrBindingContext, rootNode) {
+  const asyncBindingsApplied = /* @__PURE__ */ new Set();
+  if (rootNode.nodeType === 1 || rootNode.nodeType === 8) {
+    const bindingContext2 = getBindingContext(viewModelOrBindingContext);
+    applyBindingsToDescendantsInternal(bindingContext2, rootNode, asyncBindingsApplied);
+    return new BindingResult({ asyncBindingsApplied, rootNode, bindingContext: bindingContext2 });
+  }
+  return new BindingResult({ asyncBindingsApplied, rootNode });
+}
+function applyBindings(viewModelOrBindingContext, rootNode, extendContextCallback) {
+  const asyncBindingsApplied = /* @__PURE__ */ new Set();
+  if (!options_default.jQuery === void 0 && options_default.jQuery) {
+    options_default.jQuery = options_default.jQuery;
+  }
+  if (!rootNode) {
+    rootNode = window.document.body;
+    if (!rootNode) {
+      throw Error("ko.applyBindings: could not find window.document.body; has the document been loaded?");
+    }
+  } else if (rootNode.nodeType !== 1 && rootNode.nodeType !== 8) {
+    throw Error("ko.applyBindings: first parameter should be your view model; second parameter should be a DOM node");
+  }
+  const rootContext = getBindingContext(viewModelOrBindingContext, extendContextCallback);
+  applyBindingsToNodeAndDescendantsInternal(rootContext, rootNode, asyncBindingsApplied);
+  return Promise.all(asyncBindingsApplied);
+}
+function onBindingError(spec) {
+  var error, bindingText;
+  if (spec.bindingKey) {
+    error = spec.errorCaptured;
+    spec.message = 'Unable to process binding "' + spec.bindingKey + '" in binding "' + spec.bindingKey + '"\nMessage: ' + (error.message ? error.message : error);
+  } else {
+    error = spec.errorCaptured;
+  }
+  try {
+    extend(error, spec);
+  } catch (e) {
+    spec.stack = error.stack;
+    error = new Error(error.message ? error.message : error);
+    extend(error, spec);
+  }
+  options_default.onError(error);
+}
+
+// ../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 };
+}
+var lastMappingResultDomDataKey = data_exports.nextKey();
+var deletedItemDummyValue = data_exports.nextKey();
+function setDomNodeChildrenFromArrayMapping(domNode, array, mapping, options2, callbackAfterAddingNodes, editScript) {
+  array = array || [];
+  if (typeof array.length === "undefined") {
+    array = [array];
+  }
+  options2 = options2 || {};
+  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;
+  let countWaitingForRemove = 0;
+  function itemAdded(value) {
+    mapData = { arrayEntry: value, indexObservable: observable(newMappingResultIndex++) };
+    newMappingResult.push(mapData);
+    itemsToProcess.push(mapData);
+    if (!isFirstExecution) {
+      itemsForAfterAddCallbacks.push(mapData);
+    }
+  }
+  function itemMovedOrRetained(oldPosition) {
+    mapData = lastMappingResult[oldPosition];
+    if (newMappingResultIndex !== oldPosition) {
+      itemsForMoveCallbacks.push(mapData);
+    }
+    mapData.indexObservable(newMappingResultIndex++);
+    fixUpContinuousNodeArray(mapData.mappedNodes, domNode);
+    newMappingResult.push(mapData);
+    itemsToProcess.push(mapData);
+  }
+  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);
+        });
+      }
+    }
+  }
+  if (isFirstExecution) {
+    arrayForEach(array, itemAdded);
+  } else {
+    if (!editScript || lastMappingResult && lastMappingResult["_countWaitingForRemove"]) {
+      var lastArray = isFirstExecution ? [] : arrayMap(lastMappingResult, function(x) {
+        return x.arrayEntry;
+      });
+      var compareOptions = {
+        "dontLimitMoves": options2["dontLimitMoves"],
+        "sparse": true
+      };
+      editScript = compareArrays(lastArray, array, compareOptions);
+    }
+    for (var i = 0, editScriptItem, movedIndex, itemIndex; editScriptItem = editScript[i]; i++) {
+      movedIndex = editScriptItem["moved"];
+      itemIndex = editScriptItem["index"];
+      switch (editScriptItem["status"]) {
+        case "deleted":
+          while (lastMappingResultIndex < itemIndex) {
+            itemMovedOrRetained(lastMappingResultIndex++);
+          }
+          if (movedIndex === void 0) {
+            mapData = lastMappingResult[lastMappingResultIndex];
+            if (mapData.dependentObservable) {
+              mapData.dependentObservable.dispose();
+              mapData.dependentObservable = void 0;
+            }
+            if (fixUpContinuousNodeArray(mapData.mappedNodes, domNode).length) {
+              if (options2["beforeRemove"]) {
+                newMappingResult.push(mapData);
+                itemsToProcess.push(mapData);
+                countWaitingForRemove++;
+                if (mapData.arrayEntry === deletedItemDummyValue) {
+                  mapData = null;
+                } else {
+                  itemsForBeforeRemoveCallbacks.push(mapData);
+                }
+              }
+              if (mapData) {
+                nodesToDelete.push.apply(nodesToDelete, mapData.mappedNodes);
+              }
+            }
+          }
+          lastMappingResultIndex++;
+          break;
+        case "added":
+          while (newMappingResultIndex < itemIndex) {
+            itemMovedOrRetained(lastMappingResultIndex++);
+          }
+          if (movedIndex !== void 0) {
+            itemMovedOrRetained(movedIndex);
+          } else {
+            itemAdded(editScriptItem["value"]);
+          }
+          break;
+      }
+    }
+    while (newMappingResultIndex < array.length) {
+      itemMovedOrRetained(lastMappingResultIndex++);
+    }
+    newMappingResult["_countWaitingForRemove"] = countWaitingForRemove;
+  }
+  data_exports.set(domNode, lastMappingResultDomDataKey, newMappingResult);
+  callCallback(options2["beforeMove"], itemsForMoveCallbacks);
+  arrayForEach(nodesToDelete, options2["beforeRemove"] ? cleanNode : removeNode);
+  i = 0;
+  for (var nextNode = virtualElements_exports.firstChild(domNode), lastNode, node; mapData = itemsToProcess[i]; i++) {
+    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++) {
+      if (node !== nextNode) {
+        virtualElements_exports.insertAfter(domNode, node, lastNode);
+      }
+    }
+    if (!mapData.initialized && callbackAfterAddingNodes) {
+      callbackAfterAddingNodes(mapData.arrayEntry, mapData.mappedNodes, mapData.indexObservable);
+      mapData.initialized = true;
+    }
+  }
+  callCallback(options2["beforeRemove"], itemsForBeforeRemoveCallbacks);
+  for (i = 0; i < itemsForBeforeRemoveCallbacks.length; ++i) {
+    itemsForBeforeRemoveCallbacks[i].arrayEntry = deletedItemDummyValue;
+  }
+  callCallback(options2["afterMove"], itemsForMoveCallbacks);
+  callCallback(options2["afterAdd"], itemsForAfterAddCallbacks);
+}
+
+// ../binding.template/dist/templateSources.js
+var templateScript = 1;
+var templateTextArea = 2;
+var templateTemplate = 3;
+var templateElement = 4;
+function domElement(element) {
+  this.domElement = element;
+  if (!element) {
+    return;
+  }
+  var tagNameLower2 = tagNameLower(element);
+  this.templateType = tagNameLower2 === "script" ? templateScript : tagNameLower2 === "textarea" ? templateTextArea : tagNameLower2 == "template" && element.content && element.content.nodeType === 11 ? templateTemplate : templateElement;
+}
+domElement.prototype.text = function() {
+  var elemContentsProperty = this.templateType === templateScript ? "text" : this.templateType === templateTextArea ? "value" : "innerHTML";
+  if (arguments.length == 0) {
+    return this.domElement[elemContentsProperty];
+  } else {
+    var valueToWrite = arguments[0];
+    if (elemContentsProperty === "innerHTML") {
+      setHtml(this.domElement, valueToWrite);
+    } else {
+      this.domElement[elemContentsProperty] = valueToWrite;
+    }
+  }
+};
+var dataDomDataPrefix = data_exports.nextKey() + "_";
+domElement.prototype.data = function(key) {
+  if (arguments.length === 1) {
+    return data_exports.get(this.domElement, dataDomDataPrefix + key);
+  } else {
+    data_exports.set(this.domElement, dataDomDataPrefix + key, arguments[1]);
+  }
+};
+var templatesDomDataKey = data_exports.nextKey();
+function getTemplateDomData(element) {
+  return data_exports.get(element, templatesDomDataKey) || {};
+}
+function setTemplateDomData(element, data) {
+  data_exports.set(element, templatesDomDataKey, data);
+}
+domElement.prototype.nodes = function() {
+  var element = this.domElement;
+  if (arguments.length == 0) {
+    const templateData = getTemplateDomData(element);
+    let nodes = templateData.containerData || (this.templateType === templateTemplate ? element.content : this.templateType === templateElement ? element : void 0);
+    if (!nodes || templateData.alwaysCheckText) {
+      const text = this["text"]();
+      if (text) {
+        nodes = parseHtmlForTemplateNodes(text, element.ownerDocument);
+        this["text"]("");
+        setTemplateDomData(element, { containerData: nodes, alwaysCheckText: true });
+      }
+    }
+    return nodes;
+  } else {
+    var valueToWrite = arguments[0];
+    setTemplateDomData(element, { containerData: valueToWrite });
+  }
+};
+function anonymousTemplate(element) {
+  this.domElement = element;
+}
+anonymousTemplate.prototype = new domElement();
+anonymousTemplate.prototype.constructor = anonymousTemplate;
+anonymousTemplate.prototype.text = function() {
+  if (arguments.length == 0) {
+    var templateData = getTemplateDomData(this.domElement);
+    if (templateData.textData === void 0 && templateData.containerData) {
+      templateData.textData = templateData.containerData.innerHTML;
+    }
+    return templateData.textData;
+  } else {
+    var valueToWrite = arguments[0];
+    setTemplateDomData(this.domElement, { textData: valueToWrite });
+  }
+};
+
+// ../binding.template/dist/templateEngine.js
+function templateEngine() {
+}
+extend(templateEngine.prototype, {
+  renderTemplateSource: function(templateSource, bindingContext2, options2, templateDocument) {
+    options2.onError("Override renderTemplateSource");
+  },
+  createJavaScriptEvaluatorBlock: function(script) {
+    options_default.onError("Override createJavaScriptEvaluatorBlock");
+  },
+  makeTemplateSource: function(template, templateDocument) {
+    if (typeof template === "string") {
+      templateDocument = templateDocument || document;
+      var elem = templateDocument.getElementById(template);
+      if (!elem) {
+        options_default.onError("Cannot find template with ID " + template);
+      }
+      return new domElement(elem);
+    } else if (template.nodeType == 1 || template.nodeType == 8) {
+      return new anonymousTemplate(template);
+    } else {
+      options_default.onError("Unknown template type: " + template);
+    }
+  },
+  renderTemplate: function(template, bindingContext2, options2, templateDocument) {
+    var templateSource = this["makeTemplateSource"](template, templateDocument);
+    return this.renderTemplateSource(templateSource, bindingContext2, options2, templateDocument);
+  }
+});
+
+// ../binding.template/dist/templating.js
+var _templateEngine;
+var cleanContainerDomDataKey = data_exports.nextKey();
+function setTemplateEngine(tEngine) {
+  if (tEngine !== void 0 && !(tEngine instanceof templateEngine)) {
+    throw new Error("templateEngine must inherit from ko.templateEngine");
+  }
+  _templateEngine = tEngine;
+}
+function invokeForEachNodeInContinuousRange(firstNode, lastNode, action) {
+  let node;
+  let nextInQueue = firstNode;
+  let firstOutOfRangeNode = virtualElements_exports.nextSibling(lastNode);
+  while (nextInQueue && (node = nextInQueue) !== firstOutOfRangeNode) {
+    nextInQueue = virtualElements_exports.nextSibling(node);
+    action(node, nextInQueue);
+  }
+}
+function activateBindingsOnContinuousNodeArray(continuousNodeArray, bindingContext2, afterBindingCallback) {
+  if (continuousNodeArray.length) {
+    var firstNode = continuousNodeArray[0];
+    var lastNode = continuousNodeArray[continuousNodeArray.length - 1];
+    var parentNode = firstNode.parentNode;
+    var provider = options_default.bindingProviderInstance;
+    var preprocessNode = provider.preprocessNode;
+    if (preprocessNode) {
+      invokeForEachNodeInContinuousRange(firstNode, lastNode, function(node, nextNodeInRange) {
+        var nodePreviousSibling = node.previousSibling;
+        var newNodes = preprocessNode.call(provider, node);
+        if (newNodes) {
+          if (node === firstNode) {
+            firstNode = newNodes[0] || nextNodeInRange;
+          }
+          if (node === lastNode) {
+            lastNode = newNodes[newNodes.length - 1] || nodePreviousSibling;
+          }
+        }
+      });
+      continuousNodeArray.length = 0;
+      if (!firstNode) {
+        return;
+      }
+      if (firstNode === lastNode) {
+        continuousNodeArray.push(firstNode);
+      } else {
+        continuousNodeArray.push(firstNode, lastNode);
+        fixUpContinuousNodeArray(continuousNodeArray, parentNode);
+      }
+    }
+    invokeForEachNodeInContinuousRange(firstNode, lastNode, function(node) {
+      if (node.nodeType === 1 || node.nodeType === 8) {
+        applyBindings(bindingContext2, node).then(afterBindingCallback);
+      }
+    });
+    invokeForEachNodeInContinuousRange(firstNode, lastNode, function(node) {
+      if (node.nodeType === 1 || node.nodeType === 8) {
+        memoization_exports.unmemoizeDomNodeAndDescendants(node, [bindingContext2]);
+      }
+    });
+    fixUpContinuousNodeArray(continuousNodeArray, parentNode);
+  }
+}
+function getFirstNodeFromPossibleArray(nodeOrNodeArray) {
+  return nodeOrNodeArray.nodeType ? nodeOrNodeArray : nodeOrNodeArray.length > 0 ? nodeOrNodeArray[0] : null;
+}
+function executeTemplate(targetNodeOrNodeArray, renderMode, template, bindingContext2, options2, afterBindingCallback) {
+  options2 = options2 || {};
+  var firstTargetNode = targetNodeOrNodeArray && getFirstNodeFromPossibleArray(targetNodeOrNodeArray);
+  var templateDocument = (firstTargetNode || template || {}).ownerDocument;
+  var templateEngineToUse = options2.templateEngine || _templateEngine;
+  var renderedNodesArray = templateEngineToUse.renderTemplate(template, bindingContext2, options2, templateDocument);
+  if (typeof renderedNodesArray.length !== "number" || renderedNodesArray.length > 0 && typeof renderedNodesArray[0].nodeType !== "number") {
+    throw new Error("Template engine must return an array of DOM nodes");
+  }
+  var haveAddedNodesToParent = false;
+  switch (renderMode) {
+    case "replaceChildren":
+      virtualElements_exports.setDomNodeChildren(targetNodeOrNodeArray, renderedNodesArray);
+      haveAddedNodesToParent = true;
+      break;
+    case "replaceNode":
+      replaceDomNodes(targetNodeOrNodeArray, renderedNodesArray);
+      haveAddedNodesToParent = true;
+      break;
+    case "ignoreTargetNode":
+      break;
+    default:
+      throw new Error("Unknown renderMode: " + renderMode);
+  }
+  if (haveAddedNodesToParent) {
+    activateBindingsOnContinuousNodeArray(renderedNodesArray, bindingContext2, afterBindingCallback);
+    if (options2.afterRender) {
+      dependencyDetection_exports.ignore(options2.afterRender, null, [renderedNodesArray, bindingContext2["$data"]]);
+    }
+    if (renderMode === "replaceChildren") {
+      bindingEvent.notify(targetNodeOrNodeArray, bindingEvent.childrenComplete);
+    }
+  }
+  return renderedNodesArray;
+}
+function resolveTemplateName(template, data, context) {
+  if (isObservable(template)) {
+    return template();
+  } else if (typeof template === "function") {
+    return template(data, context);
+  } else {
+    return template;
+  }
+}
+function renderTemplate(template, dataOrBindingContext, options2, targetNodeOrNodeArray, renderMode, afterBindingCallback) {
+  options2 = options2 || {};
+  if ((options2.templateEngine || _templateEngine) === void 0) {
+    throw new Error("Set a template engine before calling renderTemplate");
+  }
+  renderMode = renderMode || "replaceChildren";
+  if (targetNodeOrNodeArray) {
+    var firstTargetNode = getFirstNodeFromPossibleArray(targetNodeOrNodeArray);
+    var whenToDispose = function() {
+      return !firstTargetNode || !domNodeIsAttachedToDocument(firstTargetNode);
+    };
+    var activelyDisposeWhenNodeIsRemoved = firstTargetNode && renderMode === "replaceNode" ? firstTargetNode.parentNode : firstTargetNode;
+    return computed(function() {
+      var bindingContext2 = dataOrBindingContext && dataOrBindingContext instanceof bindingContext ? dataOrBindingContext : new bindingContext(dataOrBindingContext, null, null, null, { "exportDependencies": true });
+      var templateName = resolveTemplateName(template, bindingContext2.$data, bindingContext2);
+      const renderedNodesArray = executeTemplate(targetNodeOrNodeArray, renderMode, templateName, bindingContext2, options2, afterBindingCallback);
+      if (renderMode === "replaceNode") {
+        targetNodeOrNodeArray = renderedNodesArray;
+        firstTargetNode = getFirstNodeFromPossibleArray(targetNodeOrNodeArray);
+      }
+    }, null, { disposeWhen: whenToDispose, disposeWhenNodeIsRemoved: activelyDisposeWhenNodeIsRemoved });
+  } else {
+    return memoization_exports.memoize(function(domNode) {
+      renderTemplate(template, dataOrBindingContext, options2, domNode, "replaceNode");
+    });
+  }
+}
+var templateComputedDomDataKey = data_exports.nextKey();
+
+// ../binding.template/dist/nativeTemplateEngine.js
+function nativeTemplateEngine() {
+}
+nativeTemplateEngine.prototype = new templateEngine();
+nativeTemplateEngine.prototype.constructor = nativeTemplateEngine;
+nativeTemplateEngine.prototype.renderTemplateSource = function(templateSource, bindingContext2, options2, templateDocument) {
+  var useNodesIfAvailable = !(ieVersion < 9), templateNodesFunc = useNodesIfAvailable ? templateSource.nodes : null, templateNodes = templateNodesFunc ? templateSource.nodes() : null;
+  if (templateNodes) {
+    return makeArray(templateNodes.cloneNode(true).childNodes);
+  } else {
+    var templateText = templateSource.text();
+    return parseHtmlFragment(templateText, templateDocument);
+  }
+};
+nativeTemplateEngine.instance = new nativeTemplateEngine();
+setTemplateEngine(nativeTemplateEngine.instance);
+
+// src/Builder.ts
+var domNodeDisposal = {
+  addDisposeCallback,
+  removeDisposeCallback,
+  removeNode,
+  addCleaner,
+  removeCleaner,
+  get cleanExternalData() {
+    return options_default.cleanExternalData;
+  },
+  set cleanExternalData(cleanerFn) {
+    options_default.set("cleanExternalData", cleanerFn);
+  }
+};
+var utils = Object.assign({
+  addOrRemoveItem,
+  arrayFilter,
+  arrayFirst,
+  arrayForEach,
+  arrayGetDistinctValues,
+  arrayIndexOf,
+  arrayMap,
+  arrayPushAll,
+  arrayRemoveItem,
+  cloneNodes,
+  compareArrays,
+  createSymbolOrString,
+  domData: data_exports,
+  domNodeDisposal,
+  extend,
+  filters: options_default.filters,
+  objectForEach,
+  objectMap,
+  parseHtmlFragment,
+  parseJson,
+  parseObjectLiteral,
+  peekObservable: peek,
+  range,
+  registerEventHandler,
+  setDomNodeChildrenFromArrayMapping,
+  setHtml,
+  setTextContent,
+  toggleDomNodeCssClass,
+  triggerEvent,
+  unwrapObservable: unwrap
+});
+var knockout = {
+  cleanNode,
+  dependencyDetection: dependencyDetection_exports,
+  computedContext: dependencyDetection_exports,
+  filters: options_default.filters,
+  ignoreDependencies: dependencyDetection_exports.ignore,
+  memoization: memoization_exports,
+  options: options_default,
+  removeNode,
+  selectExtensions,
+  tasks: tasks_exports,
+  utils,
+  LifeCycle,
+  isObservable,
+  isSubscribable,
+  isWriteableObservable,
+  isWritableObservable: isWriteableObservable,
+  observable,
+  observableArray,
+  isObservableArray,
+  peek,
+  subscribable,
+  unwrap,
+  toJS,
+  toJSON,
+  proxy,
+  computed,
+  dependentObservable: computed,
+  isComputed,
+  isPureComputed,
+  pureComputed,
+  when,
+  nativeTemplateEngine,
+  renderTemplate,
+  setTemplateEngine,
+  templateEngine,
+  templateSources: { domElement, anonymousTemplate },
+  applyBindingAccessorsToNode,
+  applyBindings,
+  applyBindingsToDescendants,
+  applyBindingsToNode,
+  contextFor,
+  dataFor,
+  BindingHandler,
+  AsyncBindingHandler,
+  virtualElements: virtualElements_exports,
+  domNodeDisposal,
+  bindingEvent
+};
+var Builder = class {
+  constructor({ provider, bindings, extenders: extenders2, filters, options: options2 }) {
+    Object.assign(knockout.options, options2, {
+      filters,
+      bindingProviderInstance: provider
+    });
+    provider.setGlobals(knockout.options.bindingGlobals);
+    if (Array.isArray(bindings)) {
+      for (const bindingsObject of bindings) {
+        provider.bindingHandlers.set(bindingsObject);
+      }
+    } else {
+      provider.bindingHandlers.set(bindings);
+    }
+    this.providedProperties = {
+      extenders: Object.assign(extenders, extenders2),
+      bindingHandlers: provider.bindingHandlers,
+      bindingProvider: provider
+    };
+  }
+  create(...additionalProperties) {
+    const instance = Object.assign({
+      get getBindingHandler() {
+        return options_default.getBindingHandler;
+      },
+      set getBindingHandler(fn) {
+        options_default.set("getBindingHandler", fn);
+      }
+    }, knockout, this.providedProperties, ...additionalProperties);
+    instance.options.knockoutInstance = instance;
+    return instance;
+  }
+};