tag is supported\r\nsupportsTemplateTag = options.document && 'content' in options.document.createElement('template');\r\nfunction getWrap(tags) {\r\n var m = tags.match(/^(?:\\s*?)*?<([a-z]+)[\\s>]/);\r\n return (m && lookup[m[1]]) || none;\r\n}\r\nfunction simpleHtmlParse(html, documentContext) {\r\n documentContext || (documentContext = document);\r\n var windowContext = documentContext['parentWindow'] || documentContext['defaultView'] || window;\r\n // Based on jQuery's \"clean\" function, but only accounting for table-related elements.\r\n // If you have referenced jQuery, this won't be used anyway - KO will use jQuery's \"clean\" function directly\r\n // Note that there's still an issue in IE < 9 whereby it will discard comment nodes that are the first child of\r\n // a descendant node. For example: \"abc
\" will get parsed as \"abc
\"\r\n // This won't affect anyone who has referenced jQuery, and there's always the workaround of inserting a dummy node\r\n // (possibly a text node) in front of the comment. So, KO does not attempt to workaround this IE issue automatically at present.\r\n // Trim whitespace, otherwise indexOf won't work as expected\r\n var tags = stringTrim(html).toLowerCase(), div = documentContext.createElement('div'), wrap = getWrap(tags), depth = wrap[0];\r\n // Go to html and back, then peel off extra wrappers\r\n // Note that we always prefix with some dummy text, because otherwise, IE<9 will strip out leading comment nodes in descendants. Total madness.\r\n var markup = 'ignored' + wrap[1] + html + wrap[2] + '
';\r\n if (typeof windowContext['innerShiv'] === 'function') {\r\n // Note that innerShiv is deprecated in favour of html5shiv. We should consider adding\r\n // support for html5shiv (except if no explicit support is needed, e.g., if html5shiv\r\n // somehow shims the native APIs so it just works anyway)\r\n div.appendChild(windowContext['innerShiv'](markup));\r\n }\r\n else {\r\n div.innerHTML = markup;\r\n }\r\n // Move to the right depth\r\n while (depth--) {\r\n div = div.lastChild;\r\n }\r\n return makeArray(div.lastChild.childNodes);\r\n}\r\nfunction templateHtmlParse(html, documentContext) {\r\n if (!documentContext) {\r\n documentContext = document;\r\n }\r\n var template = documentContext.createElement('template');\r\n template.innerHTML = html;\r\n return makeArray(template.content.childNodes);\r\n}\r\nfunction jQueryHtmlParse(html, documentContext) {\r\n // jQuery's \"parseHTML\" function was introduced in jQuery 1.8.0 and is a documented public API.\r\n if (jQueryInstance.parseHTML) {\r\n return jQueryInstance.parseHTML(html, documentContext) || []; // Ensure we always return an array and never null\r\n }\r\n else {\r\n // For jQuery < 1.8.0, we fall back on the undocumented internal \"clean\" function.\r\n var elems = jQueryInstance.clean([html], documentContext);\r\n // As of jQuery 1.7.1, jQuery parses the HTML by appending it to some dummy parent nodes held in an in-memory document fragment.\r\n // Unfortunately, it never clears the dummy parent nodes from the document fragment, so it leaks memory over time.\r\n // Fix this by finding the top-most dummy parent element, and detaching it from its owner fragment.\r\n if (elems && elems[0]) {\r\n // Find the top-most parent element that's a direct child of a document fragment\r\n var elem = elems[0];\r\n while (elem.parentNode && elem.parentNode.nodeType !== 11 /* i.e., DocumentFragment */) {\r\n elem = elem.parentNode;\r\n }\r\n // ... then detach it\r\n if (elem.parentNode) {\r\n elem.parentNode.removeChild(elem);\r\n }\r\n }\r\n return elems;\r\n }\r\n}\r\n/**\r\n * parseHtmlFragment converts a string into an array of DOM Nodes.\r\n * If supported, it uses -tag parsing, falling back on\r\n * jQuery parsing (if jQuery is present), and finally on a\r\n * straightforward parser.\r\n *\r\n * @param {string} html To be parsed.\r\n * @param {Object} documentContext That owns the executing code.\r\n * @return {[DOMNode]} Parsed DOM Nodes\r\n */\r\nfunction parseHtmlFragment(html, documentContext) {\r\n // Prefer -tag based HTML parsing.\r\n return supportsTemplateTag ? templateHtmlParse(html, documentContext)\r\n // Benefit from jQuery's on old browsers, where possible\r\n // NOTE: jQuery's HTML parsing fails on element names like tr-*.\r\n // See: https://github.com/jquery/jquery/pull/1988\r\n : (jQueryInstance ? jQueryHtmlParse(html, documentContext)\r\n // ... otherwise, this simple logic will do in most common cases.\r\n : simpleHtmlParse(html, documentContext));\r\n}\r\nfunction parseHtmlForTemplateNodes(html, documentContext) {\r\n var nodes = parseHtmlFragment(html, documentContext);\r\n return (nodes.length && nodes[0].parentElement) || moveCleanedNodesToContainerElement(nodes);\r\n}\r\n/**\r\n * setHtml empties the node's contents, unwraps the HTML, and\r\n * sets the node's HTML using jQuery.html or parseHtmlFragment\r\n *\r\n * @param {DOMNode} node Node in which HTML needs to be set\r\n * @param {DOMNode} html HTML to be inserted in node\r\n * @returns undefined\r\n */\r\nfunction setHtml(node, html) {\r\n emptyDomNode(node);\r\n // There's few cases where we would want to display a stringified\r\n // function, so we unwrap it.\r\n if (typeof html === 'function') {\r\n html = html();\r\n }\r\n if ((html !== null) && (html !== undefined)) {\r\n if (typeof html !== 'string') {\r\n html = html.toString();\r\n }\r\n // If the browser supports tags, prefer that, as\r\n // it obviates all the complex workarounds of jQuery.\r\n //\r\n // However, jQuery contains a lot of sophisticated code to parse arbitrary HTML fragments,\r\n // for example elements which are not normally allowed to exist on their own.\r\n // If you've referenced jQuery (and template tags are not supported) we'll use that rather than duplicating its code.\r\n if (jQueryInstance && !supportsTemplateTag) {\r\n jQueryInstance(node).html(html);\r\n }\r\n else {\r\n // ... otherwise, use KO's own parsing logic.\r\n var parsedNodes = parseHtmlFragment(html, node.ownerDocument);\r\n if (node.nodeType === 8) {\r\n if (html === null) {\r\n emptyNode(node);\r\n }\r\n else {\r\n setDomNodeChildren$1(node, parsedNodes);\r\n }\r\n }\r\n else {\r\n for (var i = 0; i < parsedNodes.length; i++) {\r\n node.appendChild(parsedNodes[i]);\r\n }\r\n }\r\n }\r\n }\r\n}\r\nfunction setTextContent(element, textContent) {\r\n var value = typeof textContent === 'function' ? textContent() : textContent;\r\n if ((value === null) || (value === undefined)) {\r\n value = '';\r\n }\r\n // We need there to be exactly one child: a text node.\r\n // If there are no children, more than one, or if it's not a text node,\r\n // we'll clear everything and create a single text node.\r\n var innerTextNode = firstChild(element);\r\n if (!innerTextNode || innerTextNode.nodeType != 3 || nextSibling(innerTextNode)) {\r\n setDomNodeChildren$1(element, [element.ownerDocument.createTextNode(value)]);\r\n }\r\n else {\r\n innerTextNode.data = value;\r\n }\r\n forceRefresh(element);\r\n}\n\nvar hasDomDataExpandoProperty = Symbol('Knockout selectExtensions hasDomDataProperty');\r\n// Normally, SELECT elements and their OPTIONs can only take value of type 'string' (because the values\r\n// are stored on DOM attributes). ko.selectExtensions provides a way for SELECTs/OPTIONs to have values\r\n// that are arbitrary objects. This is very convenient when implementing things like cascading dropdowns.\r\n//\r\nvar selectExtensions = {\r\n optionValueDomDataKey: nextKey(),\r\n readValue: function (element) {\r\n switch (tagNameLower(element)) {\r\n case 'option':\r\n if (element[hasDomDataExpandoProperty] === true) {\r\n return get(element, selectExtensions.optionValueDomDataKey);\r\n }\r\n return element.value;\r\n case 'select':\r\n return element.selectedIndex >= 0 ? selectExtensions.readValue(element.options[element.selectedIndex]) : undefined;\r\n default:\r\n return element.value;\r\n }\r\n },\r\n writeValue: function (element, value, allowUnset) {\r\n switch (tagNameLower(element)) {\r\n case 'option':\r\n if (typeof value === 'string') {\r\n set(element, selectExtensions.optionValueDomDataKey, undefined);\r\n if (hasDomDataExpandoProperty in element) { // IE <= 8 throws errors if you delete non-existent properties from a DOM node\r\n delete element[hasDomDataExpandoProperty];\r\n }\r\n element.value = value;\r\n }\r\n else {\r\n // Store arbitrary object using DomData\r\n set(element, selectExtensions.optionValueDomDataKey, value);\r\n element[hasDomDataExpandoProperty] = true;\r\n // Special treatment of numbers is just for backward compatibility. KO 1.2.1 wrote numerical values to element.value.\r\n element.value = typeof value === 'number' ? value : '';\r\n }\r\n break;\r\n case 'select':\r\n if (value === '' || value === null) {\r\n // A blank string or null value will select the caption\r\n value = undefined;\r\n }\r\n var selection = -1;\r\n for (var i = 0, n = element.options.length, optionValue = void 0; i < n; ++i) {\r\n optionValue = selectExtensions.readValue(element.options[i]);\r\n // Include special check to handle selecting a caption with a blank string value\r\n if (optionValue === value || (optionValue === '' && value === undefined)) {\r\n selection = i;\r\n break;\r\n }\r\n }\r\n if (allowUnset || selection >= 0 || (value === undefined && element.size > 1)) {\r\n element.selectedIndex = selection;\r\n if (ieVersion === 6) {\r\n // Workaround for IE6 bug: It won't reliably apply values to SELECT nodes during the same execution thread\r\n // right after you've changed the set of OPTION nodes on it. So for that node type, we'll schedule a second thread\r\n // to apply the value as well.\r\n safeSetTimeout(function () { element.selectedIndex = selection; }, 0);\r\n }\r\n }\r\n break;\r\n default:\r\n if ((value === null) || (value === undefined)) {\r\n value = '';\r\n }\r\n element.value = value;\r\n break;\r\n }\r\n }\r\n};\n\n//\r\nvar memos = {};\r\nfunction randomMax8HexChars() {\r\n return (((1 + Math.random()) * 0x100000000) | 0).toString(16).substring(1);\r\n}\r\nfunction generateRandomId() {\r\n return randomMax8HexChars() + randomMax8HexChars();\r\n}\r\nfunction findMemoNodes(rootNode, appendToArray) {\r\n if (!rootNode) {\r\n return;\r\n }\r\n if (rootNode.nodeType == 8) {\r\n var memoId = parseMemoText(rootNode.nodeValue);\r\n if (memoId != null) {\r\n appendToArray.push({ domNode: rootNode, memoId: memoId });\r\n }\r\n }\r\n else if (rootNode.nodeType == 1) {\r\n for (var i = 0, childNodes = rootNode.childNodes, j = childNodes.length; i < j; i++) {\r\n findMemoNodes(childNodes[i], appendToArray);\r\n }\r\n }\r\n}\r\nfunction memoize(callback) {\r\n if (typeof callback !== 'function') {\r\n throw new Error('You can only pass a function to memoization.memoize()');\r\n }\r\n var memoId = generateRandomId();\r\n memos[memoId] = callback;\r\n return '';\r\n}\r\nfunction unmemoize(memoId, callbackParams) {\r\n var callback = memos[memoId];\r\n if (callback === undefined) {\r\n throw new Error(\"Couldn't find any memo with ID \" + memoId + \". Perhaps it's already been unmemoized.\");\r\n }\r\n try {\r\n callback.apply(null, callbackParams || []);\r\n return true;\r\n }\r\n finally {\r\n delete memos[memoId];\r\n }\r\n}\r\nfunction unmemoizeDomNodeAndDescendants(domNode, extraCallbackParamsArray) {\r\n var memos = [];\r\n findMemoNodes(domNode, memos);\r\n for (var i = 0, j = memos.length; i < j; i++) {\r\n var node = memos[i].domNode;\r\n var combinedParams = [node];\r\n if (extraCallbackParamsArray) {\r\n arrayPushAll(combinedParams, extraCallbackParamsArray);\r\n }\r\n unmemoize(memos[i].memoId, combinedParams);\r\n node.nodeValue = ''; // Neuter this node so we don't try to unmemoize it again\r\n if (node.parentNode) {\r\n node.parentNode.removeChild(node);\r\n } // If possible, erase it totally (not always possible - someone else might just hold a reference to it then call unmemoizeDomNodeAndDescendants again)\r\n }\r\n}\r\nfunction parseMemoText(memoText) {\r\n var match = memoText.match(/^\\[ko_memo\\:(.*?)\\]$/);\r\n return match ? match[1] : null;\r\n}\n\nvar memoization = /*#__PURE__*/Object.freeze({\n memoize: memoize,\n unmemoize: unmemoize,\n unmemoizeDomNodeAndDescendants: unmemoizeDomNodeAndDescendants,\n parseMemoText: parseMemoText\n});\n\n//\r\nvar taskQueue = [], taskQueueLength = 0, nextHandle = 1, nextIndexToProcess = 0, w = options.global;\r\nif (w && w.MutationObserver && !(w.navigator && w.navigator.standalone)) {\r\n // Chrome 27+, Firefox 14+, IE 11+, Opera 15+, Safari 6.1+, node\r\n // From https://github.com/petkaantonov/bluebird * Copyright (c) 2014 Petka Antonov * License: MIT\r\n options.taskScheduler = (function (callback) {\r\n var div = w.document.createElement('div');\r\n new w.MutationObserver(callback).observe(div, { attributes: true });\r\n return function () { div.classList.toggle('foo'); };\r\n })(scheduledProcess);\r\n}\r\nelse if (w && w.document && 'onreadystatechange' in w.document.createElement('script')) {\r\n // IE 6-10\r\n // From https://github.com/YuzuJS/setImmediate * Copyright (c) 2012 Barnesandnoble.com, llc, Donavon West, and Domenic Denicola * License: MIT\r\n options.taskScheduler = function (callback) {\r\n var script = document.createElement('script');\r\n script.onreadystatechange = function () {\r\n script.onreadystatechange = null;\r\n document.documentElement.removeChild(script);\r\n script = null;\r\n callback();\r\n };\r\n document.documentElement.appendChild(script);\r\n };\r\n}\r\nelse {\r\n options.taskScheduler = function (callback) {\r\n setTimeout(callback, 0);\r\n };\r\n}\r\nfunction processTasks() {\r\n if (taskQueueLength) {\r\n // Each mark represents the end of a logical group of tasks and the number of these groups is\r\n // limited to prevent unchecked recursion.\r\n var mark = taskQueueLength, countMarks = 0;\r\n // nextIndexToProcess keeps track of where we are in the queue; processTasks can be called recursively without issue\r\n for (var task; nextIndexToProcess < taskQueueLength;) {\r\n if (task = taskQueue[nextIndexToProcess++]) {\r\n if (nextIndexToProcess > mark) {\r\n if (++countMarks >= 5000) {\r\n nextIndexToProcess = taskQueueLength; // skip all tasks remaining in the queue since any of them could be causing the recursion\r\n deferError(Error(\"'Too much recursion' after processing \" + countMarks + ' task groups.'));\r\n break;\r\n }\r\n mark = taskQueueLength;\r\n }\r\n try {\r\n task();\r\n }\r\n catch (ex) {\r\n deferError(ex);\r\n }\r\n }\r\n }\r\n }\r\n}\r\nfunction scheduledProcess() {\r\n processTasks();\r\n // Reset the queue\r\n nextIndexToProcess = taskQueueLength = taskQueue.length = 0;\r\n}\r\nfunction scheduleTaskProcessing() {\r\n options.taskScheduler(scheduledProcess);\r\n}\r\nfunction schedule(func) {\r\n if (!taskQueueLength) {\r\n scheduleTaskProcessing();\r\n }\r\n taskQueue[taskQueueLength++] = func;\r\n return nextHandle++;\r\n}\r\nfunction cancel(handle) {\r\n var index = handle - (nextHandle - taskQueueLength);\r\n if (index >= nextIndexToProcess && index < taskQueueLength) {\r\n taskQueue[index] = null;\r\n }\r\n}\r\n// For testing only: reset the queue and return the previous queue length\r\nfunction resetForTesting() {\r\n var length = taskQueueLength - nextIndexToProcess;\r\n nextIndexToProcess = taskQueueLength = taskQueue.length = 0;\r\n return length;\r\n}\n\nvar tasks = /*#__PURE__*/Object.freeze({\n schedule: schedule,\n cancel: cancel,\n resetForTesting: resetForTesting,\n runEarly: processTasks\n});\n\n/*\r\n tko.util\r\n ===\r\n\n*/\n\nexport { tasks, virtualElements, data as domData, memoization, jQuerySetInstance, options, arrayForEach, arrayIndexOf, arrayFirst, arrayMap, arrayRemoveItem, arrayGetDistinctValues, arrayFilter, arrayPushAll, addOrRemoveItem, makeArray, range, findMovesInArrayComparison, compareArrays, throttle, debounce, catchFunctionErrors, deferError, safeSetTimeout, ieVersion, isIe6, isIe7, hasOwnProperty, extend, objectForEach, objectMap, getObjectOwnProperty, clonePlainObjectDeep, functionSupportsLengthOverwrite, overwriteLengthPropertyIfSupported, stringTrim, stringStartsWith, parseJson, useSymbols, createSymbolOrString, toggleDomNodeCssClass, registerEventHandler, triggerEvent, domNodeIsContainedBy, domNodeIsAttachedToDocument, anyDomNodeIsAttachedToDocument, tagNameLower, isDomElement, isDocumentFragment, moveCleanedNodesToContainerElement, cloneNodes, setDomNodeChildren, replaceDomNodes, setElementName, emptyDomNode, fixUpContinuousNodeArray, setOptionNodeSelectionState, forceRefresh, ensureSelectElementIsRenderedCorrectly, parseHtmlFragment, parseHtmlForTemplateNodes, setHtml, setTextContent, addDisposeCallback, removeDisposeCallback, cleanNode, removeNode, otherNodeCleanerFunctions, addCleaner, removeCleaner, cleanjQueryData, selectExtensions };\n//# sourceMappingURL=tko.utils.js.map\n","/*!\n * TKO subscribables and observables 🥊 tko.observable@4.0.0-alpha5c\n * (c) The Knockout.js Team - https://tko.io/\n * License: MIT (http://www.opensource.org/licenses/mit-license.php)\n */\n\nimport { tasks, removeDisposeCallback, addDisposeCallback, options, objectForEach, throttle, debounce, arrayRemoveItem, overwriteLengthPropertyIfSupported, extend, compareArrays, findMovesInArrayComparison, arrayIndexOf, arrayForEach } from 'tko.utils';\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n\r\nfunction __generator(thisArg, body) {\r\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n function verb(n) { return function (v) { return step([n, v]); }; }\r\n function step(op) {\r\n if (f) throw new TypeError(\"Generator is already executing.\");\r\n while (_) try {\r\n if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n if (y = 0, t) op = [op[0] & 2, t.value];\r\n switch (op[0]) {\r\n case 0: case 1: t = op; break;\r\n case 4: _.label++; return { value: op[1], done: false };\r\n case 5: _.label++; y = op[1]; op = [0]; continue;\r\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n default:\r\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n if (t[2]) _.ops.pop();\r\n _.trys.pop(); continue;\r\n }\r\n op = body.call(thisArg, _);\r\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n }\r\n}\r\n\r\nfunction __values(o) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n if (m) return m.call(o);\r\n return {\r\n next: function () {\r\n if (o && i >= o.length) o = void 0;\r\n return { value: o && o[i++], done: !o };\r\n }\r\n };\r\n}\r\n\r\nfunction __read(o, n) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n if (!m) return o;\r\n var i = m.call(o), r, ar = [], e;\r\n try {\r\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n }\r\n catch (error) { e = { error: error }; }\r\n finally {\r\n try {\r\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n }\r\n finally { if (e) throw e.error; }\r\n }\r\n return ar;\r\n}\r\n\r\nfunction __spread() {\r\n for (var ar = [], i = 0; i < arguments.length; i++)\r\n ar = ar.concat(__read(arguments[i]));\r\n return ar;\r\n}\n\n/**\r\n * Create a subscribable symbol that's used to identify subscribables.\r\n */\r\nvar SUBSCRIBABLE_SYM = Symbol('Knockout Subscribable');\r\nfunction isSubscribable(instance) {\r\n return (instance && instance[SUBSCRIBABLE_SYM]) || false;\r\n}\n\n//\r\nvar outerFrames = [];\r\nvar currentFrame;\r\nvar lastId = 0;\r\n// Return a unique ID that can be assigned to an observable for dependency tracking.\r\n// Theoretically, you could eventually overflow the number storage size, resulting\r\n// in duplicate IDs. But in JavaScript, the largest exact integral value is 2^53\r\n// or 9,007,199,254,740,992. If you created 1,000,000 IDs per second, it would\r\n// take over 285 years to reach that number.\r\n// Reference http://blog.vjeux.com/2010/javascript/javascript-max_int-number-limits.html\r\nfunction getId() {\r\n return ++lastId;\r\n}\r\nfunction begin(options$$1) {\r\n outerFrames.push(currentFrame);\r\n currentFrame = options$$1;\r\n}\r\nfunction end() {\r\n currentFrame = outerFrames.pop();\r\n}\r\nfunction registerDependency(subscribable) {\r\n if (currentFrame) {\r\n if (!isSubscribable(subscribable)) {\r\n throw new Error('Only subscribable things can act as dependencies');\r\n }\r\n currentFrame.callback.call(currentFrame.callbackTarget, subscribable, subscribable._id || (subscribable._id = getId()));\r\n }\r\n}\r\nfunction ignore(callback, callbackTarget, callbackArgs) {\r\n try {\r\n begin();\r\n return callback.apply(callbackTarget, callbackArgs || []);\r\n }\r\n finally {\r\n end();\r\n }\r\n}\r\nfunction getDependenciesCount() {\r\n if (currentFrame) {\r\n return currentFrame.computed.getDependenciesCount();\r\n }\r\n}\r\nfunction getDependencies() {\r\n if (currentFrame) {\r\n return currentFrame.computed.getDependencies();\r\n }\r\n}\r\nfunction isInitial() {\r\n if (currentFrame) {\r\n return currentFrame.isInitial;\r\n }\r\n}\n\nvar dependencyDetection = /*#__PURE__*/Object.freeze({\n begin: begin,\n end: end,\n registerDependency: registerDependency,\n ignore: ignore,\n getDependenciesCount: getDependenciesCount,\n getDependencies: getDependencies,\n isInitial: isInitial,\n ignoreDependencies: ignore\n});\n\n//\r\nfunction deferUpdates(target) {\r\n if (target._deferUpdates) {\r\n return;\r\n }\r\n target._deferUpdates = true;\r\n target.limit(function (callback) {\r\n var handle;\r\n var ignoreUpdates = false;\r\n return function () {\r\n if (!ignoreUpdates) {\r\n tasks.cancel(handle);\r\n handle = tasks.schedule(callback);\r\n try {\r\n ignoreUpdates = true;\r\n target.notifySubscribers(undefined, 'dirty');\r\n }\r\n finally {\r\n ignoreUpdates = false;\r\n }\r\n }\r\n };\r\n });\r\n}\n\nvar Subscription = /** @class */ (function () {\r\n function Subscription(target, observer, disposeCallback) {\r\n this._target = target;\r\n this._callback = observer.next;\r\n this._disposeCallback = disposeCallback;\r\n this._isDisposed = false;\r\n this._domNodeDisposalCallback = null;\r\n }\r\n Subscription.prototype.dispose = function () {\r\n if (this._domNodeDisposalCallback) {\r\n removeDisposeCallback(this._node, this._domNodeDisposalCallback);\r\n }\r\n this._isDisposed = true;\r\n this._disposeCallback();\r\n };\r\n Subscription.prototype.disposeWhenNodeIsRemoved = function (node) {\r\n this._node = node;\r\n addDisposeCallback(node, this._domNodeDisposalCallback = this.dispose.bind(this));\r\n };\r\n // TC39 Observable API\r\n Subscription.prototype.unsubscribe = function () { this.dispose(); };\r\n Object.defineProperty(Subscription.prototype, \"closed\", {\r\n get: function () { return this._isDisposed; },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n return Subscription;\r\n}());\n\n//\r\nvar primitiveTypes = {\r\n 'undefined': 1, 'boolean': 1, 'number': 1, 'string': 1\r\n};\r\nfunction valuesArePrimitiveAndEqual(a, b) {\r\n var oldValueIsPrimitive = (a === null) || (typeof (a) in primitiveTypes);\r\n return oldValueIsPrimitive ? (a === b) : false;\r\n}\r\nfunction applyExtenders(requestedExtenders) {\r\n var target = this;\r\n if (requestedExtenders) {\r\n objectForEach(requestedExtenders, function (key, value) {\r\n var extenderHandler = extenders[key];\r\n if (typeof extenderHandler === 'function') {\r\n target = extenderHandler(target, value) || target;\r\n }\r\n else {\r\n options.onError(new Error('Extender not found: ' + key));\r\n }\r\n });\r\n }\r\n return target;\r\n}\r\n/*\r\n --- DEFAULT EXTENDERS ---\r\n */\r\n// Change when notifications are published.\r\nfunction notify(target, notifyWhen) {\r\n target.equalityComparer = notifyWhen == 'always'\r\n ? null // null equalityComparer means to always notify\r\n : valuesArePrimitiveAndEqual;\r\n}\r\nfunction deferred(target, option) {\r\n if (option !== true) {\r\n throw new Error('The \\'deferred\\' extender only accepts the value \\'true\\', because it is not supported to turn deferral off once enabled.');\r\n }\r\n deferUpdates(target);\r\n}\r\nfunction rateLimit(target, options$$1) {\r\n var timeout, method, limitFunction;\r\n if (typeof options$$1 === 'number') {\r\n timeout = options$$1;\r\n }\r\n else {\r\n timeout = options$$1.timeout;\r\n method = options$$1.method;\r\n }\r\n // rateLimit supersedes deferred updates\r\n target._deferUpdates = false;\r\n limitFunction = method === 'notifyWhenChangesStop' ? debounce : throttle;\r\n target.limit(function (callback) {\r\n return limitFunction(callback, timeout);\r\n });\r\n}\r\nvar extenders = {\r\n notify: notify,\r\n deferred: deferred,\r\n rateLimit: rateLimit\r\n};\n\nvar _a;\r\n// Descendants may have a LATEST_VALUE, which if present\r\n// causes TC39 subscriptions to emit the latest value when\r\n// subscribed.\r\nvar LATEST_VALUE = Symbol('Knockout latest value');\r\nfunction subscribable() {\r\n Object.setPrototypeOf(this, ko_subscribable_fn);\r\n ko_subscribable_fn.init(this);\r\n}\r\nvar defaultEvent = 'change';\r\nvar ko_subscribable_fn = (_a = {},\r\n _a[SUBSCRIBABLE_SYM] = true,\r\n _a[Symbol.observable] = function () { return this; },\r\n _a.init = function (instance) {\r\n instance._subscriptions = { change: [] };\r\n instance._versionNumber = 1;\r\n },\r\n _a.subscribe = function (callback, callbackTarget, event) {\r\n var _this = this;\r\n // TC39 proposed standard Observable { next: () => ... }\r\n var isTC39Callback = typeof callback === 'object' && callback.next;\r\n event = event || defaultEvent;\r\n var observer = isTC39Callback ? callback : {\r\n next: callbackTarget ? callback.bind(callbackTarget) : callback\r\n };\r\n var subscriptionInstance = new Subscription(this, observer, function () {\r\n arrayRemoveItem(_this._subscriptions[event], subscriptionInstance);\r\n if (_this.afterSubscriptionRemove) {\r\n _this.afterSubscriptionRemove(event);\r\n }\r\n });\r\n if (this.beforeSubscriptionAdd) {\r\n this.beforeSubscriptionAdd(event);\r\n }\r\n if (!this._subscriptions[event]) {\r\n this._subscriptions[event] = [];\r\n }\r\n this._subscriptions[event].push(subscriptionInstance);\r\n // Have TC39 `subscribe` immediately emit.\r\n // https://github.com/tc39/proposal-observable/issues/190\r\n if (isTC39Callback && LATEST_VALUE in this) {\r\n observer.next(this[LATEST_VALUE]);\r\n }\r\n return subscriptionInstance;\r\n },\r\n _a.notifySubscribers = function (valueToNotify, event) {\r\n event = event || defaultEvent;\r\n if (event === defaultEvent) {\r\n this.updateVersion();\r\n }\r\n if (this.hasSubscriptionsForEvent(event)) {\r\n var subs = event === defaultEvent && this._changeSubscriptions\r\n || __spread(this._subscriptions[event]);\r\n try {\r\n begin(); // Begin suppressing dependency detection (by setting the top frame to undefined)\r\n for (var i = 0, subscriptionInstance = void 0; subscriptionInstance = subs[i]; ++i) {\r\n // In case a subscription was disposed during the arrayForEach cycle, check\r\n // for isDisposed on each subscription before invoking its callback\r\n if (!subscriptionInstance._isDisposed) {\r\n subscriptionInstance._callback(valueToNotify);\r\n }\r\n }\r\n }\r\n finally {\r\n end(); // End suppressing dependency detection\r\n }\r\n }\r\n },\r\n _a.getVersion = function () {\r\n return this._versionNumber;\r\n },\r\n _a.hasChanged = function (versionToCheck) {\r\n return this.getVersion() !== versionToCheck;\r\n },\r\n _a.updateVersion = function () {\r\n ++this._versionNumber;\r\n },\r\n _a.hasSubscriptionsForEvent = function (event) {\r\n return this._subscriptions[event] && this._subscriptions[event].length;\r\n },\r\n _a.getSubscriptionsCount = function (event) {\r\n if (event) {\r\n return this._subscriptions[event] && this._subscriptions[event].length || 0;\r\n }\r\n else {\r\n var total = 0;\r\n objectForEach(this._subscriptions, function (eventName, subscriptions) {\r\n if (eventName !== 'dirty') {\r\n total += subscriptions.length;\r\n }\r\n });\r\n return total;\r\n }\r\n },\r\n _a.isDifferent = function (oldValue, newValue) {\r\n return !this.equalityComparer ||\r\n !this.equalityComparer(oldValue, newValue);\r\n },\r\n _a.once = function (cb) {\r\n var subs = this.subscribe(function (nv) {\r\n subs.dispose();\r\n cb(nv);\r\n });\r\n },\r\n _a.when = function (test, returnValue) {\r\n var _this = this;\r\n var current = this.peek();\r\n var givenRv = arguments.length > 1;\r\n var testFn = typeof test === 'function' ? test : function (v) { return v === test; };\r\n if (testFn(current)) {\r\n return options.Promise.resolve(givenRv ? returnValue : current);\r\n }\r\n return new options.Promise(function (resolve, reject) {\r\n var subs = _this.subscribe(function (newValue) {\r\n if (testFn(newValue)) {\r\n subs.dispose();\r\n resolve(givenRv ? returnValue : newValue);\r\n }\r\n });\r\n });\r\n },\r\n _a.yet = function (test) {\r\n var args = [];\r\n for (var _i = 1; _i < arguments.length; _i++) {\r\n args[_i - 1] = arguments[_i];\r\n }\r\n var testFn = typeof test === 'function' ? test : function (v) { return v === test; };\r\n var negated = function (v) { return !testFn(v); };\r\n return this.when.apply(this, __spread([negated], args));\r\n },\r\n _a.next = function () {\r\n var _this = this;\r\n return new Promise(function (resolve) { return _this.once(resolve); });\r\n },\r\n _a.toString = function () { return '[object Object]'; },\r\n _a.extend = applyExtenders,\r\n _a);\r\n// For browsers that support proto assignment, we overwrite the prototype of each\r\n// observable instance. Since observables are functions, we need Function.prototype\r\n// to still be in the prototype chain.\r\nObject.setPrototypeOf(ko_subscribable_fn, Function.prototype);\r\nsubscribable.fn = ko_subscribable_fn;\n\nfunction observable(initialValue) {\r\n function Observable() {\r\n if (arguments.length > 0) {\r\n // Write\r\n // Ignore writes if the value hasn't changed\r\n if (Observable.isDifferent(Observable[LATEST_VALUE], arguments[0])) {\r\n Observable.valueWillMutate();\r\n Observable[LATEST_VALUE] = arguments[0];\r\n Observable.valueHasMutated();\r\n }\r\n return this; // Permits chained assignments\r\n }\r\n else {\r\n // Read\r\n registerDependency(Observable); // The caller only needs to be notified of changes if they did a \"read\" operation\r\n return Observable[LATEST_VALUE];\r\n }\r\n }\r\n overwriteLengthPropertyIfSupported(Observable, { value: undefined });\r\n Observable[LATEST_VALUE] = initialValue;\r\n subscribable.fn.init(Observable);\r\n // Inherit from 'observable'\r\n Object.setPrototypeOf(Observable, observable.fn);\r\n if (options.deferUpdates) {\r\n deferUpdates(Observable);\r\n }\r\n return Observable;\r\n}\r\n// Define prototype for observables\r\nobservable.fn = {\r\n equalityComparer: valuesArePrimitiveAndEqual,\r\n peek: function () { return this[LATEST_VALUE]; },\r\n valueHasMutated: function () {\r\n this.notifySubscribers(this[LATEST_VALUE], 'spectate');\r\n this.notifySubscribers(this[LATEST_VALUE]);\r\n },\r\n valueWillMutate: function () {\r\n this.notifySubscribers(this[LATEST_VALUE], 'beforeChange');\r\n },\r\n // Some observables may not always be writeable, notably computeds.\r\n isWriteable: true\r\n};\r\n// Moved out of \"limit\" to avoid the extra closure\r\nfunction limitNotifySubscribers(value, event) {\r\n if (!event || event === defaultEvent) {\r\n this._limitChange(value);\r\n }\r\n else if (event === 'beforeChange') {\r\n this._limitBeforeChange(value);\r\n }\r\n else {\r\n this._origNotifySubscribers(value, event);\r\n }\r\n}\r\n// Add `limit` function to the subscribable prototype\r\nsubscribable.fn.limit = function limit(limitFunction) {\r\n var self = this;\r\n var selfIsObservable = isObservable(self);\r\n var beforeChange = 'beforeChange';\r\n var ignoreBeforeChange, notifyNextChange, previousValue, pendingValue, didUpdate;\r\n if (!self._origNotifySubscribers) {\r\n self._origNotifySubscribers = self.notifySubscribers;\r\n self.notifySubscribers = limitNotifySubscribers;\r\n }\r\n var finish = limitFunction(function () {\r\n self._notificationIsPending = false;\r\n // If an observable provided a reference to itself, access it to get the latest value.\r\n // This allows computed observables to delay calculating their value until needed.\r\n if (selfIsObservable && pendingValue === self) {\r\n pendingValue = self._evalIfChanged ? self._evalIfChanged() : self();\r\n }\r\n var shouldNotify = notifyNextChange || (didUpdate && self.isDifferent(previousValue, pendingValue));\r\n self._notifyNextChange = didUpdate = ignoreBeforeChange = false;\r\n if (shouldNotify) {\r\n self._origNotifySubscribers(previousValue = pendingValue);\r\n }\r\n });\r\n Object.assign(self, {\r\n _limitChange: function (value, isDirty) {\r\n if (!isDirty || !self._notificationIsPending) {\r\n didUpdate = !isDirty;\r\n }\r\n self._changeSubscriptions = __spread(self._subscriptions[defaultEvent]);\r\n self._notificationIsPending = ignoreBeforeChange = true;\r\n pendingValue = value;\r\n finish();\r\n },\r\n _limitBeforeChange: function (value) {\r\n if (!ignoreBeforeChange) {\r\n previousValue = value;\r\n self._origNotifySubscribers(value, beforeChange);\r\n }\r\n },\r\n _notifyNextChangeIfValueIsDifferent: function () {\r\n if (self.isDifferent(previousValue, self.peek(true /* evaluate */))) {\r\n notifyNextChange = true;\r\n }\r\n },\r\n _recordUpdate: function () {\r\n didUpdate = true;\r\n }\r\n });\r\n};\r\nObject.setPrototypeOf(observable.fn, subscribable.fn);\r\nvar protoProperty = observable.protoProperty = options.protoProperty;\r\nobservable.fn[protoProperty] = observable;\r\n// Subclasses can add themselves to observableProperties so that\r\n// isObservable will be `true`.\r\nobservable.observablePrototypes = new Set([observable]);\r\nfunction isObservable(instance) {\r\n var proto = typeof instance === 'function' && instance[protoProperty];\r\n if (proto && !observable.observablePrototypes.has(proto)) {\r\n throw Error('Invalid object that looks like an observable; possibly from another Knockout instance');\r\n }\r\n return !!proto;\r\n}\r\nfunction unwrap(value) {\r\n return isObservable(value) ? value() : value;\r\n}\r\nfunction peek(value) {\r\n return isObservable(value) ? value.peek() : value;\r\n}\r\nfunction isWriteableObservable(instance) {\r\n return isObservable(instance) && instance.isWriteable;\r\n}\n\n//\r\nvar arrayChangeEventName = 'arrayChange';\r\nfunction trackArrayChanges(target, options$$1) {\r\n // Use the provided options--each call to trackArrayChanges overwrites the previously set options\r\n target.compareArrayOptions = {};\r\n if (options$$1 && typeof options$$1 === 'object') {\r\n extend(target.compareArrayOptions, options$$1);\r\n }\r\n target.compareArrayOptions.sparse = true;\r\n // Only modify the target observable once\r\n if (target.cacheDiffForKnownOperation) {\r\n return;\r\n }\r\n var trackingChanges = false;\r\n var cachedDiff = null;\r\n var arrayChangeSubscription;\r\n var pendingNotifications = 0;\r\n var underlyingNotifySubscribersFunction;\r\n var underlyingBeforeSubscriptionAddFunction = target.beforeSubscriptionAdd;\r\n var underlyingAfterSubscriptionRemoveFunction = target.afterSubscriptionRemove;\r\n // Watch \"subscribe\" calls, and for array change events, ensure change tracking is enabled\r\n target.beforeSubscriptionAdd = function (event) {\r\n if (underlyingBeforeSubscriptionAddFunction) {\r\n underlyingBeforeSubscriptionAddFunction.call(target, event);\r\n }\r\n if (event === arrayChangeEventName) {\r\n trackChanges();\r\n }\r\n };\r\n // Watch \"dispose\" calls, and for array change events, ensure change tracking is disabled when all are disposed\r\n target.afterSubscriptionRemove = function (event) {\r\n if (underlyingAfterSubscriptionRemoveFunction) {\r\n underlyingAfterSubscriptionRemoveFunction.call(target, event);\r\n }\r\n if (event === arrayChangeEventName && !target.hasSubscriptionsForEvent(arrayChangeEventName)) {\r\n if (underlyingNotifySubscribersFunction) {\r\n target.notifySubscribers = underlyingNotifySubscribersFunction;\r\n underlyingNotifySubscribersFunction = undefined;\r\n }\r\n if (arrayChangeSubscription) {\r\n arrayChangeSubscription.dispose();\r\n }\r\n arrayChangeSubscription = null;\r\n trackingChanges = false;\r\n }\r\n };\r\n function trackChanges() {\r\n // Calling 'trackChanges' multiple times is the same as calling it once\r\n if (trackingChanges) {\r\n return;\r\n }\r\n trackingChanges = true;\r\n // Intercept \"notifySubscribers\" to track how many times it was called.\r\n underlyingNotifySubscribersFunction = target['notifySubscribers'];\r\n target['notifySubscribers'] = function (valueToNotify, event) {\r\n if (!event || event === defaultEvent) {\r\n ++pendingNotifications;\r\n }\r\n return underlyingNotifySubscribersFunction.apply(this, arguments);\r\n };\r\n // Each time the array changes value, capture a clone so that on the next\r\n // change it's possible to produce a diff\r\n var previousContents = [].concat(target.peek() || []);\r\n cachedDiff = null;\r\n arrayChangeSubscription = target.subscribe(function (currentContents) {\r\n // Make a copy of the current contents and ensure it's an array\r\n currentContents = [].concat(currentContents || []);\r\n // Compute the diff and issue notifications, but only if someone is listening\r\n if (target.hasSubscriptionsForEvent(arrayChangeEventName)) {\r\n var changes = getChanges(previousContents, currentContents);\r\n }\r\n // Eliminate references to the old, removed items, so they can be GCed\r\n previousContents = currentContents;\r\n cachedDiff = null;\r\n pendingNotifications = 0;\r\n if (changes && changes.length) {\r\n target['notifySubscribers'](changes, arrayChangeEventName);\r\n }\r\n });\r\n }\r\n function getChanges(previousContents, currentContents) {\r\n // We try to re-use cached diffs.\r\n // The scenarios where pendingNotifications > 1 are when using rate-limiting or the Deferred Updates\r\n // plugin, which without this check would not be compatible with arrayChange notifications. Normally,\r\n // notifications are issued immediately so we wouldn't be queueing up more than one.\r\n if (!cachedDiff || pendingNotifications > 1) {\r\n cachedDiff = trackArrayChanges.compareArrays(previousContents, currentContents, target.compareArrayOptions);\r\n }\r\n return cachedDiff;\r\n }\r\n target.cacheDiffForKnownOperation = function (rawArray, operationName, args) {\r\n var index, argsIndex;\r\n // Only run if we're currently tracking changes for this observable array\r\n // and there aren't any pending deferred notifications.\r\n if (!trackingChanges || pendingNotifications) {\r\n return;\r\n }\r\n var diff = [], arrayLength = rawArray.length, argsLength = args.length, offset = 0;\r\n function pushDiff(status, value, index) {\r\n return diff[diff.length] = { 'status': status, 'value': value, 'index': index };\r\n }\r\n switch (operationName) {\r\n case 'push':\r\n offset = arrayLength;\r\n case 'unshift':\r\n for (index = 0; index < argsLength; index++) {\r\n pushDiff('added', args[index], offset + index);\r\n }\r\n break;\r\n case 'pop':\r\n offset = arrayLength - 1;\r\n case 'shift':\r\n if (arrayLength) {\r\n pushDiff('deleted', rawArray[offset], offset);\r\n }\r\n break;\r\n case 'splice':\r\n // Negative start index means 'from end of array'. After that we clamp to [0...arrayLength].\r\n // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice\r\n 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 = [];\r\n for (index = startIndex, argsIndex = 2; index < endIndex; ++index, ++argsIndex) {\r\n if (index < endDeleteIndex) {\r\n deletions.push(pushDiff('deleted', rawArray[index], index));\r\n }\r\n if (index < endAddIndex) {\r\n additions.push(pushDiff('added', args[argsIndex], index));\r\n }\r\n }\r\n findMovesInArrayComparison(deletions, additions);\r\n break;\r\n default:\r\n return;\r\n }\r\n cachedDiff = diff;\r\n };\r\n}\r\n// Expose compareArrays for testing.\r\ntrackArrayChanges.compareArrays = compareArrays;\r\n// Add the trackArrayChanges extender so we can use\r\n// obs.extend({ trackArrayChanges: true })\r\nextenders.trackArrayChanges = trackArrayChanges;\n\nvar _a$1;\r\nfunction observableArray(initialValues) {\r\n initialValues = initialValues || [];\r\n if (typeof initialValues !== 'object' || !('length' in initialValues)) {\r\n throw new Error('The argument passed when initializing an observable array must be an array, or null, or undefined.');\r\n }\r\n var result = observable(initialValues);\r\n Object.setPrototypeOf(result, observableArray.fn);\r\n trackArrayChanges(result);\r\n // ^== result.extend({ trackArrayChanges: true })\r\n overwriteLengthPropertyIfSupported(result, { get: function () { return result().length; } });\r\n return result;\r\n}\r\nfunction isObservableArray(instance) {\r\n return isObservable(instance) && typeof instance.remove === 'function' && typeof instance.push === 'function';\r\n}\r\nobservableArray.fn = (_a$1 = {\r\n remove: function (valueOrPredicate) {\r\n var underlyingArray = this.peek();\r\n var removedValues = [];\r\n var predicate = typeof valueOrPredicate === 'function' && !isObservable(valueOrPredicate) ? valueOrPredicate : function (value) { return value === valueOrPredicate; };\r\n for (var i = 0; i < underlyingArray.length; i++) {\r\n var value = underlyingArray[i];\r\n if (predicate(value)) {\r\n if (removedValues.length === 0) {\r\n this.valueWillMutate();\r\n }\r\n if (underlyingArray[i] !== value) {\r\n throw Error(\"Array modified during remove; cannot remove item\");\r\n }\r\n removedValues.push(value);\r\n underlyingArray.splice(i, 1);\r\n i--;\r\n }\r\n }\r\n if (removedValues.length) {\r\n this.valueHasMutated();\r\n }\r\n return removedValues;\r\n },\r\n removeAll: function (arrayOfValues) {\r\n // If you passed zero args, we remove everything\r\n if (arrayOfValues === undefined) {\r\n var underlyingArray = this.peek();\r\n var allValues = underlyingArray.slice(0);\r\n this.valueWillMutate();\r\n underlyingArray.splice(0, underlyingArray.length);\r\n this.valueHasMutated();\r\n return allValues;\r\n }\r\n // If you passed an arg, we interpret it as an array of entries to remove\r\n if (!arrayOfValues) {\r\n return [];\r\n }\r\n return this['remove'](function (value) {\r\n return arrayIndexOf(arrayOfValues, value) >= 0;\r\n });\r\n },\r\n destroy: function (valueOrPredicate) {\r\n var underlyingArray = this.peek();\r\n var predicate = typeof valueOrPredicate === 'function' && !isObservable(valueOrPredicate) ? valueOrPredicate : function (value) { return value === valueOrPredicate; };\r\n this.valueWillMutate();\r\n for (var i = underlyingArray.length - 1; i >= 0; i--) {\r\n var value = underlyingArray[i];\r\n if (predicate(value)) {\r\n value['_destroy'] = true;\r\n }\r\n }\r\n this.valueHasMutated();\r\n },\r\n destroyAll: function (arrayOfValues) {\r\n // If you passed zero args, we destroy everything\r\n if (arrayOfValues === undefined) {\r\n return this.destroy(function () { return true; });\r\n }\r\n // If you passed an arg, we interpret it as an array of entries to destroy\r\n if (!arrayOfValues) {\r\n return [];\r\n }\r\n return this.destroy(function (value) {\r\n return arrayIndexOf(arrayOfValues, value) >= 0;\r\n });\r\n },\r\n indexOf: function (item) {\r\n return arrayIndexOf(this(), item);\r\n },\r\n replace: function (oldItem, newItem) {\r\n var index = this.indexOf(oldItem);\r\n if (index >= 0) {\r\n this.valueWillMutate();\r\n this.peek()[index] = newItem;\r\n this.valueHasMutated();\r\n }\r\n },\r\n sorted: function (compareFn) {\r\n return __spread(this()).sort(compareFn);\r\n },\r\n reversed: function () {\r\n return __spread(this()).reverse();\r\n }\r\n },\r\n _a$1[Symbol.iterator] = function () {\r\n return __generator(this, function (_a) {\r\n switch (_a.label) {\r\n case 0: return [5 /*yield**/, __values(this())];\r\n case 1:\r\n _a.sent();\r\n return [2 /*return*/];\r\n }\r\n });\r\n },\r\n _a$1);\r\nObject.setPrototypeOf(observableArray.fn, observable.fn);\r\n// Populate ko.observableArray.fn with read/write functions from native arrays\r\n// Important: Do not add any additional functions here that may reasonably be used to *read* data from the array\r\n// because we'll eval them without causing subscriptions, so ko.computed output could end up getting stale\r\narrayForEach(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function (methodName) {\r\n observableArray.fn[methodName] = function () {\r\n // Use \"peek\" to avoid creating a subscription in any computed that we're executing in the context of\r\n // (for consistency with mutating regular observables)\r\n var underlyingArray = this.peek();\r\n this.valueWillMutate();\r\n this.cacheDiffForKnownOperation(underlyingArray, methodName, arguments);\r\n var methodCallResult = underlyingArray[methodName].apply(underlyingArray, arguments);\r\n this.valueHasMutated();\r\n // The native sort and reverse methods return a reference to the array, but it makes more sense to return the observable array instead.\r\n return methodCallResult === underlyingArray ? this : methodCallResult;\r\n };\r\n});\r\n// Populate ko.observableArray.fn with read-only functions from native arrays\r\narrayForEach(['slice'], function (methodName) {\r\n observableArray.fn[methodName] = function () {\r\n var underlyingArray = this();\r\n return underlyingArray[methodName].apply(underlyingArray, arguments);\r\n };\r\n});\r\n// Expose for testing.\r\nobservableArray.trackArrayChanges = trackArrayChanges;\n\n//\r\nvar maxNestedObservableDepth = 10; // Escape the (unlikely) pathological case where an observable's current value is itself (or similar reference cycle)\r\nfunction toJS(rootObject) {\r\n if (arguments.length == 0) {\r\n throw new Error('When calling ko.toJS, pass the object you want to convert.');\r\n }\r\n // We just unwrap everything at every level in the object graph\r\n return mapJsObjectGraph(rootObject, function (valueToMap) {\r\n // Loop because an observable's value might in turn be another observable wrapper\r\n for (var i = 0; isObservable(valueToMap) && (i < maxNestedObservableDepth); i++) {\r\n valueToMap = valueToMap();\r\n }\r\n return valueToMap;\r\n });\r\n}\r\nfunction toJSON(rootObject, replacer, space) {\r\n var plainJavaScriptObject = toJS(rootObject);\r\n return JSON.stringify(plainJavaScriptObject, replacer, space);\r\n}\r\nfunction mapJsObjectGraph(rootObject, mapInputCallback, visitedObjects) {\r\n visitedObjects = visitedObjects || new objectLookup();\r\n rootObject = mapInputCallback(rootObject);\r\n var canHaveProperties = (typeof rootObject === 'object') && (rootObject !== null) && (rootObject !== undefined) && (!(rootObject instanceof RegExp)) && (!(rootObject instanceof Date)) && (!(rootObject instanceof String)) && (!(rootObject instanceof Number)) && (!(rootObject instanceof Boolean));\r\n if (!canHaveProperties) {\r\n return rootObject;\r\n }\r\n var outputProperties = rootObject instanceof Array ? [] : {};\r\n visitedObjects.save(rootObject, outputProperties);\r\n visitPropertiesOrArrayEntries(rootObject, function (indexer) {\r\n var propertyValue = mapInputCallback(rootObject[indexer]);\r\n switch (typeof propertyValue) {\r\n case 'boolean':\r\n case 'number':\r\n case 'string':\r\n case 'function':\r\n outputProperties[indexer] = propertyValue;\r\n break;\r\n case 'object':\r\n case 'undefined':\r\n var previouslyMappedValue = visitedObjects.get(propertyValue);\r\n outputProperties[indexer] = (previouslyMappedValue !== undefined)\r\n ? previouslyMappedValue\r\n : mapJsObjectGraph(propertyValue, mapInputCallback, visitedObjects);\r\n break;\r\n }\r\n });\r\n return outputProperties;\r\n}\r\nfunction visitPropertiesOrArrayEntries(rootObject, visitorCallback) {\r\n if (rootObject instanceof Array) {\r\n for (var i = 0; i < rootObject.length; i++) {\r\n visitorCallback(i);\r\n }\r\n // For arrays, also respect toJSON property for custom mappings (fixes #278)\r\n if (typeof rootObject['toJSON'] === 'function') {\r\n visitorCallback('toJSON');\r\n }\r\n }\r\n else {\r\n for (var propertyName in rootObject) {\r\n visitorCallback(propertyName);\r\n }\r\n }\r\n}\r\nfunction objectLookup() {\r\n this.keys = [];\r\n this.values = [];\r\n}\r\nobjectLookup.prototype = {\r\n constructor: objectLookup,\r\n save: function (key, value) {\r\n var existingIndex = arrayIndexOf(this.keys, key);\r\n if (existingIndex >= 0) {\r\n this.values[existingIndex] = value;\r\n }\r\n else {\r\n this.keys.push(key);\r\n this.values.push(value);\r\n }\r\n },\r\n get: function (key) {\r\n var existingIndex = arrayIndexOf(this.keys, key);\r\n return (existingIndex >= 0) ? this.values[existingIndex] : undefined;\r\n }\r\n};\n\n//\n\nexport { dependencyDetection, observable, isObservable, unwrap, peek, isWriteableObservable, isWriteableObservable as isWritableObservable, isSubscribable, subscribable, LATEST_VALUE, observableArray, isObservableArray, trackArrayChanges, arrayChangeEventName, toJS, toJSON, deferUpdates, valuesArePrimitiveAndEqual, applyExtenders, extenders };\n//# sourceMappingURL=tko.observable.js.map\n","/*!\n * Parse the Javascript-like language used in data-bind and other HTML attributes (CSP-safe) 🥊 tko.utils.parser@4.0.0-alpha5c\n * (c) The Knockout.js Team - https://tko.io/\n * License: MIT (http://www.opensource.org/licenses/mit-license.php)\n */\n\nimport { unwrap, isWriteableObservable, isObservable } from 'tko.observable';\nimport { hasOwnProperty, options, objectForEach, clonePlainObjectDeep, extend, stringTrim } from 'tko.utils';\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n\r\nfunction __read(o, n) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n if (!m) return o;\r\n var i = m.call(o), r, ar = [], e;\r\n try {\r\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n }\r\n catch (error) { e = { error: error }; }\r\n finally {\r\n try {\r\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n }\r\n finally { if (e) throw e.error; }\r\n }\r\n return ar;\r\n}\r\n\r\nfunction __spread() {\r\n for (var ar = [], i = 0; i < arguments.length; i++)\r\n ar = ar.concat(__read(arguments[i]));\r\n return ar;\r\n}\n\nfunction LAMBDA() { }\r\n/**\r\n * @ operator - recursively call the identifier if it's a function\r\n * @param {operand} a ignored\r\n * @param {operand} b The variable to be called (if a function) and unwrapped\r\n * @return {value} The result.\r\n */\r\nfunction unwrapOrCall(a, b) {\r\n while (typeof b === 'function') {\r\n b = b();\r\n }\r\n return b;\r\n}\r\nvar operators = {\r\n // unary\r\n '@': unwrapOrCall,\r\n '#': function (a, b) { return function () { return unwrap(b); }; },\r\n '=>': LAMBDA,\r\n '!': function not(a, b) { return !b; },\r\n '!!': function notnot(a, b) { return !!b; },\r\n '++': function preinc(a, b) { return ++b; },\r\n '--': function preinc(a, b) { return --b; },\r\n // mul/div\r\n '*': function mul(a, b) { return a * b; },\r\n '/': function div(a, b) { return a / b; },\r\n '%': function mod(a, b) { return a % b; },\r\n // sub/add\r\n '+': function add(a, b) { return a + b; },\r\n '-': function sub(a, b) { return (a || 0) - (b || 0); },\r\n '&-': function neg(a, b) { return -1 * b; },\r\n // relational\r\n '<': function lt(a, b) { return a < b; },\r\n '<=': function le(a, b) { return a <= b; },\r\n '>': function gt(a, b) { return a > b; },\r\n '>=': function ge(a, b) { return a >= b; },\r\n // TODO: 'in': function (a, b) { return a in b; },\r\n // TODO: 'instanceof': function (a, b) { return a instanceof b; },\r\n // equality\r\n '==': function equal(a, b) { return a === b; },\r\n '!=': function ne(a, b) { return a !== b; },\r\n '===': function sequal(a, b) { return a === b; },\r\n '!==': function sne(a, b) { return a !== b; },\r\n // bitwise\r\n '&': function bitAnd(a, b) { return a & b; },\r\n '^': function xor(a, b) { return a ^ b; },\r\n '|': function bitOr(a, b) { return a | b; },\r\n // logic\r\n '&&': function logicAnd(a, b) { return a && b; },\r\n '||': function logicOr(a, b) { return a || b; },\r\n // Access\r\n '.': function member(a, b) { return a[b]; },\r\n '[': function member(a, b) { return a[b]; },\r\n // conditional/ternary\r\n // '?': ternary See Node.js\r\n // Function-Call\r\n 'call': function callOp(a, b) { return a.apply(null, b); }\r\n};\r\n/* Order of precedence from:\r\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table\r\n*/\r\n// Our operator - unwrap/call\r\noperators['@'].precedence = 21;\r\noperators['#'].precedence = 21;\r\n// lambda\r\noperators['=>'].precedence = 20;\r\n// Member\r\noperators['.'].precedence = 19;\r\noperators['['].precedence = 19;\r\n// Logical not\r\noperators['!'].precedence = 16;\r\noperators['!!'].precedence = 16; // explicit double-negative\r\n// Prefix inc/dec\r\noperators['++'].precedence = 16;\r\noperators['--'].precedence = 16;\r\noperators['&-'].precedence = 16;\r\n// mul/div/remainder\r\noperators['%'].precedence = 14;\r\noperators['*'].precedence = 14;\r\noperators['/'].precedence = 14;\r\n// add/sub\r\noperators['+'].precedence = 13;\r\noperators['-'].precedence = 13;\r\n// bitwise\r\noperators['|'].precedence = 12;\r\noperators['^'].precedence = 11;\r\noperators['&'].precedence = 10;\r\n// comparison\r\noperators['<'].precedence = 11;\r\noperators['<='].precedence = 11;\r\noperators['>'].precedence = 11;\r\noperators['>='].precedence = 11;\r\n// operators['in'].precedence = 8;\r\n// operators['instanceof'].precedence = 8;\r\n// equality\r\noperators['=='].precedence = 10;\r\noperators['!='].precedence = 10;\r\noperators['==='].precedence = 10;\r\noperators['!=='].precedence = 10;\r\n// logic\r\noperators['&&'].precedence = 6;\r\noperators['||'].precedence = 5;\r\noperators['&&'].earlyOut = function (a) { return !a; };\r\noperators['||'].earlyOut = function (a) { return a; };\r\n// Call a function\r\noperators['call'].precedence = 1;\n\nvar IS_EXPR_OR_IDENT = Symbol('Node - Is Expression Or Identifier');\r\nvar Node = /** @class */ (function () {\r\n function Node(lhs, op, rhs) {\r\n this.lhs = lhs;\r\n this.op = op;\r\n this.rhs = rhs;\r\n }\r\n Object.defineProperty(Node, \"operators\", {\r\n get: function () { return operators; },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n Node.prototype.get_leaf_value = function (leaf, context, globals, node) {\r\n if (typeof leaf === 'function') {\r\n // Expressions on observables are nonsensical, so we unwrap any\r\n // function values (e.g. identifiers).\r\n return unwrap(leaf());\r\n }\r\n // primitives\r\n if (typeof leaf !== 'object' || leaf === null) {\r\n return leaf;\r\n }\r\n // Identifiers and Expressions\r\n if (leaf[Node.isExpressionOrIdentifierSymbol]) {\r\n // lhs is passed in as the parent of the leaf. It will be defined in\r\n // cases like a.b.c as 'a' for 'b' then as 'b' for 'c'.\r\n return unwrap(leaf.get_value(undefined, context, globals, node));\r\n }\r\n // Plain object/class.\r\n return leaf;\r\n };\r\n /**\r\n * Return a function that calculates and returns an expression's value\r\n * when called.\r\n * @param {array} ops The operations to perform\r\n * @return {function} The function that calculates the expression.\r\n *\r\n * Note that for a lambda, we do not evaluate the RHS expression until\r\n * the lambda is called.\r\n */\r\n Node.prototype.get_value = function (notused, context, globals, node) {\r\n var node = this;\r\n if (node.op === LAMBDA) {\r\n return function () { return node.get_leaf_value(node.rhs, context, globals, node); };\r\n }\r\n var lhv = node.get_leaf_value(node.lhs, context, globals, node);\r\n var earlyOut = node.op.earlyOut;\r\n if (earlyOut && earlyOut(lhv)) {\r\n return lhv;\r\n }\r\n var rhv = node.get_leaf_value(node.rhs, context, globals, node);\r\n return node.op(lhv, rhv, context, globals);\r\n };\r\n Object.defineProperty(Node, \"isExpressionOrIdentifierSymbol\", {\r\n //\r\n // Class variables.\r\n //\r\n get: function () { return IS_EXPR_OR_IDENT; },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n Object.defineProperty(Node.prototype, IS_EXPR_OR_IDENT, {\r\n get: function () { return true; },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n Node.value_of = function (item, context, globals, node) {\r\n if (item && item[Node.isExpressionOrIdentifierSymbol]) {\r\n return item.get_value(item, context, globals, node);\r\n }\r\n return item;\r\n };\r\n /**\r\n * Convert an array of nodes to an executable tree.\r\n * @return {object} An object with a `lhs`, `rhs` and `op` key, corresponding\r\n * to the left hand side, right hand side, and\r\n * operation function.\r\n */\r\n Node.create_root = function (nodes) {\r\n var root, leaf, op, value;\r\n // Prime the leaf = root node.\r\n leaf = root = new Node(nodes.shift(), nodes.shift(), nodes.shift());\r\n while (true) {\r\n op = nodes.shift();\r\n value = nodes.shift();\r\n if (!op) {\r\n break;\r\n }\r\n if (op.precedence < root.op.precedence) {\r\n // rebase\r\n root = new Node(root, op, value);\r\n leaf = root;\r\n }\r\n else {\r\n leaf.rhs = new Node(leaf.rhs, op, value);\r\n leaf = leaf.rhs;\r\n }\r\n }\r\n // console.log('tree', root)\r\n return root;\r\n };\r\n return Node;\r\n}());\r\n/**\r\n * Because of cyclical dependencies on operators <-> Node <-> value_of,\r\n * we need to patch this in here.\r\n */\r\noperators['?'] = function ternary(a, b, context, globals, node) {\r\n return Node.value_of(a ? b.yes : b.no, context, globals, node);\r\n};\r\noperators['?'].precedence = 4;\n\nvar Expression = /** @class */ (function () {\r\n function Expression(nodes) {\r\n this.nodes = nodes;\r\n this.root = Node.create_root(nodes);\r\n }\r\n /**\r\n * Return the value of `this` Expression instance.\r\n */\r\n Expression.prototype.get_value = function (parent, context, globals, node) {\r\n if (!this.root) {\r\n this.root = Node.create_root(this.nodes);\r\n }\r\n return this.root.get_value(parent, context, globals, node);\r\n };\r\n return Expression;\r\n}());\r\nExpression.prototype[Node.isExpressionOrIdentifierSymbol] = true;\n\nvar Arguments = /** @class */ (function () {\r\n function Arguments(parser, args) {\r\n this.parser = parser;\r\n this.args = args;\r\n }\r\n Arguments.prototype.get_value = function (parent, context, globals, node) {\r\n var deReffedArgs = [];\r\n for (var i = 0, j = this.args.length; i < j; ++i) {\r\n deReffedArgs.push(Node.value_of(this.args[i], context, globals, node));\r\n }\r\n return deReffedArgs;\r\n };\r\n Object.defineProperty(Arguments.prototype, Node.isExpressionOrIdentifierSymbol, {\r\n get: function () { return true; },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n return Arguments;\r\n}());\n\n/**\r\n * The following regular expressions were generated by\r\n * https://mathiasbynens.be/demo/javascript-identifier-regex\r\n */\r\nvar 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]/;\r\nvar 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]/;\n\nvar Identifier = /** @class */ (function () {\r\n function Identifier(parser, token, dereferences) {\r\n this.token = token;\r\n this.dereferences = dereferences;\r\n this.parser = parser;\r\n }\r\n /**\r\n * Apply all () and [] functions on the identifier to the lhs value e.g.\r\n * a()[3] has deref functions that are essentially this:\r\n * [_deref_call, _deref_this where this=3]\r\n *\r\n * @param {mixed} value Should be an object.\r\n * @return {mixed} The dereferenced value.\r\n *\r\n * [1] We want to bind any function that is a method of an object, but not\r\n * corrupt any values (e.g. computed()s). e.g. Running x.bind(obj) where\r\n * we're given `data-bind='binding: obj.x'` and x is a computed will\r\n * break the computed's `this` and it will stop working as expected.\r\n *\r\n * The test `!last_value.hasOwnProperty(member)`\r\n * distinguishes between functions on the prototype chain (prototypal\r\n * members) and value-members added directly to the object. This may\r\n * not be the canonical test for this relationship, but it succeeds\r\n * in the known test cases.\r\n *\r\n * See: `this` tests of our dereference function.\r\n */\r\n Identifier.prototype.dereference = function (value, $context, globals, node) {\r\n var member;\r\n var refs = this.dereferences || [];\r\n var $data = $context.$data || {};\r\n var lastValue; // becomes `this` in function calls to object properties.\r\n var i, n;\r\n for (i = 0, n = refs.length; i < n; ++i) {\r\n member = Node.value_of(refs[i], $context, globals, node);\r\n if (typeof value === 'function' && refs[i] instanceof Arguments) {\r\n // fn(args)\r\n value = value.apply(lastValue || $data, member);\r\n lastValue = value;\r\n }\r\n else {\r\n // obj[x] or obj.x dereference. Note that obj may be a function.\r\n lastValue = value;\r\n value = Node.value_of(value[member], $context, globals, node);\r\n }\r\n }\r\n // [1] See note above.\r\n if (typeof value === 'function' && n > 0 && lastValue !== value &&\r\n !hasOwnProperty(lastValue, member)) {\r\n return value.bind(lastValue);\r\n }\r\n return value;\r\n };\r\n /**\r\n * Return the value as one would get it from the top-level i.e.\r\n * $data.token/$context.token/globals.token; this does not return intermediate\r\n * values on a chain of members i.e. $data.hello.there -- requesting the\r\n * Identifier('there').value will return $data/$context/globals.there.\r\n *\r\n * This will dereference using () or [arg] member.\r\n * @param {object | Identifier | Expression} parent\r\n * @return {mixed} Return the primitive or an accessor.\r\n */\r\n Identifier.prototype.get_value = function (parent, context, globals, node) {\r\n var intermediate = parent && !(parent instanceof Identifier)\r\n ? Node.value_of(parent, context, globals, node)[this.token]\r\n : context.lookup(this.token, globals, node);\r\n return this.dereference(intermediate, context, globals, node);\r\n };\r\n Identifier.prototype.assign = function (object, property, value) {\r\n if (isWriteableObservable(object[property])) {\r\n object[property](value);\r\n }\r\n else if (!isObservable(object[property])) {\r\n object[property] = value;\r\n }\r\n };\r\n /**\r\n * Set the value of the Identifier.\r\n *\r\n * @param {Mixed} new_value The value that Identifier is to be set to.\r\n */\r\n Identifier.prototype.set_value = function (new_value, $context, globals) {\r\n var $data = $context.$data || {};\r\n var refs = this.dereferences || [];\r\n var leaf = this.token;\r\n var i, n, root;\r\n if (hasOwnProperty($data, leaf)) {\r\n root = $data;\r\n }\r\n else if (hasOwnProperty($context, leaf)) {\r\n root = $context;\r\n }\r\n else if (hasOwnProperty(globals, leaf)) {\r\n root = globals;\r\n }\r\n else {\r\n throw new Error('Identifier::set_value -- ' +\r\n \"The property '\" + leaf + \"' does not exist \" +\r\n 'on the $data, $context, or globals.');\r\n }\r\n // Degenerate case. {$data|$context|global}[leaf] = something;\r\n n = refs.length;\r\n if (n === 0) {\r\n this.assign(root, leaf, new_value);\r\n return;\r\n }\r\n // First dereference is {$data|$context|global}[token].\r\n root = root[leaf];\r\n // We cannot use this.dereference because that gives the leaf; to evoke\r\n // the ES5 setter we have to call `obj[leaf] = new_value`\r\n for (i = 0; i < n - 1; ++i) {\r\n leaf = refs[i];\r\n if (leaf instanceof Arguments) {\r\n root = root();\r\n }\r\n else {\r\n root = root[Node.value_of(leaf)];\r\n }\r\n }\r\n // We indicate that a dereference is a function when it is `true`.\r\n if (refs[i] === true) {\r\n throw new Error('Cannot assign a value to a function.');\r\n }\r\n // Call the setter for the leaf.\r\n if (refs[i]) {\r\n this.assign(root, Node.value_of(refs[i]), new_value);\r\n }\r\n };\r\n /**\r\n * Determine if a character is a valid item in an identifier.\r\n * Note that we do not check whether the first item is a number, nor do we\r\n * support unicode identifiers here.\r\n *\r\n * From: http://stackoverflow.com/a/9337047\r\n * @param {String} ch The character\r\n * @return {Boolean} True if this is a valid identifier\r\n */\r\n // function is_identifier_char(ch) {\r\n // return (ch >= 'A' && ch <= 'Z') ||\r\n // (ch >= 'a' && ch <= 'z') ||\r\n // (ch >= '0' && ch <= 9) ||\r\n // ch === '_' || ch === '$';\r\n // }\r\n Identifier.is_valid_start_char = function (ch) {\r\n return IDStart.test(ch);\r\n };\r\n Identifier.is_valid_continue_char = function (ch) {\r\n return IDContinue.test(ch);\r\n };\r\n Object.defineProperty(Identifier.prototype, Node.isExpressionOrIdentifierSymbol, {\r\n get: function () { return true; },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n return Identifier;\r\n}());\n\nvar Ternary = /** @class */ (function () {\r\n function Ternary(yes, no) {\r\n Object.assign(this, { yes: yes, no: no });\r\n }\r\n Ternary.prototype.get_value = function () { return this; };\r\n Object.defineProperty(Ternary.prototype, Node.isExpressionOrIdentifierSymbol, {\r\n get: function () { return true; },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n return Ternary;\r\n}());\n\n/**\r\n * Originally based on (public domain):\r\n * https://github.com/douglascrockford/JSON-js/blob/master/json_parse.js\r\n */\r\nvar escapee = {\r\n \"'\": \"'\",\r\n '\"': '\"',\r\n '`': '`',\r\n '\\\\': '\\\\',\r\n '/': '/',\r\n '$': '$',\r\n b: '\\b',\r\n f: '\\f',\r\n n: '\\n',\r\n r: '\\r',\r\n t: '\\t'\r\n};\r\n/**\r\n * Construct a new Parser instance with new Parser(node, context)\r\n * @param {Node} node The DOM element from which we parsed the\r\n * content.\r\n * @param {object} context The Knockout context.\r\n * @param {object} globals An object containing any desired globals.\r\n */\r\nvar Parser = /** @class */ (function () {\r\n function Parser() {\r\n }\r\n Parser.prototype.white = function () {\r\n var ch = this.ch;\r\n while (ch && ch <= ' ') {\r\n ch = this.next();\r\n }\r\n return this.comment(ch);\r\n };\r\n /**\r\n * Slurp any C or C++ style comments\r\n */\r\n Parser.prototype.comment = function (ch) {\r\n if (ch !== '/') {\r\n return ch;\r\n }\r\n var p = this.at;\r\n var second = this.lookahead();\r\n if (second === '/') {\r\n while (ch) {\r\n ch = this.next();\r\n if (ch === '\\n' || ch === '\\r') {\r\n break;\r\n }\r\n }\r\n ch = this.next();\r\n }\r\n else if (second === '*') {\r\n while (ch) {\r\n ch = this.next();\r\n if (ch === '*' && this.lookahead() === '/') {\r\n this.next();\r\n break;\r\n }\r\n }\r\n if (!ch) {\r\n this.error('Unclosed comment, starting at character ' + p);\r\n }\r\n this.next();\r\n return this.white();\r\n }\r\n return ch;\r\n };\r\n Parser.prototype.next = function (c) {\r\n if (c && c !== this.ch) {\r\n this.error(\"Expected '\" + c + \"' but got '\" + this.ch + \"'\");\r\n }\r\n this.ch = this.text.charAt(this.at);\r\n this.at += 1;\r\n return this.ch;\r\n };\r\n Parser.prototype.lookahead = function () {\r\n return this.text[this.at];\r\n };\r\n Parser.prototype.error = function (m) {\r\n if (m instanceof Error) {\r\n throw m;\r\n }\r\n var _a = __read(m.name ? [m.name, m.message] : [m, ''], 2), name = _a[0], msg = _a[1];\r\n var message = \"\\n\" + name + \" \" + msg + \" of\\n \" + this.text + \"\\n\" + Array(this.at).join(' ') + '_/ 🔥 \\\\_\\n';\r\n throw new Error(message);\r\n };\r\n Parser.prototype.name = function () {\r\n // A name of a binding\r\n var name = '';\r\n var enclosedBy;\r\n this.white();\r\n var ch = this.ch;\r\n if (ch === \"'\" || ch === '\"') {\r\n enclosedBy = ch;\r\n ch = this.next();\r\n }\r\n while (ch) {\r\n if (enclosedBy && ch === enclosedBy) {\r\n this.white();\r\n ch = this.next();\r\n if (ch !== ':' && ch !== ',') {\r\n this.error('Object name: ' + name + ' missing closing ' + enclosedBy);\r\n }\r\n return name;\r\n }\r\n else if (ch === ':' || ch <= ' ' || ch === ',' || ch === '|') {\r\n return name;\r\n }\r\n name += ch;\r\n ch = this.next();\r\n }\r\n return name;\r\n };\r\n Parser.prototype.number = function () {\r\n var number;\r\n var string = '';\r\n var ch = this.ch;\r\n if (ch === '-') {\r\n string = '-';\r\n ch = this.next('-');\r\n }\r\n while (ch >= '0' && ch <= '9') {\r\n string += ch;\r\n ch = this.next();\r\n }\r\n if (ch === '.') {\r\n string += '.';\r\n ch = this.next();\r\n while (ch && ch >= '0' && ch <= '9') {\r\n string += ch;\r\n ch = this.next();\r\n }\r\n }\r\n if (ch === 'e' || ch === 'E') {\r\n string += ch;\r\n ch = this.next();\r\n if (ch === '-' || ch === '+') {\r\n string += ch;\r\n ch = this.next();\r\n }\r\n while (ch >= '0' && ch <= '9') {\r\n string += ch;\r\n ch = this.next();\r\n }\r\n }\r\n number = +string;\r\n if (!isFinite(number)) {\r\n options.onError(new Error('Bad number: ' + number + ' in ' + string));\r\n }\r\n else {\r\n return number;\r\n }\r\n };\r\n /**\r\n * Add a property to 'object' that equals the given value.\r\n * @param {Object} object The object to add the value to.\r\n * @param {String} key object[key] is set to the given value.\r\n * @param {mixed} value The value, may be a primitive or a function. If a\r\n * function it is unwrapped as a property.\r\n */\r\n Parser.prototype.objectAddValue = function (object, key, value) {\r\n var _this = this;\r\n if (value && value[Node.isExpressionOrIdentifierSymbol]) {\r\n Object.defineProperty(object, key, {\r\n get: function () { return Node.value_of.apply(Node, __spread([value], _this.currentContextGlobals)); },\r\n enumerable: true\r\n });\r\n }\r\n else if (Array.isArray(value)) {\r\n Object.defineProperty(object, key, {\r\n get: function () { return value.map(function (v) { return Node.value_of.apply(Node, __spread([v], _this.currentContextGlobals)); }); },\r\n enumerable: true\r\n });\r\n }\r\n else {\r\n // primitives\r\n object[key] = value;\r\n }\r\n };\r\n Parser.prototype.object = function () {\r\n var key;\r\n var object = {};\r\n var ch = this.ch;\r\n if (ch === '{') {\r\n this.next('{');\r\n ch = this.white();\r\n if (ch === '}') {\r\n ch = this.next('}');\r\n return object;\r\n }\r\n while (ch) {\r\n if (ch === '\"' || ch === \"'\" || ch === '`') {\r\n key = this.string();\r\n }\r\n else {\r\n key = this.name();\r\n }\r\n if (hasOwnProperty(object, key)) {\r\n this.error('Duplicate key \"' + key + '\"');\r\n }\r\n if (this.white() === ':') {\r\n ch = this.next(':');\r\n this.objectAddValue(object, key, this.expression());\r\n }\r\n else {\r\n var objectKeyIsValue = new Identifier(this, key, []);\r\n this.objectAddValue(object, key, objectKeyIsValue);\r\n }\r\n ch = this.white();\r\n if (ch === '}') {\r\n ch = this.next('}');\r\n return object;\r\n }\r\n this.next(',');\r\n ch = this.white();\r\n }\r\n }\r\n this.error('Bad object');\r\n };\r\n /**\r\n * Read up to delim and return the string\r\n * @param {string} delim The delimiter, either ' or \"\r\n * @return {string} The string read.\r\n */\r\n Parser.prototype.readString = function (delim) {\r\n var string = '';\r\n var nodes = [''];\r\n var plusOp = operators['+'];\r\n var hex;\r\n var i;\r\n var uffff;\r\n var interpolate = delim === '`';\r\n var ch = this.next();\r\n while (ch) {\r\n if (ch === delim) {\r\n ch = this.next();\r\n if (interpolate) {\r\n nodes.push(plusOp);\r\n }\r\n nodes.push(string);\r\n return nodes;\r\n }\r\n if (ch === '\\\\') {\r\n ch = this.next();\r\n if (ch === 'u') {\r\n uffff = 0;\r\n for (i = 0; i < 4; i += 1) {\r\n hex = parseInt(ch = this.next(), 16);\r\n if (!isFinite(hex)) {\r\n break;\r\n }\r\n uffff = uffff * 16 + hex;\r\n }\r\n string += String.fromCharCode(uffff);\r\n }\r\n else if (typeof escapee[ch] === 'string') {\r\n string += escapee[ch];\r\n }\r\n else {\r\n break;\r\n }\r\n }\r\n else if (interpolate && ch === '$') {\r\n ch = this.next();\r\n if (ch === '{') {\r\n this.next('{');\r\n nodes.push(plusOp);\r\n nodes.push(string);\r\n nodes.push(plusOp);\r\n nodes.push(this.expression());\r\n string = '';\r\n // this.next('}');\r\n }\r\n else {\r\n string += '$' + ch;\r\n }\r\n }\r\n else {\r\n string += ch;\r\n }\r\n ch = this.next();\r\n }\r\n this.error('Bad string');\r\n };\r\n Parser.prototype.string = function () {\r\n var ch = this.ch;\r\n if (ch === '\"') {\r\n return this.readString('\"').join('');\r\n }\r\n else if (ch === \"'\") {\r\n return this.readString(\"'\").join('');\r\n }\r\n else if (ch === '`') {\r\n return Node.create_root(this.readString('`'));\r\n }\r\n this.error('Bad string');\r\n };\r\n Parser.prototype.array = function () {\r\n var array = [];\r\n var ch = this.ch;\r\n if (ch === '[') {\r\n ch = this.next('[');\r\n this.white();\r\n if (ch === ']') {\r\n ch = this.next(']');\r\n return array;\r\n }\r\n while (ch) {\r\n array.push(this.expression());\r\n ch = this.white();\r\n if (ch === ']') {\r\n ch = this.next(']');\r\n return array;\r\n }\r\n this.next(',');\r\n ch = this.white();\r\n }\r\n }\r\n this.error('Bad array');\r\n };\r\n Parser.prototype.value = function () {\r\n var ch;\r\n this.white();\r\n ch = this.ch;\r\n switch (ch) {\r\n case '{': return this.object();\r\n case '[': return this.array();\r\n case '\"':\r\n case \"'\":\r\n case '`': return this.string();\r\n case '-': return this.number();\r\n default:\r\n return ch >= '0' && ch <= '9' ? this.number() : this.identifier();\r\n }\r\n };\r\n /**\r\n * Get the function for the given operator.\r\n * A `.precedence` value is added to the function, with increasing\r\n * precedence having a higher number.\r\n * @return {function} The function that performs the infix operation\r\n */\r\n Parser.prototype.operator = function (opts) {\r\n var op = '';\r\n var opFn;\r\n var ch = this.white();\r\n var isIdentifierChar = Identifier.is_valid_start_char;\r\n while (ch) {\r\n if (isIdentifierChar(ch) || ch <= ' ' || ch === '' ||\r\n ch === '\"' || ch === \"'\" || ch === '{' || ch === '(' ||\r\n ch === '`' || ch === ')' || (ch <= '9' && ch >= '0')) {\r\n break;\r\n }\r\n if (!opts.not_an_array && ch === '[') {\r\n break;\r\n }\r\n op += ch;\r\n ch = this.next();\r\n // An infix followed by the prefix e.g. a + @b\r\n // TODO: other prefix unary operators\r\n if (ch === '@') {\r\n break;\r\n }\r\n isIdentifierChar = Identifier.is_valid_continue_char;\r\n }\r\n if (op !== '') {\r\n if (opts.prefix && op === '-') {\r\n op = '&-';\r\n }\r\n opFn = operators[op];\r\n if (!opFn) {\r\n this.error(\"Bad operator: '\" + op + \"'.\");\r\n }\r\n }\r\n return opFn;\r\n };\r\n /**\r\n * Filters\r\n * Returns what the Node interprets as an \"operator\".\r\n * e.g.\r\n * \r\n */\r\n Parser.prototype.filter = function () {\r\n var ch = this.next();\r\n var args = [];\r\n var nextFilter = function (v) { return v; };\r\n var name = this.name();\r\n if (!options.filters[name]) {\r\n options.onError('Cannot find filter by the name of: ' + name);\r\n }\r\n ch = this.white();\r\n while (ch) {\r\n if (ch === ':') {\r\n ch = this.next();\r\n args.push(this.expression('|'));\r\n }\r\n if (ch === '|') {\r\n nextFilter = this.filter();\r\n break;\r\n }\r\n if (ch === ',') {\r\n break;\r\n }\r\n ch = this.white();\r\n }\r\n var filter = function filter(value, ignored, context, globals, node) {\r\n var argValues = [value];\r\n for (var i = 0, j = args.length; i < j; ++i) {\r\n argValues.push(Node.value_of(args[i], context, globals, node));\r\n }\r\n return nextFilter(options.filters[name].apply(null, argValues));\r\n };\r\n // Lowest precedence.\r\n filter.precedence = 1;\r\n return filter;\r\n };\r\n /**\r\n * Parse an expression – builds an operator tree, in something like\r\n * Shunting-Yard.\r\n * See: http://en.wikipedia.org/wiki/Shunting-yard_algorithm\r\n *\r\n * @return {function} A function that computes the value of the expression\r\n * when called or a primitive.\r\n */\r\n Parser.prototype.expression = function (filterable) {\r\n var op;\r\n var nodes = [];\r\n var ch = this.white();\r\n while (ch) {\r\n // unary prefix operators\r\n op = this.operator({ prefix: true });\r\n if (op) {\r\n nodes.push(undefined); // LHS Tree node.\r\n nodes.push(op);\r\n ch = this.white();\r\n }\r\n if (ch === '(') {\r\n this.next();\r\n nodes.push(this.expression());\r\n this.next(')');\r\n }\r\n else {\r\n nodes.push(this.value());\r\n }\r\n ch = this.white();\r\n if (ch === ':' || ch === '}' || ch === ',' || ch === ']' ||\r\n ch === ')' || ch === '' || ch === '`' || (ch === '|' && filterable === '|')) {\r\n break;\r\n }\r\n // filters\r\n if (ch === '|' && this.lookahead() !== '|' && filterable) {\r\n nodes.push(this.filter());\r\n nodes.push(undefined);\r\n break;\r\n }\r\n // infix or postfix operators\r\n op = this.operator({ not_an_array: true });\r\n if (op === operators['?']) {\r\n this.ternary(nodes);\r\n break;\r\n }\r\n else if (op === operators['.']) {\r\n nodes.push(op);\r\n nodes.push(this.member());\r\n op = null;\r\n }\r\n else if (op === operators['[']) {\r\n nodes.push(op);\r\n nodes.push(this.expression());\r\n ch = this.next(']');\r\n op = null;\r\n }\r\n else if (op) {\r\n nodes.push(op);\r\n }\r\n ch = this.white();\r\n if (ch === ']' || (!op && ch === '(')) {\r\n break;\r\n }\r\n }\r\n if (nodes.length === 0) {\r\n return undefined;\r\n }\r\n var dereferences = this.dereferences();\r\n if (nodes.length === 1 && !dereferences.length) {\r\n return nodes[0];\r\n }\r\n for (var i = 0, j = dereferences.length; i < j; ++i) {\r\n var deref = dereferences[i];\r\n if (deref.constructor === Arguments) {\r\n nodes.push(operators.call);\r\n }\r\n else {\r\n nodes.push(operators['.']);\r\n }\r\n nodes.push(deref);\r\n }\r\n return new Expression(nodes);\r\n };\r\n Parser.prototype.ternary = function (nodes) {\r\n var ternary = new Ternary();\r\n ternary.yes = this.expression();\r\n this.next(':');\r\n ternary.no = this.expression();\r\n nodes.push(operators['?']);\r\n nodes.push(ternary);\r\n };\r\n /**\r\n * Parse the arguments to a function, returning an Array.\r\n *\r\n */\r\n Parser.prototype.funcArguments = function () {\r\n var args = [];\r\n var ch = this.next('(');\r\n while (ch) {\r\n ch = this.white();\r\n if (ch === ')') {\r\n this.next(')');\r\n return new Arguments(this, args);\r\n }\r\n else {\r\n args.push(this.expression());\r\n ch = this.white();\r\n }\r\n if (ch !== ')') {\r\n this.next(',');\r\n }\r\n }\r\n this.error('Bad arguments to function');\r\n };\r\n /**\r\n * The literal string reference `abc` in an `x.abc` expression.\r\n */\r\n Parser.prototype.member = function () {\r\n var member = '';\r\n var ch = this.white();\r\n var isIdentifierChar = Identifier.is_valid_start_char;\r\n while (ch) {\r\n if (!isIdentifierChar(ch)) {\r\n break;\r\n }\r\n member += ch;\r\n ch = this.next();\r\n isIdentifierChar = Identifier.is_valid_continue_char;\r\n }\r\n return member;\r\n };\r\n /**\r\n * A dereference applies to an identifer, being either a function\r\n * call \"()\" or a membership lookup with square brackets \"[member]\".\r\n * @return {fn or undefined} Dereference function to be applied to the\r\n * Identifier\r\n */\r\n Parser.prototype.dereference = function () {\r\n var member;\r\n var ch = this.white();\r\n while (ch) {\r\n if (ch === '(') {\r\n // a(...) function call\r\n return this.funcArguments();\r\n }\r\n else if (ch === '[') {\r\n // a[x] membership\r\n this.next('[');\r\n member = this.expression();\r\n this.white();\r\n this.next(']');\r\n return member;\r\n }\r\n else if (ch === '.') {\r\n // a.x membership\r\n this.next('.');\r\n return this.member();\r\n }\r\n else {\r\n break;\r\n }\r\n }\r\n };\r\n Parser.prototype.dereferences = function () {\r\n var ch = this.white();\r\n var dereferences = [];\r\n var deref;\r\n while (ch) {\r\n deref = this.dereference();\r\n if (deref !== undefined) {\r\n dereferences.push(deref);\r\n }\r\n else {\r\n break;\r\n }\r\n }\r\n return dereferences;\r\n };\r\n Parser.prototype.identifier = function () {\r\n var token = '';\r\n var isIdentifierChar = Identifier.is_valid_start_char;\r\n var ch = this.white();\r\n while (ch) {\r\n if (!isIdentifierChar(ch)) {\r\n break;\r\n }\r\n token += ch;\r\n ch = this.next();\r\n isIdentifierChar = Identifier.is_valid_continue_char;\r\n }\r\n switch (token) {\r\n case 'true': return true;\r\n case 'false': return false;\r\n case 'null': return null;\r\n case 'undefined': return void 0;\r\n case 'function':\r\n throw new Error('Knockout: Anonymous functions are no longer supported, but `=>` lambdas are.');\r\n // return this.anonymous_fn();\r\n }\r\n return new Identifier(this, token, this.dereferences());\r\n };\r\n Parser.prototype.readBindings = function () {\r\n var key;\r\n var bindings = {};\r\n var sep;\r\n var expr;\r\n var ch = this.ch;\r\n while (ch) {\r\n key = this.name();\r\n sep = this.white();\r\n if (!sep || sep === ',') {\r\n if (sep) {\r\n ch = this.next(',');\r\n }\r\n else {\r\n ch = '';\r\n }\r\n // A \"bare\" binding e.g. \"text\"; substitute value of 'null'\r\n // so it becomes \"text: null\".\r\n bindings[key] = null;\r\n }\r\n else {\r\n if (key.indexOf('.') !== -1) {\r\n // Namespaced – i.e.\r\n // `attr.css: x` becomes `attr: { css: x }`\r\n // ^^^ - key\r\n key = key.split('.');\r\n bindings[key[0]] = bindings[key[0]] || {};\r\n if (key.length !== 2) {\r\n options.onError('Binding ' + key + ' should have two parts (a.b).');\r\n }\r\n else if (bindings[key[0]].constructor !== Object) {\r\n options.onError('Binding ' + key[0] + '.' + key[1] + ' paired with a non-object.');\r\n }\r\n ch = this.next(':');\r\n this.objectAddValue(bindings[key[0]], key[1], this.expression(true));\r\n }\r\n else {\r\n ch = this.next(':');\r\n if (bindings[key] && typeof bindings[key] === 'object' && bindings[key].constructor === Object) {\r\n // Extend a namespaced bindings e.g. we've previously seen\r\n // on.x, now we're seeing on: { 'abc' }.\r\n expr = this.expression(true);\r\n if (typeof expr !== 'object' || expr.constructor !== Object) {\r\n options.onError('Expected plain object for ' + key + ' value.');\r\n }\r\n else {\r\n extend(bindings[key], expr);\r\n }\r\n }\r\n else {\r\n bindings[key] = this.expression(true);\r\n }\r\n }\r\n this.white();\r\n if (this.ch) {\r\n ch = this.next(',');\r\n }\r\n else {\r\n ch = '';\r\n }\r\n }\r\n }\r\n return bindings;\r\n };\r\n Parser.prototype.valueAsAccessor = function (value, context, globals, node) {\r\n if (!value) {\r\n return function () { return value; };\r\n }\r\n if (typeof value === 'function') {\r\n return value;\r\n }\r\n if (value[Node.isExpressionOrIdentifierSymbol]) {\r\n return function () { return Node.value_of(value, context, globals, node); };\r\n }\r\n if (Array.isArray(value)) {\r\n return function () { return value.map(function (v) { return Node.value_of(v, context, globals, node); }); };\r\n }\r\n if (typeof (value) !== 'function') {\r\n return function () { return clonePlainObjectDeep(value); };\r\n }\r\n throw new Error('Value has cannot be converted to accessor: ' + value);\r\n };\r\n /**\r\n * Convert result[name] from a value to a function (i.e. `valueAccessor()`)\r\n * @param {object} result [Map of top-level names to values]\r\n * @return {object} [Map of top-level names to functions]\r\n *\r\n * Accessors may be one of (below) constAccessor, identifierAccessor,\r\n * expressionAccessor, or nodeAccessor.\r\n */\r\n Parser.prototype.convertToAccessors = function (result, context, globals, node) {\r\n var _this = this;\r\n objectForEach(result, function (name, value) {\r\n if (value instanceof Identifier) {\r\n // Return a function that, with no arguments returns\r\n // the value of the identifier, otherwise sets the\r\n // value of the identifier to the first given argument.\r\n Object.defineProperty(result, name, {\r\n value: function (optionalValue, options$$1) {\r\n var currentValue = value.get_value(undefined, context, globals, node);\r\n if (arguments.length === 0) {\r\n return currentValue;\r\n }\r\n var unchanged = optionalValue === currentValue;\r\n if (options$$1 && options$$1.onlyIfChanged && unchanged) {\r\n return;\r\n }\r\n return value.set_value(optionalValue, context, globals);\r\n }\r\n });\r\n }\r\n else {\r\n result[name] = _this.valueAsAccessor(value, context, globals, node);\r\n }\r\n });\r\n return result;\r\n };\r\n Parser.prototype.preparse = function (source) {\r\n if (source === void 0) { source = ''; }\r\n var preparsers = options.bindingStringPreparsers || [];\r\n return preparsers.reduce(function (acc, fn) { return fn(acc); }, source.trim());\r\n };\r\n Parser.prototype.runParse = function (source, fn) {\r\n this.text = this.preparse(source);\r\n this.at = 0;\r\n this.ch = ' ';\r\n try {\r\n var result = fn();\r\n this.white();\r\n if (this.ch) {\r\n this.error('Syntax Error');\r\n }\r\n return result;\r\n }\r\n catch (e) {\r\n options.onError(e);\r\n }\r\n };\r\n /**\r\n * Get the bindings as name: accessor()\r\n * @param {string} source The binding string to parse.\r\n * @return {object} Map of name to accessor function.\r\n */\r\n Parser.prototype.parse = function (source, context, globals, node) {\r\n var _this = this;\r\n if (context === void 0) { context = {}; }\r\n if (globals === void 0) { globals = {}; }\r\n if (!source) {\r\n return function () { return null; };\r\n }\r\n this.currentContextGlobals = [context, globals, node];\r\n var parseFn = function () { return _this.readBindings(); };\r\n var bindingAccessors = this.runParse(source, parseFn);\r\n return this.convertToAccessors(bindingAccessors, context, globals, node);\r\n };\r\n /**\r\n * Return a function that evaluates and returns the result of the expression.\r\n */\r\n Parser.prototype.parseExpression = function (source, context, globals, node) {\r\n var _this = this;\r\n if (context === void 0) { context = {}; }\r\n if (globals === void 0) { globals = {}; }\r\n if (!source) {\r\n return function () { return ''; };\r\n }\r\n this.currentContextGlobals = [context, globals, node];\r\n var parseFn = function () { return _this.expression(true); };\r\n var bindingAccessors = this.runParse(source, parseFn);\r\n return this.valueAsAccessor(bindingAccessors, context, globals, node);\r\n };\r\n return Parser;\r\n}());\n\n/* eslint no-cond-assign: 0 */\r\n// The following regular expressions will be used to split an object-literal string into tokens\r\n// These characters have special meaning to the parser and must not appear in the middle of a\r\n// token, except as part of a string.\r\nvar specials = ',\"\\'`{}()/:[\\\\]';\r\nvar bindingToken = RegExp([\r\n // These match strings, either with double quotes, single quotes, or backticks\r\n '\"(?:\\\\\\\\.|[^\"])*\"',\r\n \"'(?:\\\\\\\\.|[^'])*'\",\r\n '`(?:\\\\\\\\.|[^`])*`',\r\n // Match C style comments\r\n '/\\\\*(?:[^*]|\\\\*+[^*/])*\\\\*+/',\r\n // Match C++ style comments\r\n '//.*\\n',\r\n // Match a regular expression (text enclosed by slashes), but will also match sets of divisions\r\n // as a regular expression (this is handled by the parsing loop below).\r\n '/(?:\\\\\\\\.|[^/])+/\\\\w*',\r\n // Match text (at least two characters) that does not contain any of the above special characters,\r\n // although some of the special characters are allowed to start it (all but the colon and comma).\r\n // The text can contain spaces, but leading or trailing spaces are skipped.\r\n '[^\\\\s:,/][^' + specials + ']*[^\\\\s' + specials + ']',\r\n // Match any non-space character not matched already. This will match colons and commas, since they're\r\n // not matched by \"everyThingElse\", but will also match any other single character that wasn't already\r\n // matched (for example: in \"a: 1, b: 2\", each of the non-space characters will be matched by oneNotSpace).\r\n '[^\\\\s]'\r\n].join('|'), 'g');\r\n// Match end of previous token to determine whether a slash is a division or regex.\r\nvar divisionLookBehind = /[\\])\"'A-Za-z0-9_$]+$/;\r\nvar keywordRegexLookBehind = { 'in': 1, 'return': 1, 'typeof': 1 };\r\n/**\r\n * Break a binding string (data-bind='x: val, y: ..') into a stable array\r\n * of {key: value}.\r\n */\r\nfunction parseObjectLiteral(objectLiteralString) {\r\n // Trim leading and trailing spaces from the string\r\n var str = stringTrim(objectLiteralString);\r\n // Trim braces '{' surrounding the whole object literal\r\n if (str.charCodeAt(0) === 123)\r\n str = str.slice(1, -1);\r\n // Add a newline to correctly match a C++ style comment at the end of the string and\r\n // add a comma so that we don't need a separate code block to deal with the last item\r\n str += '\\n,';\r\n // Split into tokens\r\n var result = [];\r\n var toks = str.match(bindingToken);\r\n var key;\r\n var values = [];\r\n var depth = 0;\r\n if (toks.length <= 1) {\r\n return [];\r\n }\r\n for (var i = 0, tok; tok = toks[i]; ++i) {\r\n var c = tok.charCodeAt(0);\r\n // A comma signals the end of a key/value pair if depth is zero\r\n if (c === 44) { // \",\"\r\n if (depth <= 0) {\r\n result.push((key && values.length) ? {\r\n key: key,\r\n value: values.join('')\r\n } : {\r\n 'unknown': key || values.join('')\r\n });\r\n key = depth = 0;\r\n values = [];\r\n continue;\r\n }\r\n // Simply skip the colon that separates the name and value\r\n }\r\n else if (c === 58) { // \":\"\r\n if (!depth && !key && values.length === 1) {\r\n key = values.pop();\r\n continue;\r\n }\r\n // A set of slashes is initially matched as a regular expression, but could be division\r\n }\r\n else if (c === 47 && tok.length > 1 && (tok.charCodeAt(1) === 47 || tok.charCodeAt(1) === 42)) { // \"//\" or \"/*\"\r\n // skip comments\r\n continue;\r\n }\r\n else if (c === 47 && i && tok.length > 1) { // \"/\"\r\n // Look at the end of the previous token to determine if the slash is actually division\r\n var match = toks[i - 1].match(divisionLookBehind);\r\n if (match && !keywordRegexLookBehind[match[0]]) {\r\n // The slash is actually a division punctuator; re-parse the remainder of the string (not including the slash)\r\n str = str.substr(str.indexOf(tok) + 1);\r\n toks = str.match(bindingToken);\r\n i = -1;\r\n // Continue with just the slash\r\n tok = '/';\r\n }\r\n // Increment depth for parentheses, braces, and brackets so that interior commas are ignored\r\n }\r\n else if (c === 40 || c === 123 || c === 91) { // '(', '{', '['\r\n ++depth;\r\n }\r\n else if (c === 41 || c === 125 || c === 93) { // ')', '}', ']'\r\n --depth;\r\n // The key will be the first token; if it's a string, trim the quotes\r\n }\r\n else if (!key && !values.length && (c === 34 || c === 39)) { // '\"', \"'\"\r\n tok = tok.slice(1, -1);\r\n }\r\n values.push(tok);\r\n }\r\n return result;\r\n}\n\nexport { Parser, Identifier, Arguments, Node, parseObjectLiteral };\n//# sourceMappingURL=tko.utils.parser.js.map\n","/*!\n * TKO Computed Observables 🥊 tko.computed@4.0.0-alpha5c\n * (c) The Knockout.js Team - https://tko.io/\n * License: MIT (http://www.opensource.org/licenses/mit-license.php)\n */\n\nimport { addDisposeCallback, arrayForEach, createSymbolOrString, domNodeIsAttachedToDocument, extend, options, hasOwnProperty, objectForEach, removeDisposeCallback, safeSetTimeout } from 'tko.utils';\nimport { dependencyDetection, extenders, valuesArePrimitiveAndEqual, observable, subscribable, LATEST_VALUE, observableArray, unwrap } from 'tko.observable';\n\nvar _a;\r\nvar computedState = createSymbolOrString('_state');\r\nvar DISPOSED_STATE = {\r\n dependencyTracking: null,\r\n dependenciesCount: 0,\r\n isDisposed: true,\r\n isStale: false,\r\n isDirty: false,\r\n isSleeping: false,\r\n disposeWhenNodeIsRemoved: null,\r\n readFunction: null,\r\n _options: null\r\n};\r\nfunction computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget, options$$1) {\r\n if (typeof evaluatorFunctionOrOptions === 'object') {\r\n // Single-parameter syntax - everything is on this \"options\" param\r\n options$$1 = evaluatorFunctionOrOptions;\r\n }\r\n else {\r\n // Multi-parameter syntax - construct the options according to the params passed\r\n options$$1 = options$$1 || {};\r\n if (evaluatorFunctionOrOptions) {\r\n options$$1.read = evaluatorFunctionOrOptions;\r\n }\r\n }\r\n if (typeof options$$1.read !== 'function') {\r\n throw Error('Pass a function that returns the value of the computed');\r\n }\r\n var writeFunction = options$$1.write;\r\n var state = {\r\n latestValue: undefined,\r\n isStale: true,\r\n isDirty: true,\r\n isBeingEvaluated: false,\r\n suppressDisposalUntilDisposeWhenReturnsFalse: false,\r\n isDisposed: false,\r\n pure: false,\r\n isSleeping: false,\r\n readFunction: options$$1.read,\r\n evaluatorFunctionTarget: evaluatorFunctionTarget || options$$1.owner,\r\n disposeWhenNodeIsRemoved: options$$1.disposeWhenNodeIsRemoved || options$$1.disposeWhenNodeIsRemoved || null,\r\n disposeWhen: options$$1.disposeWhen || options$$1.disposeWhen,\r\n domNodeDisposalCallback: null,\r\n dependencyTracking: {},\r\n dependenciesCount: 0,\r\n evaluationTimeoutInstance: null\r\n };\r\n function computedObservable() {\r\n if (arguments.length > 0) {\r\n if (typeof writeFunction === 'function') {\r\n // Writing a value\r\n writeFunction.apply(state.evaluatorFunctionTarget, arguments);\r\n }\r\n else {\r\n 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.\");\r\n }\r\n return this; // Permits chained assignments\r\n }\r\n else {\r\n // Reading the value\r\n if (!state.isDisposed) {\r\n dependencyDetection.registerDependency(computedObservable);\r\n }\r\n if (state.isDirty || (state.isSleeping && computedObservable.haveDependenciesChanged())) {\r\n computedObservable.evaluateImmediate();\r\n }\r\n return state.latestValue;\r\n }\r\n }\r\n computedObservable[computedState] = state;\r\n computedObservable.isWriteable = typeof writeFunction === 'function';\r\n subscribable.fn.init(computedObservable);\r\n // Inherit from 'computed'\r\n Object.setPrototypeOf(computedObservable, computed.fn);\r\n if (options$$1.pure) {\r\n state.pure = true;\r\n state.isSleeping = true; // Starts off sleeping; will awake on the first subscription\r\n extend(computedObservable, pureComputedOverrides);\r\n }\r\n else if (options$$1.deferEvaluation) {\r\n extend(computedObservable, deferEvaluationOverrides);\r\n }\r\n if (options.deferUpdates) {\r\n extenders.deferred(computedObservable, true);\r\n }\r\n if (options.debug) {\r\n // #1731 - Aid debugging by exposing the computed's options\r\n computedObservable._options = options$$1;\r\n }\r\n if (state.disposeWhenNodeIsRemoved) {\r\n // Since this computed is associated with a DOM node, and we don't want to dispose the computed\r\n // until the DOM node is *removed* from the document (as opposed to never having been in the document),\r\n // we'll prevent disposal until \"disposeWhen\" first returns false.\r\n state.suppressDisposalUntilDisposeWhenReturnsFalse = true;\r\n // disposeWhenNodeIsRemoved: true can be used to opt into the \"only dispose after first false result\"\r\n // behaviour even if there's no specific node to watch. In that case, clear the option so we don't try\r\n // to watch for a non-node's disposal. This technique is intended for KO's internal use only and shouldn't\r\n // be documented or used by application code, as it's likely to change in a future version of KO.\r\n if (!state.disposeWhenNodeIsRemoved.nodeType) {\r\n state.disposeWhenNodeIsRemoved = null;\r\n }\r\n }\r\n // Evaluate, unless sleeping or deferEvaluation is true\r\n if (!state.isSleeping && !options$$1.deferEvaluation) {\r\n computedObservable.evaluateImmediate();\r\n }\r\n // Attach a DOM node disposal callback so that the computed will be proactively disposed as soon as the node is\r\n // removed using ko.removeNode. But skip if isActive is false (there will never be any dependencies to dispose).\r\n if (state.disposeWhenNodeIsRemoved && computedObservable.isActive()) {\r\n addDisposeCallback(state.disposeWhenNodeIsRemoved, state.domNodeDisposalCallback = function () {\r\n computedObservable.dispose();\r\n });\r\n }\r\n return computedObservable;\r\n}\r\n// Utility function that disposes a given dependencyTracking entry\r\nfunction computedDisposeDependencyCallback(id, entryToDispose) {\r\n if (entryToDispose !== null && entryToDispose.dispose) {\r\n entryToDispose.dispose();\r\n }\r\n}\r\n// This function gets called each time a dependency is detected while evaluating a computed.\r\n// It's factored out as a shared function to avoid creating unnecessary function instances during evaluation.\r\nfunction computedBeginDependencyDetectionCallback(subscribable$$1, id) {\r\n var computedObservable = this.computedObservable, state = computedObservable[computedState];\r\n if (!state.isDisposed) {\r\n if (this.disposalCount && this.disposalCandidates[id]) {\r\n // Don't want to dispose this subscription, as it's still being used\r\n computedObservable.addDependencyTracking(id, subscribable$$1, this.disposalCandidates[id]);\r\n this.disposalCandidates[id] = null; // No need to actually delete the property - disposalCandidates is a transient object anyway\r\n --this.disposalCount;\r\n }\r\n else if (!state.dependencyTracking[id]) {\r\n // Brand new subscription - add it\r\n computedObservable.addDependencyTracking(id, subscribable$$1, state.isSleeping ? { _target: subscribable$$1 } : computedObservable.subscribeToDependency(subscribable$$1));\r\n }\r\n // If the observable we've accessed has a pending notification, ensure\r\n // we get notified of the actual final value (bypass equality checks)\r\n if (subscribable$$1._notificationIsPending) {\r\n subscribable$$1._notifyNextChangeIfValueIsDifferent();\r\n }\r\n }\r\n}\r\ncomputed.fn = (_a = {\r\n equalityComparer: valuesArePrimitiveAndEqual,\r\n getDependenciesCount: function () {\r\n return this[computedState].dependenciesCount;\r\n },\r\n getDependencies: function () {\r\n var dependencyTracking = this[computedState].dependencyTracking;\r\n var dependentObservables = [];\r\n objectForEach(dependencyTracking, function (id, dependency) {\r\n dependentObservables[dependency._order] = dependency._target;\r\n });\r\n return dependentObservables;\r\n },\r\n addDependencyTracking: function (id, target, trackingObj) {\r\n if (this[computedState].pure && target === this) {\r\n throw Error(\"A 'pure' computed must not be called recursively\");\r\n }\r\n this[computedState].dependencyTracking[id] = trackingObj;\r\n trackingObj._order = this[computedState].dependenciesCount++;\r\n trackingObj._version = target.getVersion();\r\n },\r\n haveDependenciesChanged: function () {\r\n var id, dependency, dependencyTracking = this[computedState].dependencyTracking;\r\n for (id in dependencyTracking) {\r\n if (hasOwnProperty(dependencyTracking, id)) {\r\n dependency = dependencyTracking[id];\r\n if ((this._evalDelayed && dependency._target._notificationIsPending) || dependency._target.hasChanged(dependency._version)) {\r\n return true;\r\n }\r\n }\r\n }\r\n },\r\n markDirty: function () {\r\n // Process \"dirty\" events if we can handle delayed notifications\r\n if (this._evalDelayed && !this[computedState].isBeingEvaluated) {\r\n this._evalDelayed(false /* notifyChange */);\r\n }\r\n },\r\n isActive: function () {\r\n var state = this[computedState];\r\n return state.isDirty || state.dependenciesCount > 0;\r\n },\r\n respondToChange: function () {\r\n // Ignore \"change\" events if we've already scheduled a delayed notification\r\n if (!this._notificationIsPending) {\r\n this.evaluatePossiblyAsync();\r\n }\r\n else if (this[computedState].isDirty) {\r\n this[computedState].isStale = true;\r\n }\r\n },\r\n subscribeToDependency: function (target) {\r\n if (target._deferUpdates) {\r\n var dirtySub = target.subscribe(this.markDirty, this, 'dirty'), changeSub = target.subscribe(this.respondToChange, this);\r\n return {\r\n _target: target,\r\n dispose: function () {\r\n dirtySub.dispose();\r\n changeSub.dispose();\r\n }\r\n };\r\n }\r\n else {\r\n return target.subscribe(this.evaluatePossiblyAsync, this);\r\n }\r\n },\r\n evaluatePossiblyAsync: function () {\r\n var computedObservable = this, throttleEvaluationTimeout = computedObservable.throttleEvaluation;\r\n if (throttleEvaluationTimeout && throttleEvaluationTimeout >= 0) {\r\n clearTimeout(this[computedState].evaluationTimeoutInstance);\r\n this[computedState].evaluationTimeoutInstance = safeSetTimeout(function () {\r\n computedObservable.evaluateImmediate(true /* notifyChange */);\r\n }, throttleEvaluationTimeout);\r\n }\r\n else if (computedObservable._evalDelayed) {\r\n computedObservable._evalDelayed(true /* notifyChange */);\r\n }\r\n else {\r\n computedObservable.evaluateImmediate(true /* notifyChange */);\r\n }\r\n },\r\n evaluateImmediate: function (notifyChange) {\r\n var computedObservable = this, state = computedObservable[computedState], disposeWhen = state.disposeWhen, changed = false;\r\n if (state.isBeingEvaluated) {\r\n // If the evaluation of a ko.computed causes side effects, it's possible that it will trigger its own re-evaluation.\r\n // This is not desirable (it's hard for a developer to realise a chain of dependencies might cause this, and they almost\r\n // certainly didn't intend infinite re-evaluations). So, for predictability, we simply prevent ko.computeds from causing\r\n // their own re-evaluation. Further discussion at https://github.com/SteveSanderson/knockout/pull/387\r\n return;\r\n }\r\n // Do not evaluate (and possibly capture new dependencies) if disposed\r\n if (state.isDisposed) {\r\n return;\r\n }\r\n if (state.disposeWhenNodeIsRemoved && !domNodeIsAttachedToDocument(state.disposeWhenNodeIsRemoved) || disposeWhen && disposeWhen()) {\r\n // See comment above about suppressDisposalUntilDisposeWhenReturnsFalse\r\n if (!state.suppressDisposalUntilDisposeWhenReturnsFalse) {\r\n computedObservable.dispose();\r\n return;\r\n }\r\n }\r\n else {\r\n // It just did return false, so we can stop suppressing now\r\n state.suppressDisposalUntilDisposeWhenReturnsFalse = false;\r\n }\r\n state.isBeingEvaluated = true;\r\n try {\r\n changed = this.evaluateImmediate_CallReadWithDependencyDetection(notifyChange);\r\n }\r\n finally {\r\n state.isBeingEvaluated = false;\r\n }\r\n return changed;\r\n },\r\n evaluateImmediate_CallReadWithDependencyDetection: function (notifyChange) {\r\n // This function is really just part of the evaluateImmediate logic. You would never call it from anywhere else.\r\n // Factoring it out into a separate function means it can be independent of the try/catch block in evaluateImmediate,\r\n // which contributes to saving about 40% off the CPU overhead of computed evaluation (on V8 at least).\r\n var computedObservable = this, state = computedObservable[computedState], changed = false;\r\n // Initially, we assume that none of the subscriptions are still being used (i.e., all are candidates for disposal).\r\n // Then, during evaluation, we cross off any that are in fact still being used.\r\n var isInitial = state.pure ? undefined : !state.dependenciesCount, // If we're evaluating when there are no previous dependencies, it must be the first time\r\n dependencyDetectionContext = {\r\n computedObservable: computedObservable,\r\n disposalCandidates: state.dependencyTracking,\r\n disposalCount: state.dependenciesCount\r\n };\r\n dependencyDetection.begin({\r\n callbackTarget: dependencyDetectionContext,\r\n callback: computedBeginDependencyDetectionCallback,\r\n computed: computedObservable,\r\n isInitial: isInitial\r\n });\r\n state.dependencyTracking = {};\r\n state.dependenciesCount = 0;\r\n var newValue = this.evaluateImmediate_CallReadThenEndDependencyDetection(state, dependencyDetectionContext);\r\n if (!state.dependenciesCount) {\r\n computedObservable.dispose();\r\n changed = true; // When evaluation causes a disposal, make sure all dependent computeds get notified so they'll see the new state\r\n }\r\n else {\r\n changed = computedObservable.isDifferent(state.latestValue, newValue);\r\n }\r\n if (changed) {\r\n if (!state.isSleeping) {\r\n computedObservable.notifySubscribers(state.latestValue, 'beforeChange');\r\n }\r\n else {\r\n computedObservable.updateVersion();\r\n }\r\n state.latestValue = newValue;\r\n if (options.debug) {\r\n computedObservable._latestValue = newValue;\r\n }\r\n computedObservable.notifySubscribers(state.latestValue, 'spectate');\r\n if (!state.isSleeping && notifyChange) {\r\n computedObservable.notifySubscribers(state.latestValue);\r\n }\r\n if (computedObservable._recordUpdate) {\r\n computedObservable._recordUpdate();\r\n }\r\n }\r\n if (isInitial) {\r\n computedObservable.notifySubscribers(state.latestValue, 'awake');\r\n }\r\n return changed;\r\n },\r\n evaluateImmediate_CallReadThenEndDependencyDetection: function (state, dependencyDetectionContext) {\r\n // This function is really part of the evaluateImmediate_CallReadWithDependencyDetection logic.\r\n // You'd never call it from anywhere else. Factoring it out means that evaluateImmediate_CallReadWithDependencyDetection\r\n // can be independent of try/finally blocks, which contributes to saving about 40% off the CPU\r\n // overhead of computed evaluation (on V8 at least).\r\n try {\r\n var readFunction = state.readFunction;\r\n return state.evaluatorFunctionTarget ? readFunction.call(state.evaluatorFunctionTarget) : readFunction();\r\n }\r\n finally {\r\n dependencyDetection.end();\r\n // For each subscription no longer being used, remove it from the active subscriptions list and dispose it\r\n if (dependencyDetectionContext.disposalCount && !state.isSleeping) {\r\n objectForEach(dependencyDetectionContext.disposalCandidates, computedDisposeDependencyCallback);\r\n }\r\n state.isStale = state.isDirty = false;\r\n }\r\n },\r\n peek: function (forceEvaluate) {\r\n // Peek won't ordinarily re-evaluate, except while the computed is sleeping\r\n // or to get the initial value when \"deferEvaluation\" is set.\r\n var state = this[computedState];\r\n if ((state.isDirty && (forceEvaluate || !state.dependenciesCount)) || (state.isSleeping && this.haveDependenciesChanged())) {\r\n this.evaluateImmediate();\r\n }\r\n return state.latestValue;\r\n }\r\n },\r\n Object.defineProperty(_a, LATEST_VALUE, {\r\n get: function () {\r\n return this.peek();\r\n },\r\n enumerable: true,\r\n configurable: true\r\n }),\r\n _a.limit = function (limitFunction) {\r\n var state = this[computedState];\r\n // Override the limit function with one that delays evaluation as well\r\n subscribable.fn.limit.call(this, limitFunction);\r\n Object.assign(this, {\r\n _evalIfChanged: function () {\r\n if (!this[computedState].isSleeping) {\r\n if (this[computedState].isStale) {\r\n this.evaluateImmediate();\r\n }\r\n else {\r\n this[computedState].isDirty = false;\r\n }\r\n }\r\n return state.latestValue;\r\n },\r\n _evalDelayed: function (isChange) {\r\n this._limitBeforeChange(state.latestValue);\r\n // Mark as dirty\r\n state.isDirty = true;\r\n if (isChange) {\r\n state.isStale = true;\r\n }\r\n // Pass the observable to the \"limit\" code, which will evaluate it when\r\n // it's time to do the notification.\r\n this._limitChange(this, !isChange /* isDirty */);\r\n }\r\n });\r\n },\r\n _a.dispose = function () {\r\n var state = this[computedState];\r\n if (!state.isSleeping && state.dependencyTracking) {\r\n objectForEach(state.dependencyTracking, function (id, dependency) {\r\n if (dependency.dispose) {\r\n dependency.dispose();\r\n }\r\n });\r\n }\r\n if (state.disposeWhenNodeIsRemoved && state.domNodeDisposalCallback) {\r\n removeDisposeCallback(state.disposeWhenNodeIsRemoved, state.domNodeDisposalCallback);\r\n }\r\n Object.assign(state, DISPOSED_STATE);\r\n },\r\n _a);\r\nvar pureComputedOverrides = {\r\n beforeSubscriptionAdd: function (event) {\r\n // If asleep, wake up the computed by subscribing to any dependencies.\r\n var computedObservable = this, state = computedObservable[computedState];\r\n if (!state.isDisposed && state.isSleeping && event === 'change') {\r\n state.isSleeping = false;\r\n if (state.isStale || computedObservable.haveDependenciesChanged()) {\r\n state.dependencyTracking = null;\r\n state.dependenciesCount = 0;\r\n if (computedObservable.evaluateImmediate()) {\r\n computedObservable.updateVersion();\r\n }\r\n }\r\n else {\r\n // First put the dependencies in order\r\n var dependenciesOrder = [];\r\n objectForEach(state.dependencyTracking, function (id, dependency) {\r\n dependenciesOrder[dependency._order] = id;\r\n });\r\n // Next, subscribe to each one\r\n arrayForEach(dependenciesOrder, function (id, order) {\r\n var dependency = state.dependencyTracking[id], subscription = computedObservable.subscribeToDependency(dependency._target);\r\n subscription._order = order;\r\n subscription._version = dependency._version;\r\n state.dependencyTracking[id] = subscription;\r\n });\r\n // Waking dependencies may have triggered effects\r\n if (computedObservable.haveDependenciesChanged()) {\r\n if (computedObservable.evaluateImmediate()) {\r\n computedObservable.updateVersion();\r\n }\r\n }\r\n }\r\n if (!state.isDisposed) { // test since evaluating could trigger disposal\r\n computedObservable.notifySubscribers(state.latestValue, 'awake');\r\n }\r\n }\r\n },\r\n afterSubscriptionRemove: function (event) {\r\n var state = this[computedState];\r\n if (!state.isDisposed && event === 'change' && !this.hasSubscriptionsForEvent('change')) {\r\n objectForEach(state.dependencyTracking, function (id, dependency) {\r\n if (dependency.dispose) {\r\n state.dependencyTracking[id] = {\r\n _target: dependency._target,\r\n _order: dependency._order,\r\n _version: dependency._version\r\n };\r\n dependency.dispose();\r\n }\r\n });\r\n state.isSleeping = true;\r\n this.notifySubscribers(undefined, 'asleep');\r\n }\r\n },\r\n getVersion: function () {\r\n // Because a pure computed is not automatically updated while it is sleeping, we can't\r\n // simply return the version number. Instead, we check if any of the dependencies have\r\n // changed and conditionally re-evaluate the computed observable.\r\n var state = this[computedState];\r\n if (state.isSleeping && (state.isStale || this.haveDependenciesChanged())) {\r\n this.evaluateImmediate();\r\n }\r\n return subscribable.fn.getVersion.call(this);\r\n }\r\n};\r\nvar deferEvaluationOverrides = {\r\n beforeSubscriptionAdd: function (event) {\r\n // This will force a computed with deferEvaluation to evaluate when the first subscription is registered.\r\n if (event === 'change' || event === 'beforeChange') {\r\n this.peek();\r\n }\r\n }\r\n};\r\nObject.setPrototypeOf(computed.fn, subscribable.fn);\r\n// Set the proto values for ko.computed\r\nvar protoProp = observable.protoProperty; // == \"__ko_proto__\"\r\ncomputed.fn[protoProp] = computed;\r\n/* This is used by ko.isObservable */\r\nobservable.observablePrototypes.add(computed);\r\nfunction isComputed(instance) {\r\n return (typeof instance === 'function' && instance[protoProp] === computed);\r\n}\r\nfunction isPureComputed(instance) {\r\n return isComputed(instance) && instance[computedState] && instance[computedState].pure;\r\n}\r\nfunction pureComputed(evaluatorFunctionOrOptions, evaluatorFunctionTarget) {\r\n if (typeof evaluatorFunctionOrOptions === 'function') {\r\n return computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget, { 'pure': true });\r\n }\r\n else {\r\n evaluatorFunctionOrOptions = extend({}, evaluatorFunctionOrOptions); // make a copy of the parameter object\r\n evaluatorFunctionOrOptions.pure = true;\r\n return computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget);\r\n }\r\n}\n\nfunction throttleExtender(target, timeout) {\r\n // Throttling means two things:\r\n // (1) For dependent observables, we throttle *evaluations* so that, no matter how fast its dependencies\r\n // notify updates, the target doesn't re-evaluate (and hence doesn't notify) faster than a certain rate\r\n target.throttleEvaluation = timeout;\r\n // (2) For writable targets (observables, or writable dependent observables), we throttle *writes*\r\n // so the target cannot change value synchronously or faster than a certain rate\r\n var writeTimeoutInstance = null;\r\n return computed({\r\n read: target,\r\n write: function (value) {\r\n clearTimeout(writeTimeoutInstance);\r\n writeTimeoutInstance = setTimeout(function () {\r\n target(value);\r\n }, timeout);\r\n }\r\n });\r\n}\r\nextenders.throttle = throttleExtender;\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n\r\nfunction __values(o) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n if (m) return m.call(o);\r\n return {\r\n next: function () {\r\n if (o && i >= o.length) o = void 0;\r\n return { value: o && o[i++], done: !o };\r\n }\r\n };\r\n}\r\n\r\nfunction __read(o, n) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n if (!m) return o;\r\n var i = m.call(o), r, ar = [], e;\r\n try {\r\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n }\r\n catch (error) { e = { error: error }; }\r\n finally {\r\n try {\r\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n }\r\n finally { if (e) throw e.error; }\r\n }\r\n return ar;\r\n}\r\n\r\nfunction __spread() {\r\n for (var ar = [], i = 0; i < arguments.length; i++)\r\n ar = ar.concat(__read(arguments[i]));\r\n return ar;\r\n}\n\n/**\r\n * Create an ES\r\n */\r\nvar PROXY_SYM = Symbol('Knockout Proxied Object');\r\nvar MIRROR_SYM = Symbol('Knockout Proxied Observables');\r\nfunction makeComputed(proxy, fn) {\r\n return computed({\r\n owner: proxy,\r\n read: fn,\r\n write: fn,\r\n pure: 'pure' in fn ? fn.pure : true,\r\n deferEvaluation: 'deferEvaluation' in fn ? fn.deferEvaluation : true\r\n }).extend({ deferred: true });\r\n}\r\nfunction setOrCreate(mirror, prop, value, proxy) {\r\n if (!mirror[prop]) {\r\n var ctr = Array.isArray(value) ? observableArray\r\n : typeof value === 'function' ? makeComputed.bind(null, proxy)\r\n : observable;\r\n mirror[prop] = ctr(value);\r\n }\r\n else {\r\n mirror[prop](value);\r\n }\r\n}\r\nfunction assignOrUpdate(mirror, object, proxy) {\r\n var e_1, _a;\r\n try {\r\n for (var _b = __values(Object.keys(object)), _c = _b.next(); !_c.done; _c = _b.next()) {\r\n var key = _c.value;\r\n setOrCreate(mirror, key, object[key], proxy);\r\n }\r\n }\r\n catch (e_1_1) { e_1 = { error: e_1_1 }; }\r\n finally {\r\n try {\r\n if (_c && !_c.done && (_a = _b[\"return\"])) _a.call(_b);\r\n }\r\n finally { if (e_1) throw e_1.error; }\r\n }\r\n return object;\r\n}\r\nfunction proxy(object) {\r\n var _a;\r\n var mirror = (_a = {}, _a[PROXY_SYM] = object, _a);\r\n mirror[MIRROR_SYM] = mirror;\r\n var proxy = new Proxy(function () { }, {\r\n has: function (target, prop) { return prop in mirror; },\r\n get: function (target, prop) { return unwrap(mirror[prop]); },\r\n set: function (target, prop, value, receiver) {\r\n setOrCreate(mirror, prop, value, proxy);\r\n object[prop] = value;\r\n return true;\r\n },\r\n deleteProperty: function (property) {\r\n delete mirror[property];\r\n return delete object[property];\r\n },\r\n apply: function (target, thisArg, _a) {\r\n var _b = __read(_a, 1), props = _b[0];\r\n if (props) {\r\n assignOrUpdate(mirror, props, proxy);\r\n return Object.assign(object, props);\r\n }\r\n return object;\r\n },\r\n getPrototypeOf: function () { return Object.getPrototypeOf(object); },\r\n setPrototypeOf: function (target, proto) { return Object.setPrototypeOf(object, proto); },\r\n defineProperty: function (target, prop, desc) { return Object.defineProperty(object, prop, desc); },\r\n preventExtensions: function () { return Object.preventExtensions(object); },\r\n isExtensible: function () { return Object.isExtensible(object); },\r\n ownKeys: function () {\r\n return __spread(Object.getOwnPropertyNames(object), Object.getOwnPropertySymbols(object));\r\n }\r\n });\r\n assignOrUpdate(mirror, object, proxy);\r\n return proxy;\r\n}\r\nfunction getObservable(proxied, prop) { return proxied[MIRROR_SYM][prop]; }\r\nfunction peek(proxied, prop) { return getObservable(proxied, prop).peek(); }\r\nfunction isProxied(proxied) { return PROXY_SYM in proxied; }\r\nObject.assign(proxy, { getObservable: getObservable, peek: peek, isProxied: isProxied });\n\nfunction kowhen(predicate, context, resolve) {\r\n var observable$$1 = pureComputed(predicate, context).extend({ notify: 'always' });\r\n var subscription = observable$$1.subscribe(function (value) {\r\n if (value) {\r\n subscription.dispose();\r\n resolve(value);\r\n }\r\n });\r\n // In case the initial value is true, process it right away\r\n observable$$1.notifySubscribers(observable$$1.peek());\r\n return subscription;\r\n}\r\nfunction when(predicate, callback, context) {\r\n var whenFn = kowhen.bind(null, predicate, context);\r\n return callback ? whenFn(callback.bind(context)) : new Promise(whenFn);\r\n}\n\n//\n\nexport { computed, isComputed, isPureComputed, pureComputed, throttleExtender, proxy, when };\n//# sourceMappingURL=tko.computed.js.map\n","/*!\n * Knockout LifeCycle for object instances 🥊 tko.lifecycle@4.0.0-alpha5c\n * (c) The Knockout.js Team - https://tko.io/\n * License: MIT (http://www.opensource.org/licenses/mit-license.php)\n */\n\nimport { addDisposeCallback, createSymbolOrString } from 'tko.utils';\nimport { computed } from 'tko.computed';\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n\r\nfunction __values(o) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n if (m) return m.call(o);\r\n return {\r\n next: function () {\r\n if (o && i >= o.length) o = void 0;\r\n return { value: o && o[i++], done: !o };\r\n }\r\n };\r\n}\r\n\r\nfunction __read(o, n) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n if (!m) return o;\r\n var i = m.call(o), r, ar = [], e;\r\n try {\r\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n }\r\n catch (error) { e = { error: error }; }\r\n finally {\r\n try {\r\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n }\r\n finally { if (e) throw e.error; }\r\n }\r\n return ar;\r\n}\n\nvar SUBSCRIPTIONS = createSymbolOrString('LifeCycle Subscriptions List');\r\nvar ANCHOR_NODE = createSymbolOrString('LifeCycle Anchor Node');\r\nvar LifeCycle = /** @class */ (function () {\r\n function LifeCycle() {\r\n }\r\n // NOTE: For more advanced integration as an ES6 mixin, see e.g.:\r\n // http://justinfagnani.com/2015/12/21/real-mixins-with-javascript-classes/\r\n /**\r\n * Copy the properties of the LifeCycle class to the target (or its prototype)\r\n *\r\n * NOTE: getOwnPropertyNames is needed to copy the non-enumerable properties.\r\n */\r\n LifeCycle.mixInto = function (Constructor) {\r\n var e_1, _a;\r\n var target = Constructor.prototype || Constructor;\r\n var mixin = LifeCycle.prototype;\r\n try {\r\n for (var _b = __values(Object.getOwnPropertyNames(mixin)), _c = _b.next(); !_c.done; _c = _b.next()) {\r\n var prop = _c.value;\r\n target[prop] = mixin[prop];\r\n }\r\n }\r\n catch (e_1_1) { e_1 = { error: e_1_1 }; }\r\n finally {\r\n try {\r\n if (_c && !_c.done && (_a = _b[\"return\"])) _a.call(_b);\r\n }\r\n finally { if (e_1) throw e_1.error; }\r\n }\r\n };\r\n LifeCycle.prototype.subscribe = function (observable, action) {\r\n if (typeof action === 'string') {\r\n action = this[action].bind(this);\r\n }\r\n this.addDisposable(observable.subscribe(action));\r\n };\r\n LifeCycle.prototype.computed = function (params) {\r\n if (typeof params === 'string') {\r\n params = { read: this[params], write: this[params], owner: this };\r\n }\r\n else if (typeof params === 'object') ;\r\n else if (typeof params === 'function') {\r\n params = { read: params, write: params };\r\n }\r\n else {\r\n throw new Error('LifeCycle::computed not given a valid type.');\r\n }\r\n params.disposeWhenNodeIsRemoved = this[ANCHOR_NODE];\r\n return this.addDisposable(computed(params));\r\n };\r\n /**\r\n * Add an event listener for the given or anchored node.\r\n * @param {node} [node] (optional) The target node (otherwise the anchored node)\r\n * @param {string} [type] Event type\r\n * @param {function|string} [action] Either call the given function or `this[action]`\r\n * @param {object} [options] (optional) Passed as `options` to `node.addEventListener`\r\n */\r\n LifeCycle.prototype.addEventListener = function () {\r\n var args = [];\r\n for (var _i = 0; _i < arguments.length; _i++) {\r\n args[_i] = arguments[_i];\r\n }\r\n var node = args[0].nodeType ? args.shift() : this[ANCHOR_NODE];\r\n var _a = __read(args, 3), type = _a[0], act = _a[1], options = _a[2];\r\n var handler = typeof act === 'string' ? this[act].bind(this) : act;\r\n this.__addEventListener(node, type, handler, options);\r\n };\r\n LifeCycle.prototype.__addEventListener = function (node, eventType, handler, options) {\r\n node.addEventListener(eventType, handler, options);\r\n function dispose() { node.removeEventListener(eventType, handler); }\r\n addDisposeCallback(node, dispose);\r\n this.addDisposable({ dispose: dispose });\r\n };\r\n LifeCycle.prototype.anchorTo = function (node) {\r\n var _this = this;\r\n addDisposeCallback(node, function () { return _this.dispose(); });\r\n this[ANCHOR_NODE] = node;\r\n };\r\n LifeCycle.prototype.dispose = function () {\r\n var subscriptions = this[SUBSCRIPTIONS] || [];\r\n subscriptions.forEach(function (s) { return s.dispose(); });\r\n this[SUBSCRIPTIONS] = [];\r\n this[ANCHOR_NODE] = null;\r\n };\r\n LifeCycle.prototype.addDisposable = function (subscription) {\r\n var subscriptions = this[SUBSCRIPTIONS] || [];\r\n if (!this[SUBSCRIPTIONS]) {\r\n this[SUBSCRIPTIONS] = subscriptions;\r\n }\r\n if (typeof subscription.dispose !== 'function') {\r\n throw new Error('Lifecycle::addDisposable argument missing `dispose`.');\r\n }\r\n subscriptions.push(subscription);\r\n return subscription;\r\n };\r\n return LifeCycle;\r\n}());\n\nexport { LifeCycle };\n//# sourceMappingURL=tko.lifecycle.js.map\n","/*!\n * TKO DOM-Observable Binding 🥊 tko.bind@4.0.0-alpha5c\n * (c) The Knockout.js Team - https://tko.io/\n * License: MIT (http://www.opensource.org/licenses/mit-license.php)\n */\n\nimport { domData, extend, options, virtualElements, objectMap, tagNameLower, objectForEach, arrayIndexOf, arrayForEach, fixUpContinuousNodeArray, replaceDomNodes, arrayPushAll, anyDomNodeIsAttachedToDocument, arrayMap, cleanNode, removeNode, compareArrays } from 'tko.utils';\nimport { subscribable, unwrap, isObservable, dependencyDetection, observable } from 'tko.observable';\nimport { pureComputed, computed } from 'tko.computed';\nimport { LifeCycle } from 'tko.lifecycle';\n\nvar contextAncestorBindingInfo = Symbol('_ancestorBindingInfo');\r\nvar boundElementDomDataKey = domData.nextKey();\r\nvar bindingEvent = {\r\n childrenComplete: 'childrenComplete',\r\n descendantsComplete: 'descendantsComplete',\r\n subscribe: function (node, event, callback, context) {\r\n var bindingInfo = domData.getOrSet(node, boundElementDomDataKey, {});\r\n if (!bindingInfo.eventSubscribable) {\r\n bindingInfo.eventSubscribable = new subscribable();\r\n }\r\n return bindingInfo.eventSubscribable.subscribe(callback, context, event);\r\n },\r\n notify: function (node, event) {\r\n var bindingInfo = domData.get(node, boundElementDomDataKey);\r\n if (bindingInfo) {\r\n if (bindingInfo.eventSubscribable) {\r\n bindingInfo.eventSubscribable.notifySubscribers(node, event);\r\n }\r\n }\r\n }\r\n};\n\nvar boundElementDomDataKey$1 = domData.nextKey();\r\nvar contextSubscribeSymbol = Symbol('Knockout Context Subscription');\r\n// Unique stub to indicate inheritance.\r\nvar inheritParentIndicator = Symbol('Knockout Parent Indicator');\r\n// The bindingContext constructor is only called directly to create the root context. For child\r\n// contexts, use bindingContext.createChildContext or bindingContext.extend.\r\nfunction bindingContext(dataItemOrAccessor, parentContext, dataItemAlias, extendCallback, settings) {\r\n var self = this;\r\n var shouldInheritData = dataItemOrAccessor === inheritParentIndicator;\r\n var realDataItemOrAccessor = shouldInheritData ? undefined : dataItemOrAccessor;\r\n var isFunc = typeof realDataItemOrAccessor === 'function' && !isObservable(realDataItemOrAccessor);\r\n // Export 'ko' in the binding context so it will be available in bindings and templates\r\n // even if 'ko' isn't exported as a global, such as when using an AMD loader.\r\n // See https://github.com/SteveSanderson/knockout/issues/490\r\n self.ko = options.knockoutInstance;\r\n var subscribable$$1;\r\n // The binding context object includes static properties for the current, parent, and root view models.\r\n // If a view model is actually stored in an observable, the corresponding binding context object, and\r\n // any child contexts, must be updated when the view model is changed.\r\n function updateContext() {\r\n // Most of the time, the context will directly get a view model object, but if a function is given,\r\n // we call the function to retrieve the view model. If the function accesses any observables or returns\r\n // an observable, the dependency is tracked, and those observables can later cause the binding\r\n // context to be updated.\r\n var dataItemOrObservable = isFunc ? realDataItemOrAccessor() : realDataItemOrAccessor;\r\n var dataItem = unwrap(dataItemOrObservable);\r\n if (parentContext) {\r\n // When a \"parent\" context is given, register a dependency on the parent context. Thus whenever the\r\n // parent context is updated, this context will also be updated.\r\n if (parentContext[contextSubscribeSymbol]) {\r\n parentContext[contextSubscribeSymbol]();\r\n }\r\n // Copy $root and any custom properties from the parent context\r\n extend(self, parentContext);\r\n // Copy Symbol properties\r\n if (contextAncestorBindingInfo in parentContext) {\r\n self[contextAncestorBindingInfo] = parentContext[contextAncestorBindingInfo];\r\n }\r\n }\r\n else {\r\n self.$parents = [];\r\n self.$root = dataItem;\r\n }\r\n self[contextSubscribeSymbol] = subscribable$$1;\r\n if (shouldInheritData) {\r\n dataItem = self.$data;\r\n }\r\n else {\r\n self.$rawData = dataItemOrObservable;\r\n self.$data = dataItem;\r\n }\r\n if (dataItemAlias) {\r\n self[dataItemAlias] = dataItem;\r\n }\r\n // The extendCallback function is provided when creating a child context or extending a context.\r\n // It handles the specific actions needed to finish setting up the binding context. Actions in this\r\n // function could also add dependencies to this binding context.\r\n if (extendCallback) {\r\n extendCallback(self, parentContext, dataItem);\r\n }\r\n return self.$data;\r\n }\r\n if (settings && settings.exportDependencies) {\r\n // The \"exportDependencies\" option means that the calling code will track any dependencies and re-create\r\n // the binding context when they change.\r\n updateContext();\r\n }\r\n else {\r\n subscribable$$1 = pureComputed(updateContext);\r\n subscribable$$1.peek();\r\n // At this point, the binding context has been initialized, and the \"subscribable\" computed observable is\r\n // subscribed to any observables that were accessed in the process. If there is nothing to track, the\r\n // computed will be inactive, and we can safely throw it away. If it's active, the computed is stored in\r\n // the context object.\r\n if (subscribable$$1.isActive()) {\r\n self[contextSubscribeSymbol] = subscribable$$1;\r\n // Always notify because even if the model ($data) hasn't changed, other context properties might have changed\r\n subscribable$$1['equalityComparer'] = null;\r\n }\r\n else {\r\n self[contextSubscribeSymbol] = undefined;\r\n }\r\n }\r\n}\r\nObject.assign(bindingContext.prototype, {\r\n lookup: function (token, globals, node) {\r\n // short circuits\r\n switch (token) {\r\n case '$element': return node;\r\n case '$context': return this;\r\n case 'this':\r\n case '$data': return this.$data;\r\n }\r\n var $data = this.$data;\r\n // instanceof Object covers 1. {}, 2. [], 3. function() {}, 4. new *; it excludes undefined, null, primitives.\r\n if ($data instanceof Object && token in $data) {\r\n return $data[token];\r\n }\r\n if (token in this) {\r\n return this[token];\r\n }\r\n if (token in globals) {\r\n return globals[token];\r\n }\r\n throw new Error(\"The variable \\\"\" + token + \"\\\" was not found on $data, $context, or globals.\");\r\n },\r\n // Extend the binding context hierarchy with a new view model object. If the parent context is watching\r\n // any observables, the new child context will automatically get a dependency on the parent context.\r\n // But this does not mean that the $data value of the child context will also get updated. If the child\r\n // view model also depends on the parent view model, you must provide a function that returns the correct\r\n // view model on each update.\r\n createChildContext: function (dataItemOrAccessor, dataItemAlias, extendCallback, settings) {\r\n return new bindingContext(dataItemOrAccessor, this, dataItemAlias, function (self, parentContext) {\r\n // Extend the context hierarchy by setting the appropriate pointers\r\n self.$parentContext = parentContext;\r\n self.$parent = parentContext.$data;\r\n self.$parents = (parentContext.$parents || []).slice(0);\r\n self.$parents.unshift(self.$parent);\r\n if (extendCallback) {\r\n extendCallback(self);\r\n }\r\n }, settings);\r\n },\r\n // Extend the binding context with new custom properties. This doesn't change the context hierarchy.\r\n // Similarly to \"child\" contexts, provide a function here to make sure that the correct values are set\r\n // when an observable view model is updated.\r\n extend: function (properties) {\r\n // If the parent context references an observable view model, \"_subscribable\" will always be the\r\n // latest view model object. If not, \"_subscribable\" isn't set, and we can use the static \"$data\" value.\r\n return new bindingContext(inheritParentIndicator, this, null, function (self, parentContext) {\r\n extend(self, typeof properties === 'function' ? properties.call(self) : properties);\r\n });\r\n },\r\n createStaticChildContext: function (dataItemOrAccessor, dataItemAlias) {\r\n return this.createChildContext(dataItemOrAccessor, dataItemAlias, null, { 'exportDependencies': true });\r\n }\r\n});\r\nfunction storedBindingContextForNode(node) {\r\n var bindingInfo = domData.get(node, boundElementDomDataKey$1);\r\n return bindingInfo && bindingInfo.context;\r\n}\r\n// Retrieving binding context from arbitrary nodes\r\nfunction contextFor(node) {\r\n // We can only do something meaningful for elements and comment nodes (in particular, not text nodes, as IE can't store domdata for them)\r\n if (node && (node.nodeType === 1 || node.nodeType === 8)) {\r\n return storedBindingContextForNode(node);\r\n }\r\n}\r\nfunction dataFor(node) {\r\n var context = contextFor(node);\r\n return context ? context.$data : undefined;\r\n}\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = Object.setPrototypeOf ||\r\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n\r\nfunction __extends(d, b) {\r\n extendStatics(d, b);\r\n function __() { this.constructor = d; }\r\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nfunction __awaiter(thisArg, _arguments, P, generator) {\r\n return new (P || (P = Promise))(function (resolve, reject) {\r\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n });\r\n}\r\n\r\nfunction __generator(thisArg, body) {\r\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n function verb(n) { return function (v) { return step([n, v]); }; }\r\n function step(op) {\r\n if (f) throw new TypeError(\"Generator is already executing.\");\r\n while (_) try {\r\n if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n if (y = 0, t) op = [op[0] & 2, t.value];\r\n switch (op[0]) {\r\n case 0: case 1: t = op; break;\r\n case 4: _.label++; return { value: op[1], done: false };\r\n case 5: _.label++; y = op[1]; op = [0]; continue;\r\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n default:\r\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n if (t[2]) _.ops.pop();\r\n _.trys.pop(); continue;\r\n }\r\n op = body.call(thisArg, _);\r\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n }\r\n}\r\n\r\nfunction __values(o) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n if (m) return m.call(o);\r\n return {\r\n next: function () {\r\n if (o && i >= o.length) o = void 0;\r\n return { value: o && o[i++], done: !o };\r\n }\r\n };\r\n}\r\n\r\nfunction __read(o, n) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n if (!m) return o;\r\n var i = m.call(o), r, ar = [], e;\r\n try {\r\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n }\r\n catch (error) { e = { error: error }; }\r\n finally {\r\n try {\r\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n }\r\n finally { if (e) throw e.error; }\r\n }\r\n return ar;\r\n}\r\n\r\nfunction __spread() {\r\n for (var ar = [], i = 0; i < arguments.length; i++)\r\n ar = ar.concat(__read(arguments[i]));\r\n return ar;\r\n}\n\nvar BindingResult = /** @class */ (function () {\r\n function BindingResult(_a) {\r\n var asyncBindingsApplied = _a.asyncBindingsApplied, rootNode = _a.rootNode, bindingContext = _a.bindingContext;\r\n Object.assign(this, {\r\n rootNode: rootNode,\r\n bindingContext: bindingContext,\r\n isSync: asyncBindingsApplied.size === 0,\r\n isComplete: this.isSync\r\n });\r\n if (!this.isSync) {\r\n this.completionPromise = this.completeWhenBindingsFinish(asyncBindingsApplied);\r\n }\r\n }\r\n BindingResult.prototype.completeWhenBindingsFinish = function (asyncBindingsApplied) {\r\n return __awaiter(this, void 0, void 0, function () {\r\n return __generator(this, function (_a) {\r\n switch (_a.label) {\r\n case 0: return [4 /*yield*/, Promise.all(asyncBindingsApplied)];\r\n case 1:\r\n _a.sent();\r\n this.isComplete = true;\r\n return [2 /*return*/, this];\r\n }\r\n });\r\n });\r\n };\r\n return BindingResult;\r\n}());\n\nvar BindingHandler = /** @class */ (function (_super) {\r\n __extends(BindingHandler, _super);\r\n function BindingHandler(params) {\r\n var _this = _super.call(this) || this;\r\n var $element = params.$element, valueAccessor = params.valueAccessor, allBindings = params.allBindings, $context = params.$context;\r\n Object.assign(_this, {\r\n valueAccessor: valueAccessor,\r\n allBindings: allBindings,\r\n $element: $element,\r\n $context: $context,\r\n $data: $context.$data\r\n });\r\n _this.anchorTo($element);\r\n return _this;\r\n }\r\n Object.defineProperty(BindingHandler.prototype, \"value\", {\r\n get: function () { return this.valueAccessor(); },\r\n set: function (v) { return this.valueAccessor(v); },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n Object.defineProperty(BindingHandler.prototype, \"controlsDescendants\", {\r\n get: function () { return false; },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n Object.defineProperty(BindingHandler, \"allowVirtualElements\", {\r\n get: function () { return false; },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n Object.defineProperty(BindingHandler, \"isBindingHandlerClass\", {\r\n get: function () { return true; },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n Object.defineProperty(BindingHandler.prototype, \"bindingCompleted\", {\r\n /* Overload this for asynchronous bindings or bindings that recursively\r\n apply bindings (e.g. components, foreach, template).\r\n \n A binding should be complete when it has run through once, notably\r\n in server-side bindings for pre-rendering.\r\n */\r\n get: function () { return true; },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n BindingHandler.registerAs = function (name, provider) {\r\n if (provider === void 0) { provider = options.bindingProviderInstance; }\r\n provider.bindingHandlers.set(name, this);\r\n };\r\n return BindingHandler;\r\n}(LifeCycle));\r\n/**\r\n * An AsyncBindingHandler shall call `completeBinding` when the binding\r\n * is to be considered complete.\r\n */\r\nvar ResolveSymbol = Symbol('Async Binding Resolved');\r\nvar AsyncBindingHandler = /** @class */ (function (_super) {\r\n __extends(AsyncBindingHandler, _super);\r\n function AsyncBindingHandler(params) {\r\n var _this = _super.call(this, params) || this;\r\n _this.bindingCompletion = new Promise(function (resolve) {\r\n _this[ResolveSymbol] = resolve;\r\n });\r\n _this.completeBinding = function (bindingResult) { return _this[ResolveSymbol](bindingResult); };\r\n return _this;\r\n }\r\n Object.defineProperty(AsyncBindingHandler.prototype, \"bindingCompleted\", {\r\n get: function () { return this.bindingCompletion; },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n return AsyncBindingHandler;\r\n}(BindingHandler));\n\n/**\r\n * We have no guarantees, for users employing legacy bindings,\r\n * that it has not been changed with a modification like\r\n *\r\n * ko.bindingHandlers[name] = { init: ...}\r\n *\r\n * ... so we have to keep track by way of a map.\r\n */\r\nvar PossibleWeakMap = options.global.WeakMap || Map;\r\nvar legacyBindingMap = new PossibleWeakMap();\r\nvar LegacyBindingHandler = /** @class */ (function (_super) {\r\n __extends(LegacyBindingHandler, _super);\r\n function LegacyBindingHandler(params) {\r\n var _this = _super.call(this, params) || this;\r\n var handler = _this.handler;\r\n _this.onError = params.onError;\r\n if (typeof handler.dispose === 'function') {\r\n _this.addDisposable(handler);\r\n }\r\n try {\r\n _this.initReturn = handler.init && handler.init.apply(handler, __spread(_this.legacyArgs));\r\n }\r\n catch (e) {\r\n params.onError('init', e);\r\n }\r\n return _this;\r\n }\r\n LegacyBindingHandler.prototype.onValueChange = function () {\r\n var handler = this.handler;\r\n if (typeof handler.update !== 'function') {\r\n return;\r\n }\r\n try {\r\n handler.update.apply(handler, __spread(this.legacyArgs));\r\n }\r\n catch (e) {\r\n this.onError('update', e);\r\n }\r\n };\r\n Object.defineProperty(LegacyBindingHandler.prototype, \"legacyArgs\", {\r\n get: function () {\r\n return [\r\n this.$element, this.valueAccessor, this.allBindings,\r\n this.$data, this.$context\r\n ];\r\n },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n Object.defineProperty(LegacyBindingHandler.prototype, \"controlsDescendants\", {\r\n get: function () {\r\n var objectToTest = this.initReturn || this.handler || {};\r\n return objectToTest.controlsDescendantBindings;\r\n },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n /**\r\n * Create a handler instance from the `origin`, which may be:\r\n *\r\n * 1. an object (becomes LegacyBindingHandler)\r\n * 2. a function (becomes LegacyBindingHandler with `init: function`)\r\n *\r\n * If given an object (the only kind supported in knockout 3.x and before), it\r\n * shall draw the `init`, `update`, and `allowVirtualElements` properties\r\n */\r\n LegacyBindingHandler.getOrCreateFor = function (key, handler) {\r\n if (legacyBindingMap.has(handler)) {\r\n return legacyBindingMap.get(handler);\r\n }\r\n var newLegacyHandler = this.createFor(key, handler);\r\n legacyBindingMap.set(handler, newLegacyHandler);\r\n return newLegacyHandler;\r\n };\r\n LegacyBindingHandler.createFor = function (key, handler) {\r\n if (typeof handler === 'function') {\r\n var _a = __read([handler, handler.dispose], 2), initFn_1 = _a[0], disposeFn_1 = _a[1];\r\n return /** @class */ (function (_super) {\r\n __extends(class_1, _super);\r\n function class_1() {\r\n return _super !== null && _super.apply(this, arguments) || this;\r\n }\r\n Object.defineProperty(class_1.prototype, \"handler\", {\r\n get: function () {\r\n var init = initFn_1.bind(this);\r\n var dispose = disposeFn_1 ? disposeFn_1.bind(this) : null;\r\n return { init: init, dispose: dispose };\r\n },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n Object.defineProperty(class_1, \"after\", {\r\n get: function () { return handler.after; },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n Object.defineProperty(class_1, \"allowVirtualElements\", {\r\n get: function () {\r\n return handler.allowVirtualElements || virtualElements.allowedBindings[key];\r\n },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n return class_1;\r\n }(LegacyBindingHandler));\r\n }\r\n if (typeof handler === 'object') {\r\n return /** @class */ (function (_super) {\r\n __extends(class_2, _super);\r\n function class_2() {\r\n return _super !== null && _super.apply(this, arguments) || this;\r\n }\r\n Object.defineProperty(class_2.prototype, \"handler\", {\r\n get: function () { return handler; },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n Object.defineProperty(class_2, \"after\", {\r\n get: function () { return handler.after; },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n Object.defineProperty(class_2, \"allowVirtualElements\", {\r\n get: function () {\r\n return handler.allowVirtualElements || virtualElements.allowedBindings[key];\r\n },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n return class_2;\r\n }(LegacyBindingHandler));\r\n }\r\n throw new Error('The given handler is not an appropriate type.');\r\n };\r\n return LegacyBindingHandler;\r\n}(BindingHandler));\n\n/* eslint no-cond-assign: 0 */\r\n// The following element types will not be recursed into during binding.\r\nvar bindingDoesNotRecurseIntoElementTypes = {\r\n // Don't want bindings that operate on text nodes to mutate