{"version":3,"file":"polyfills.ad34453136ad8c80.js","mappings":"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","names":["environment","urlConfig","serviceUrl","signalRBaseUrl","reportingUrl","myMarketInfoUrl","launchpadUrl","yellowLogoutUrl","restrictedReportingUrls","frontAppUrl","testConfig","testMessage","showTestMessage","logToConsole","usernamesChangedForTesting","defaultPartnerConfig","id","name","logoLargeS3Url","logoSmallS3Url","logToGoogleAnalytics","logToDevGoogleAnalytics","disableAngularDebugChecks","jsBuildDate","BLOCK_MARKER$1","Error","$localize$1","messageParts","expressions","translate","translation","message","stripBlock","raw","i","length","BLOCK_MARKER","messagePart","rawMessagePart","charAt","substring","findEndOfBlock","cooked","cookedIndex","rawIndex","globalThis","$localize","ɵ$localize","window","global","__symbol__","__Zone_symbol_prefix","ObjectGetOwnPropertyDescriptor","Object","getOwnPropertyDescriptor","ObjectDefineProperty","defineProperty","ObjectGetPrototypeOf","getPrototypeOf","ObjectCreate","create","ArraySlice","Array","prototype","slice","ADD_EVENT_LISTENER_STR","REMOVE_EVENT_LISTENER_STR","ZONE_SYMBOL_ADD_EVENT_LISTENER","ZONE_SYMBOL_REMOVE_EVENT_LISTENER","TRUE_STR","FALSE_STR","ZONE_SYMBOL_PREFIX","wrapWithCurrentZone","callback","source","Zone","current","wrap","scheduleMacroTaskWithCurrentZone","data","customSchedule","customCancel","scheduleMacroTask","zoneSymbol","isWindowExists","internalWindow","undefined","_global","REMOVE_ATTRIBUTE","bindArguments","args","isPropertyWritable","propertyDesc","writable","get","set","isWebWorker","WorkerGlobalScope","self","isNode","process","toString","isBrowser","HTMLElement","isMix","zoneSymbolEventNames$1","enableBeforeunloadSymbol","wrapFn","event","eventNameSymbol","type","target","this","listener","result","call","filename","lineno","colno","error","preventDefault","apply","arguments","returnValue","patchProperty","obj","prop","desc","enumerable","configurable","onPropPatchedSymbol","hasOwnProperty","value","originalDescGet","originalDescSet","eventName","newValue","removeEventListener","addEventListener","removeAttribute","patchOnProperties","properties","onProperties","push","j","originalInstanceKey","patchClass","className","OriginalClass","a","attachOriginToPatched","instance","fn","patchMethod","patchFn","proto","delegateName","delegate","patchDelegate","patchMacroTask","funcName","metaCreator","setNative","scheduleTask","task","cbIdx","invoke","meta","patched","original","isDetectedIEOrEdge","ieOrEdge","isIEOrEdge","ua","navigator","userAgent","indexOf","isFunction","isNumber","passiveSupported","options","OPTIMIZED_ZONE_EVENT_TASK_DATA","useG","zoneSymbolEventNames","globalSources","EVENT_NAME_SYMBOL_REGX","RegExp","IMMEDIATE_PROPAGATION_SYMBOL","prepareEventNames","eventNameToString","falseEventName","trueEventName","symbol","symbolCapture","patchEventTarget","api","apis","patchOptions","ADD_EVENT_LISTENER","add","REMOVE_EVENT_LISTENER","rm","LISTENERS_EVENT_LISTENER","listeners","REMOVE_ALL_LISTENERS_EVENT_LISTENER","rmAll","zoneSymbolAddEventListener","ADD_EVENT_LISTENER_SOURCE","PREPEND_EVENT_LISTENER","PREPEND_EVENT_LISTENER_SOURCE","invokeTask","isRemoved","handleEvent","originalDelegate","err","once","globalCallback","context","isCapture","tasks","errors","copyTasks","nativeScheduleMicroTask","globalZoneAwareCallback","globalZoneAwareCaptureCallback","patchEventTargetMethods","useGlobalCallback","validateHandler","vh","checkDuplicate","chkDup","returnTarget","rt","taskData","nativeAddEventListener","nativeRemoveEventListener","nativeListeners","nativeRemoveAllListeners","nativePrependEventListener","prepend","isExisting","capture","symbolEventNames","symbolEventName","existingTasks","splice","removeAbortListener","allRemoved","compare","diff","typeOfDelegate","unpatchedEvents","passiveEvents","makeAddListener","nativeListener","addSource","customScheduleFn","customCancelFn","transferEventName","isHandleEvent","passive","copyEventListenerOptions","newOptions","signal","buildEventListenerOptions","aborted","zone","constructorName","constructor","targetSource","scheduleEventTask","onAbort","cancelTask","unshift","existingTask","findEventTasks","captureTasks","removeTasks","keys","match","exec","evtName","results","foundTasks","captureFalseTasks","captureTrueTasks","concat","patchEventPrototype","Event","taskSymbol","patchTimer","setName","cancelName","nameSuffix","clearNative","tasksByHandleId","handleOrId","handleId","handle","isRefreshable","refresh","clearTask","isPeriodic","delay","originalRefresh","state","_state","_updateTaskCount","cancelFn","filterProperties","ignoreProperties","tip","filter","ip","targetIgnoreProperties","op","patchFilteredProperties","getOnEventNames","getOwnPropertyNames","startsWith","map","patchCallbacks","targetName","method","callbacks","nativeDelegate","opts","forEach","descriptor","_redefineProperty","Zone$1","loadZone","initZone","performance","mark","performanceMeasure","label","measure","ZoneImpl","static","assertZonePatched","Promise","patches","ZoneAwarePromise","root","parent","_currentZoneFrame","currentTask","_currentTask","__load_patch","ignoreDuplicate","perfName","_api","_parent","_name","zoneSpec","_properties","_zoneDelegate","_ZoneDelegate","key","getZoneWith","fork","_callback","intercept","runGuarded","run","applyThis","applyArgs","handleError","runTask","NO_ZONE","zoneTask","notScheduled","eventTask","macroTask","reEntryGuard","running","_transitionTo","scheduled","previousTask","unknown","scheduling","zoneDelegates","_zoneDelegates","newZone","_zone","scheduleMicroTask","ZoneTask","microTask","canceling","runCount","count","DELEGATE_ZS","onHasTask","_","hasTaskState","hasTask","onScheduleTask","onInvokeTask","onCancelTask","parentDelegate","_taskCounts","_parentDelegate","_forkZS","onFork","_forkDlgt","_forkCurrZone","_interceptZS","onIntercept","_interceptDlgt","_interceptCurrZone","_invokeZS","onInvoke","_invokeDlgt","_invokeCurrZone","_handleErrorZS","onHandleError","_handleErrorDlgt","_handleErrorCurrZone","_scheduleTaskZS","_scheduleTaskDlgt","_scheduleTaskCurrZone","_invokeTaskZS","_invokeTaskDlgt","_invokeTaskCurrZone","_cancelTaskZS","_cancelTaskDlgt","_cancelTaskCurrZone","_hasTaskZS","_hasTaskDlgt","_hasTaskDlgtOwner","_hasTaskCurrZone","zoneSpecHasTask","targetZone","returnTask","scheduleFn","isEmpty","counts","prev","next","change","_numberOfNestedTaskFrames","drainMicroTaskQueue","cancelScheduleRequest","toState","fromState1","fromState2","toJSON","symbolSetTimeout","symbolPromise","symbolThen","nativeMicroTaskQueuePromise","_microTaskQueue","_isDrainingMicrotaskQueue","func","resolve","nativeThen","then","queue","onUnhandledError","microtaskDrainDone","currentZoneFrame","noop","showUncaughtError","patchThen","getGlobalObjects","patchCommon","patchPromise","_uncaughtPromiseErrors","isDisableWrappingUncaughtPromiseRejection","creationTrace","e","rejection","console","stack","uncaughtPromiseError","shift","throwOriginal","handleUnhandledRejection","UNHANDLED_PROMISE_REJECTION_HANDLER_SYMBOL","handler","isThenable","forwardResolution","forwardRejection","reject","symbolState","symbolValue","symbolFinally","symbolParentPromiseValue","symbolParentPromiseState","UNRESOLVED","RESOLVED","REJECTED","REJECTED_NO_CATCH","makeResolver","promise","v","resolvePromise","wasCalled","wrappedFunction","TYPE_ERROR","CURRENT_TASK_TRACE_SYMBOL","onceWrapper","TypeError","clearRejectedNoCatch","trace","scheduleResolveOrReject","readableObjectToString","JSON","stringify","REJECTION_HANDLED_HANDLER","chainPromise","onFulfilled","onRejected","promiseState","parentPromiseValue","isFinallyPromise","AggregateError","withResolvers","res","rej","any","values","Symbol","iterator","promises","finished","race","onResolve","onReject","all","allWithCallback","allSettled","thenCallback","status","errorCallback","reason","unresolvedCount","valueIndex","resolvedValues","curValueIndex","thenErr","executor","toStringTag","species","C","catch","finally","onFinally","NativePromise","symbolThenPatched","Ctor","originalThen","zoneify","resultPromise","ctor","patchToString","originalFunctionToString","Function","ORIGINAL_DELEGATE_SYMBOL","PROMISE_SYMBOL","ERROR_SYMBOL","newFunctionToString","nativePromise","nativeError","originalObjectToString","patchUtil","eventNames","SYMBOL_BLACK_LISTED_EVENTS","SYMBOL_UNPATCHED_EVENTS","patchBrowser","legacyPatch","clear","blockingMethods","s","patchEvent","eventTargetPatch","EVENT_TARGET","EventTarget","XMLHttpRequestEventTarget","propertyDescriptorPatch","__Zone_ignore_on_properties","patchTargets","ignoreErrorProperties","isIE","patchCustomElements","customElements","patchXHR","XMLHttpRequest","XMLHttpRequestPrototype","oriAddListener","oriRemoveListener","XMLHttpRequestEventTargetPrototype","READY_STATE_CHANGE","SCHEDULED","XHR_SCHEDULED","XHR_ERROR_BEFORE_SCHEDULED","XHR_LISTENER","newListener","readyState","DONE","loadTasks","oriInvoke","XHR_TASK","sendNative","placeholderCallback","abortNative","openNative","XHR_SYNC","XHR_URL","fetchTaskAborting","fetchTaskScheduling","url","findPendingTask","geolocation","patchPrototype","fnNames","findPromiseRejectionHandler","PromiseRejectionEvent","evt","patchQueueMicrotask","subscriptions","amplify","publish","topic","topicSubscriptions","subscription","ret","subscribe","priority","added","topicIndex","topics","split","topicLength","subscriptionInfo","unsubscribe","store","types","addType","storage","rprefix","createFromStorageInterface","storageType","storedValue","parsed","remove","now","Date","getTime","test","parse","getItem","expires","replace","pop","removeItem","setItem","webStorageType","localStorage","sessionStorage","globalStorage","location","hostname","div","document","createElement","attrKey","style","display","getElementsByTagName","appendChild","addBehavior","load","parentNode","removeChild","attr","prevValue","XMLDocument","documentElement","attributes","save","getAttribute","setAttribute","userData","memory","timeout","copy","clearTimeout","setTimeout","async","isAsync","that","request","resourceId","settings","success","abort","resource","resources","define","$","xhrProps","rurlData","ajax","defnSettings","extend","xhr","ajaxSettings","ampXHR","setRequestHeader","getAllResponseHeaders","getResponseHeader","overrideMimeType","overrideMideType","handleResponse","each","statusText","_xhr","beforeSend","_ajaxSettings","mappedKeys","m","dataMap","orig","cache","_key","checksum","chunk","charCodeAt","_default","memoryStore","cacheKey","duration","cached","persist","cacheType","decoders","jsend","_success","_error","decoder","jQuery","n","t","r","u","f","b","k","tryBuffer","signalR","connectionState","connecting","drain","connected","nojQuery","noTransportOnInit","errorOnNegotiate","stoppedWhileLoading","stoppedWhileNegotiating","errorParsingNegotiateResponse","errorDuringStartRequest","stoppedDuringStartRequest","errorParsingStartResponse","invalidStartResponse","protocolIncompatible","sendFailed","parseFailed","longPollFailed","eventSourceFailedToConnect","eventSourceError","webSocketClosed","pingServerFailedInvalidResponse","pingServerFailed","pingServerFailedStatusCode","pingServerFailedParse","noConnectionTransport","webSocketsInvalidState","reconnectTimeout","reconnectWindowTimeout","h","c","onStart","onStarting","onReceived","onError","onConnectionSlow","onReconnecting","onReconnect","onStateChanged","onDisconnect","o","triggerHandler","oldState","newState","l","keepAliveData","activated","transport","supportsKeepAlive","init","defaultContentType","ieVersion","appName","parseFloat","transportError","format","firefoxMajorVersion","parseInt","configurePingInterval","config","pingIntervalId","pingInterval","setInterval","transports","_logic","pingServer","fail","events","ajaxDefaults","processData","changeState","isDisconnecting","disconnected","reconnecting","hub","start","qs","lastError","connectingMessageBuffer","lastMessageAt","lastActiveAt","beatInterval","beatHandle","totalTransportConnectTimeout","logging","_parseResponse","json","_originalJson","isCrossDomain","trim","href","protocol","host","ajaxDataType","contentType","clientProtocol","reconnectDelay","transportConnectTimeout","disconnectTimeout","reconnectWindow","keepAliveWarnAt","d","g","waitForPageLoad","jsonp","y","_deferral","Deferred","w","isArray","log","configuredStopReconnectingTimeout","stop","stateChanged","p","baseUrl","wsProtocol","withCredentials","support","cors","bind","initHandler","monitorKeepAlive","startHeartbeat","negotiateRequest","prepareQueryString","appRelativeUrl","Url","ConnectionId","token","ConnectionToken","webSocketServerUrl","WebSocketServerUrl","pollTimeout","ConnectionTimeout","DisconnectTimeout","TransportConnectTimeout","KeepAliveTimeout","timeoutWarning","ProtocolVersion","TryWebSockets","inArray","deferredStartHandler","starting","send","received","connectionSlow","reconnected","unbind","clearInterval","stopMonitoringKeepAlive","messageId","groupsToken","toTimeString","debug","noConflict","connection","monitoring","lostConnection","userNotified","markActive","startRequested","startCompleted","connectionStopped","transportTimeoutHandle","transportFailed","initReceived","tryAbortStartRequest","ajaxStart","xhrFields","dataType","addQs","Response","encodeURIComponent","param","getUrl","Math","floor","random","maximizePersistentResponse","MessageId","Messages","M","Initialized","S","ShouldReconnect","T","LongPollDelay","L","GroupsToken","G","updateGroups","stringifySend","ajaxSend","triggerReceived","ajaxAbort","startRequest","tryInitialize","processMessages","markLastMessage","reconnectKeepAliveUpdate","verifyLastActive","isConnectedOrReconnecting","ensureReconnectingState","clearReconnectTimeout","reconnect","handleParseFailure","foreverFrame","connections","webSockets","socket","WebSocket","onopen","onclose","wasClean","onmessage","isEmptyObject","close","reconnectAttemptTimeoutHandle","serverSentEvents","timeOut","eventSource","EventSource","Message","OPEN","eventPhase","CLOSED","prevent","body","cancel","iframeClearThreshold","attachEvent","src","frame","frameId","onSuccess","receive","frameMessageCount","contentWindow","contentDocument","firstChild","execCommand","getConnection","started","longPolling","reconnectTimeoutId","pollXhr","pollTimeoutId","onprogress","responseText","min","pow","invocationCallbacks","invocationCallbackId","scope","E","useDefaultPath","hubName","callbackMap","hasSubscriptions","on","toLowerCase","off","makeArray","H","A","I","_maximizeHubResponse","State","Progress","notifyWith","Data","progressjQueryVersionLogged","jquery","StackTrace","IsHubException","ErrorData","rejectWith","resolveWith","Result","R","P","Id","D","proxies","_maximizeClientHubInvocation","Method","Hub","Args","_registerSubscribedHubs","_subscribedToHubs","createHubProxy","hubConnection","version","koExports","ko","exportSymbol","koPath","object","tokens","exportProperty","owner","publicName","utils","stringTrimRegex","knownEvents","knownEventTypesByEventName","keyEventTypeName","eventType","MouseEvents","knownEventsForType","eventsThatMustBeRegisteredUsingAttachEvent","propertychange","iElems","innerHTML","isClickOnCheckableElement","element","tagNameLower","inputType","fieldsIncludedWithJsonPost","arrayForEach","array","action","arrayIndexOf","item","arrayFirst","predicate","predicateOwner","arrayRemoveItem","itemToRemove","index","arrayGetDistinctValues","arrayMap","mapping","arrayFilter","arrayPushAll","valuesToPush","emptyDomNode","domNode","removeNode","moveCleanedNodesToContainerElement","nodes","nodesArray","container","cleanNode","cloneNodes","shouldCleanNodes","newNodesArray","clonedNode","cloneNode","setDomNodeChildren","childNodes","replaceDomNodes","nodeToReplaceOrNodeArray","nodesToReplaceArray","nodeType","insertionPoint","insertBefore","setOptionNodeSelectionState","optionNode","isSelected","selected","stringTrim","string","stringTokenize","delimiter","trimmed","stringStartsWith","domNodeIsContainedBy","node","containedByNode","compareDocumentPosition","domNodeIsAttachedToDocument","ownerDocument","tagName","registerEventHandler","mustUseAttachEvent","originalHandler","eventData","jQuerySuppliedCheckedState","checked","checkedStateBeforeEvent","triggerEvent","trigger","createEvent","dispatchEvent","initEvent","fireEvent","unwrapObservable","isObservable","peekObservable","peek","toggleDomNodeCssClass","classNames","shouldHaveClass","cssClassNameRegex","currentClassNames","indexOfClass","join","setTextContent","textContent","innerTextNode","virtualElements","nextSibling","createTextNode","forceRefresh","setElementName","mergeAttributes","elem","zoom","ensureSelectElementIsRenderedCorrectly","selectElement","originalWidth","width","range","max","arrayLikeObject","isIe6","isIe7","getFormFields","form","fieldName","fields","isMatchingField","field","matches","parseJson","jsonString","stringifyJson","replacer","space","postJson","urlOrForm","params","includeFields","originalForm","input","submitter","submit","originalFunction","domData","uniqueId","dataStoreKeyExpandoPropertyName","dataStore","allDataForNode","getAll","createIfNotFound","dataStoreKey","domNodeDisposal","domDataKey","cleanableNodeTypes","cleanableNodeTypesWithDescendants","getDisposeCallbacksCollection","allDisposeCallbacks","cleanSingleNode","cleanData","cleanImmediateCommentTypeChildren","nodeWithChildren","child","nextChild","addDisposeCallback","removeDisposeCallback","callbacksCollection","destroyCallbacksCollection","descendants","parseHtmlFragment","html","jQueryHtmlParse","parseHTML","elems","clean","simpleHtmlParse","tags","markup","innerShiv","lastChild","setHtml","parsedNodes","memoization","memos","randomMax8HexChars","findMemoNodes","rootNode","appendToArray","memoId","parseMemoText","nodeValue","memoize","generateRandomId","unmemoize","callbackParams","unmemoizeDomNodeAndDescendants","extraCallbackParamsArray","combinedParams","memoText","extenders","throttle","throttleEvaluation","writeTimeoutInstance","dependentObservable","read","write","notify","notifyWhen","equalityComparer","observable","disposeCallback","dispose","isDisposed","subscribable","_subscriptions","getSubscriptionsCount","defaultEvent","callbackTarget","boundCallback","notifySubscribers","valueToNotify","dependencyDetection","ignore","total","applyExtenders","requestedExtenders","extenderHandler","isSubscribable","_frames","begin","distinctDependencies","end","registerDependency","topFrame","callbackArgs","primitiveTypes","boolean","number","initialValue","_latestValue","valueWillMutate","valueHasMutated","protoProperty","hasPrototype","isWriteableObservable","hasWriteFunction","observableArray","initialValues","valueOrPredicate","underlyingArray","removedValues","removeAll","arrayOfValues","allValues","destroy","_destroy","destroyAll","oldItem","newItem","methodName","methodCallResult","evaluatorFunctionOrOptions","evaluatorFunctionTarget","_hasBeenEvaluated","_isBeingEvaluated","readFunction","disposeAllSubscriptionsToDependencies","_subscriptionsToDependencies","evaluatePossiblyAsync","throttleEvaluationTimeout","evaluationTimeoutInstance","evaluateImmediate","disposeWhen","disposalCandidates","inOld","addSubscriptionToDependency","writeFunction","isActive","disposeWhenNodeIsRemoved","getDependenciesCount","deferEvaluation","callee","existingDisposeWhenFunction","isComputed","hasDomDataExpandoProperty","protoProp","mapJsObjectGraph","rootObject","mapInputCallback","visitedObjects","objectLookup","outputProperties","visitPropertiesOrArrayEntries","visitorCallback","propertyName","indexer","propertyValue","previouslyMappedValue","existingIndex","toJS","valueToMap","plainJavaScriptObject","selectExtensions","readValue","bindingHandlers","optionValueDomDataKey","getAttributeNode","specified","text","selectedIndex","writeValue","expressionRewriting","restoreCapturedTokensRegex","javaScriptReservedWords","javaScriptAssignmentTarget","restoreTokens","tokenIndex","getWriteableValue","expression","ensureQuoted","trimmedKey","bindingRewriteValidators","parseObjectLiteral","objectLiteralString","str","tokenEndChar","tokenStart","position","replacement","tokenDepth","tokenStartChar","keyValuePairs","pair","colonPos","preProcessBindings","objectLiteralStringOrKeyValueArray","keyValueEntry","keyValueArray","resultStrings","propertyAccessorResultStrings","quotedKey","val","combinedResult","keyValueArrayContainsKey","writeValueToProperty","property","allBindingsAccessor","checkIfDifferent","propWriters","_ko_property_writers","commentNodesHaveTextProperty","createComment","startCommentRegex","endCommentRegex","htmlTagsWithOptionallyClosingChildren","ul","ol","isStartComment","isEndComment","getVirtualChildren","startComment","allowUnbalanced","currentNode","depth","children","getMatchingEndComment","allVirtualChildren","getUnbalancedChildTags","childNode","captureRemaining","matchingEndComment","allowedBindings","emptyNode","virtualChildren","endCommentNode","containerNode","nodeToPrepend","insertAfter","nodeToInsert","insertAfterNode","virtualNodeBindingValue","regexMatch","normaliseVirtualElementDomStructure","elementVerified","unbalancedTags","nodeToInsertBefore","defaultBindingAttributeName","createBindingsStringEvaluatorViaCache","bindingsString","createBindingsStringEvaluator","rewrittenBindings","bindingProvider","bindingCache","nodeHasBindings","getBindings","bindingContext","getBindingsString","parseBindingsString","bindingFunction","ex","validateThatBindingIsAllowedForVirtualElements","bindingName","applyBindingsToDescendantsInternal","viewModel","elementOrVirtualElement","bindingContextsMayDifferFromDomParentElement","currentChild","nextInQueue","applyBindingsToNodeAndDescendantsInternal","nodeVerified","bindingContextMayDifferFromDomParentElement","shouldBindDescendants","isElement","applyBindingsToNodeInternal","bindings","viewModelOrBindingContext","parsedBindings","bindingHandlerThatControlsDescendantBindings","initPhase","makeValueAccessor","bindingKey","parsedBindingsAccessor","bindingContextInstance","$data","storedBindingContextForNode","evaluatedBindings","binding","initResult","handlerInitFn","controlsDescendantBindings","update","handlerUpdateFn","dataItem","parentBindingContext","dataItemAlias","$parentContext","$parent","$parents","$root","createChildContext","clone","storedBindingContextDomDataKey","applyBindingsToNode","applyBindingsToDescendants","applyBindings","contextFor","dataFor","attrHtmlToJavascriptMap","class","for","valueAccessor","attrName","attrValue","toRemove","valueToWrite","modelValue","unwrappedValue","existingEntryIndex","uniqueName","classesWrittenByBindingKey","css","String","enable","disabled","disable","eventsToHandle","eventNameOutsideClosure","handlerReturnValue","handlerFunction","allBindings","argsForHandler","cancelBubble","stopPropagation","foreach","makeTemplateValueAccessor","as","includeDestroyed","afterAdd","beforeRemove","afterRender","beforeMove","afterMove","templateEngine","nativeTemplateEngine","template","hasfocusUpdatingProperty","hasfocus","handleElementFocusChange","isFocused","ownerDoc","activeElement","handleElementFocusIn","handleElementFocusOut","focus","blur","withIfDomDataKey","makeWithIfBinding","isWith","isNot","makeContextCallback","withIfData","dataValue","shouldDisplay","isFirstRender","savedNodes","didDisplayOnLastUpdate","ensureDropdownSelectionIsConsistentWithModelValue","preferModelValue","selectWasPreviouslyEmpty","previousSelectedValues","innerText","previousScrollTop","scrollTop","optionsIncludeDestroyed","optionsCaption","option","applyToObject","defaultValue","predicateType","arrayEntry","optionValue","optionsValue","optionText","optionsText","selectedOptions","styleName","styleValue","currentIndex","eventsToCatch","requestedEventsToCatch","valueUpdate","propertyChangedFired","valueUpdateHandler","elementValue","autocomplete","valueIsSelectOption","valueHasChanged","applyValueAction","visible","isCurrentlyVisible","makeEventHandlerShortcut","renderTemplateSource","templateSource","createJavaScriptEvaluatorBlock","script","makeTemplateSource","templateDocument","getElementById","templateSources","domElement","anonymousTemplate","renderTemplate","isTemplateRewritten","allowTemplateRewriting","rewriteTemplate","rewriterCallback","rewritten","templateRewriting","memoizeDataBindingAttributeSyntaxRegex","memoizeVirtualContainerBindingSyntaxRegex","constructMemoizedTagReplacement","dataBindAttributeValue","tagToRetain","dataBindKeyValueArray","validateDataBindValuesForRewriting","allValidators","validator","possibleErrorMessage","rewrittenDataBindAttributeValue","ensureTemplateIsRewritten","htmlString","memoizeBindingAttributeSyntax","applyMemoizedBindingsToNextSibling","elemContentsProperty","anonymousTemplatesDomDataKey","templateData","textData","containerData","_templateEngine","invokeForEachNodeOrCommentInContinuousRange","firstNode","lastNode","firstOutOfRangeNode","activateBindingsOnContinuousNodeArray","continuousNodeArray","getFirstNodeFromPossibleArray","nodeOrNodeArray","executeTemplate","targetNodeOrNodeArray","renderMode","firstTargetNode","templateEngineToUse","renderedNodesArray","haveAddedNodesToParent","setTemplateEngine","dataOrBindingContext","templateName","renderTemplateForEach","arrayOrObservableArray","targetNode","arrayItemContext","executeTemplateForArrayItem","arrayValue","$index","activateBindingsCallback","addedNodesArray","unwrappedArray","filteredArray","setDomNodeChildrenFromArrayMapping","templateComputedDomDataKey","bindingValue","templateNodes","templateComputed","if","ifnot","innerBindingContext","disposeOldComputedAndStoreNewOne","newComputed","oldComputed","parsedBindingValue","compareArrays","statusNotInOld","statusNotInNew","compareSmallArrayToBigArray","smlArray","bigArray","statusNotInSml","statusNotInBig","dontLimitMoves","smlIndex","bigIndex","thisRow","lastRow","bigIndexMaxForRow","myMin","myMax","editDistanceMatrix","smlIndexMax","bigIndexMax","compareRange","maxDistance","meMinusOne","editScript","notInSml","notInBig","failedCompares","notInSmlItem","notInBigItem","limitFailedCompares","moved","reverse","oldArray","newArray","fixUpNodesToBeMovedOrRemoved","contiguousNodeArray","last","newContiguousSet","mapNodeAndRefreshWhenChanged","callbackAfterAddingNodes","mappedNodes","newMappedNodes","lastMappingResultDomDataKey","mapData","isFirstExecution","lastMappingResult","lastArray","x","newMappingResult","lastMappingResultIndex","newMappingResultIndex","nodesToDelete","itemsToProcess","itemsForBeforeRemoveCallbacks","itemsForMoveCallbacks","itemsForAfterAddCallbacks","itemMovedOrRetained","editScriptIndex","oldPosition","indexObservable","callCallback","items","editScriptItem","movedIndex","nextNode","initialized","templateText","jqueryTmplTemplateEngine","jQueryTmplVersion","tmpl","tag","open","ensureHasReferencedJQueryTemplates","precompiled","resultNodes","compiledTemplate","jQueryTemplateOptions","koBindingContext","templateOptions","appendTo","fragments","addTemplate","templateMarkup","ko_code","ko_with","jqueryTmplTemplateEngineInstance","factory","exports","validation","seedId","defaults","registerExtenders","messagesOnModified","errorsAsTitle","errorsAsTitleOnModified","messageTemplate","insertMessages","parseInputAttributes","writeInputAttributes","decorateElement","decorateElementOnModified","errorClass","errorElementClass","errorMessageClass","grouping","deep","configuration","html5Attributes","html5InputTypes","isObject","getValue","hasAttribute","isValidatable","rules","isValid","isModified","newNode","newId","getConfigOptions","setDomData","getDomData","isEmptyVal","getOriginalElementTitle","savedOriginalTitle","currentTitle","title","isInitialized","force","configure","reset","group","validatables","traverse","level","objValues","validatable","computed","showAllMessages","show","isAnyMessageShown","invalidAndModifiedPresent","formatMessage","addRule","rule","addAnonymousRule","ruleObj","ruleName","addExtender","onlyIf","condition","insertValidationMessage","span","parseInputValidationAttributes","currentType","writeInputValidationAttributes","contexts","ctx","makeBindingHandlerValidatable","handlerName","validationCore","validateSync","__valid__","validateAsync","isValidating","valObj","msg","required","testVal","minLength","maxLength","pattern","regex","step","dif","abs","email","validate","date","dateISO","digit","equal","notEqual","unique","collection","external","externalValue","counter","expr","setImmediate","validationMessageElement","validationMessage","validationElement","obsv","shouldShow","validationOptions","newConfig","h_obsValidationTrigger","validateObservable","setError","clearError","h_change","_disposeValidation","ruleContexts","len","validatedObservable","localize","msgTranslations","applyBindingsWithValidation","origApplyBindings","previousUnderscore","breaker","ArrayProto","ObjProto","nativeForEach","nativeMap","nativeReduce","reduce","nativeReduceRight","reduceRight","nativeFilter","nativeEvery","every","nativeSome","some","nativeIndexOf","nativeLastIndexOf","lastIndexOf","nativeIsArray","nativeKeys","nativeBind","_wrapped","VERSION","has","collect","list","reduceError","foldl","inject","memo","initial","foldr","find","detect","select","identity","contains","include","isFunc","pluck","where","attrs","first","findWhere","Infinity","shuffle","rand","shuffled","lookupIterator","sortBy","criteria","sort","left","right","behavior","groupBy","countBy","sortedIndex","low","high","mid","toArray","size","head","take","guard","rest","tail","drop","compact","flatten","shallow","output","without","difference","uniq","isSorted","seen","union","intersection","other","zip","from","hasIndex","ceil","idx","partial","bindAll","funcs","functions","hasher","wait","defer","previous","later","remaining","debounce","immediate","callNow","ran","wrapper","compose","after","times","pairs","invert","methods","names","pick","omit","tap","interceptor","eq","aStack","bStack","multiline","ignoreCase","aCtor","bCtor","isEqual","isString","isArguments","isFinite","isNaN","isBoolean","isNull","isUndefined","accum","entityMap","escape","unescape","entityRegexes","mixin","idCounter","prefix","templateSettings","evaluate","interpolate","noMatch","escapes","escaper","render","matcher","offset","variable","chain","_chain"],"ignoreList":[],"sourceRoot":"webpack:///","sources":["./src/environments/environment.Release.ts","./node_modules/@angular/localize/fesm2022/localize.mjs","./node_modules/@angular/localize/fesm2022/init.mjs","./src/polyfills.ts","./node_modules/zone.js/fesm2015/zone.js","./src/Scripts/lib/amplify.js","./src/Scripts/lib/jquery.signalr-2.2.0.min.js","./src/Scripts/lib/knockout-2.2.1.debug.js","./src/Scripts/lib/knockout.validation.js","./src/Scripts/lib/underscore.js"],"sourcesContent":["export const environment = {\n  urlConfig: {\n    serviceUrl: 'https://service.seoflurry.com/api/launchpad/v1',\n    signalRBaseUrl: 'https://service.seoflurry.com/signalr',\n    reportingUrl: 'https://reporting.boostability.com',\n    myMarketInfoUrl: 'https://mymarketinfo.com',\n    launchpadUrl: 'https://launchpad.boostability.com',\n    yellowLogoutUrl: 'http://digital.sensis.com.au/okta/IdP_Logout.htm',\n    restrictedReportingUrls: ['mymarketinfo.com', 'www.mymarketinfo.com'],\n    frontAppUrl: 'https://app.frontapp.com'\n  },\n  testConfig: {\n    testMessage: '',\n    showTestMessage: false,\n    logToConsole: false,\n    usernamesChangedForTesting: false\n  },\n  defaultPartnerConfig: {\n    id: 1,\n    name: 'Boostability',\n    logoLargeS3Url: 'https://s3.amazonaws.com/s3staticfiles/logos/1/03cfb792-397a-402f-912b-b6dc6977b8eb.png',\n    logoSmallS3Url: 'https://s3.amazonaws.com/s3staticfiles/logos/1/cdea5b9a-2826-4156-96a8-b5bac7a681d1.png',\n  },\n  logToGoogleAnalytics: true,\n  logToDevGoogleAnalytics: false,\n  disableAngularDebugChecks: true,\n  jsBuildDate: 1743524641091\n};\n","/**\n * @license Angular v17.3.12\n * (c) 2010-2024 Google LLC. https://angular.io/\n * License: MIT\n */\n\n/**\n * The character used to mark the start and end of a \"block\" in a `$localize` tagged string.\n * A block can indicate metadata about the message or specify a name of a placeholder for a\n * substitution expressions.\n *\n * For example:\n *\n * ```ts\n * $localize`Hello, ${title}:title:!`;\n * $localize`:meaning|description@@id:source message text`;\n * ```\n */\nconst BLOCK_MARKER$1 = ':';\n/**\n * The marker used to separate a message's \"meaning\" from its \"description\" in a metadata block.\n *\n * For example:\n *\n * ```ts\n * $localize `:correct|Indicates that the user got the answer correct: Right!`;\n * $localize `:movement|Button label for moving to the right: Right!`;\n * ```\n */\nconst MEANING_SEPARATOR = '|';\n/**\n * The marker used to separate a message's custom \"id\" from its \"description\" in a metadata block.\n *\n * For example:\n *\n * ```ts\n * $localize `:A welcome message on the home page@@myApp-homepage-welcome: Welcome!`;\n * ```\n */\nconst ID_SEPARATOR = '@@';\n/**\n * The marker used to separate legacy message ids from the rest of a metadata block.\n *\n * For example:\n *\n * ```ts\n * $localize `:@@custom-id␟2df64767cd895a8fabe3e18b94b5b6b6f9e2e3f0: Welcome!`;\n * ```\n *\n * Note that this character is the \"symbol for the unit separator\" (␟) not the \"unit separator\n * character\" itself, since that has no visual representation. See https://graphemica.com/%E2%90%9F.\n *\n * Here is some background for the original \"unit separator character\":\n * https://stackoverflow.com/questions/8695118/whats-the-file-group-record-unit-separator-control-characters-and-its-usage\n */\nconst LEGACY_ID_INDICATOR = '\\u241F';\n\n/**\n * A lazily created TextEncoder instance for converting strings into UTF-8 bytes\n */\nlet textEncoder;\n/**\n * Return the message id or compute it using the XLIFF1 digest.\n */\nfunction digest(message) {\n    return message.id || computeDigest(message);\n}\n/**\n * Compute the message id using the XLIFF1 digest.\n */\nfunction computeDigest(message) {\n    return sha1(serializeNodes(message.nodes).join('') + `[${message.meaning}]`);\n}\n/**\n * Return the message id or compute it using the XLIFF2/XMB/$localize digest.\n */\nfunction decimalDigest(message) {\n    return message.id || computeDecimalDigest(message);\n}\n/**\n * Compute the message id using the XLIFF2/XMB/$localize digest.\n */\nfunction computeDecimalDigest(message) {\n    const visitor = new _SerializerIgnoreIcuExpVisitor();\n    const parts = message.nodes.map(a => a.visit(visitor, null));\n    return computeMsgId(parts.join(''), message.meaning);\n}\n/**\n * Serialize the i18n ast to something xml-like in order to generate an UID.\n *\n * The visitor is also used in the i18n parser tests\n *\n * @internal\n */\nclass _SerializerVisitor {\n    visitText(text, context) {\n        return text.value;\n    }\n    visitContainer(container, context) {\n        return `[${container.children.map(child => child.visit(this)).join(', ')}]`;\n    }\n    visitIcu(icu, context) {\n        const strCases = Object.keys(icu.cases).map((k) => `${k} {${icu.cases[k].visit(this)}}`);\n        return `{${icu.expression}, ${icu.type}, ${strCases.join(', ')}}`;\n    }\n    visitTagPlaceholder(ph, context) {\n        return ph.isVoid ?\n            `<ph tag name=\"${ph.startName}\"/>` :\n            `<ph tag name=\"${ph.startName}\">${ph.children.map(child => child.visit(this)).join(', ')}</ph name=\"${ph.closeName}\">`;\n    }\n    visitPlaceholder(ph, context) {\n        return ph.value ? `<ph name=\"${ph.name}\">${ph.value}</ph>` : `<ph name=\"${ph.name}\"/>`;\n    }\n    visitIcuPlaceholder(ph, context) {\n        return `<ph icu name=\"${ph.name}\">${ph.value.visit(this)}</ph>`;\n    }\n    visitBlockPlaceholder(ph, context) {\n        return `<ph block name=\"${ph.startName}\">${ph.children.map(child => child.visit(this)).join(', ')}</ph name=\"${ph.closeName}\">`;\n    }\n}\nconst serializerVisitor = new _SerializerVisitor();\nfunction serializeNodes(nodes) {\n    return nodes.map(a => a.visit(serializerVisitor, null));\n}\n/**\n * Serialize the i18n ast to something xml-like in order to generate an UID.\n *\n * Ignore the ICU expressions so that message IDs stays identical if only the expression changes.\n *\n * @internal\n */\nclass _SerializerIgnoreIcuExpVisitor extends _SerializerVisitor {\n    visitIcu(icu, context) {\n        let strCases = Object.keys(icu.cases).map((k) => `${k} {${icu.cases[k].visit(this)}}`);\n        // Do not take the expression into account\n        return `{${icu.type}, ${strCases.join(', ')}}`;\n    }\n}\n/**\n * Compute the SHA1 of the given string\n *\n * see https://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf\n *\n * WARNING: this function has not been designed not tested with security in mind.\n *          DO NOT USE IT IN A SECURITY SENSITIVE CONTEXT.\n */\nfunction sha1(str) {\n    textEncoder ??= new TextEncoder();\n    const utf8 = [...textEncoder.encode(str)];\n    const words32 = bytesToWords32(utf8, Endian.Big);\n    const len = utf8.length * 8;\n    const w = new Uint32Array(80);\n    let a = 0x67452301, b = 0xefcdab89, c = 0x98badcfe, d = 0x10325476, e = 0xc3d2e1f0;\n    words32[len >> 5] |= 0x80 << (24 - len % 32);\n    words32[((len + 64 >> 9) << 4) + 15] = len;\n    for (let i = 0; i < words32.length; i += 16) {\n        const h0 = a, h1 = b, h2 = c, h3 = d, h4 = e;\n        for (let j = 0; j < 80; j++) {\n            if (j < 16) {\n                w[j] = words32[i + j];\n            }\n            else {\n                w[j] = rol32(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);\n            }\n            const fkVal = fk(j, b, c, d);\n            const f = fkVal[0];\n            const k = fkVal[1];\n            const temp = [rol32(a, 5), f, e, k, w[j]].reduce(add32);\n            e = d;\n            d = c;\n            c = rol32(b, 30);\n            b = a;\n            a = temp;\n        }\n        a = add32(a, h0);\n        b = add32(b, h1);\n        c = add32(c, h2);\n        d = add32(d, h3);\n        e = add32(e, h4);\n    }\n    // Convert the output parts to a 160-bit hexadecimal string\n    return toHexU32(a) + toHexU32(b) + toHexU32(c) + toHexU32(d) + toHexU32(e);\n}\n/**\n * Convert and format a number as a string representing a 32-bit unsigned hexadecimal number.\n * @param value The value to format as a string.\n * @returns A hexadecimal string representing the value.\n */\nfunction toHexU32(value) {\n    // unsigned right shift of zero ensures an unsigned 32-bit number\n    return (value >>> 0).toString(16).padStart(8, '0');\n}\nfunction fk(index, b, c, d) {\n    if (index < 20) {\n        return [(b & c) | (~b & d), 0x5a827999];\n    }\n    if (index < 40) {\n        return [b ^ c ^ d, 0x6ed9eba1];\n    }\n    if (index < 60) {\n        return [(b & c) | (b & d) | (c & d), 0x8f1bbcdc];\n    }\n    return [b ^ c ^ d, 0xca62c1d6];\n}\n/**\n * Compute the fingerprint of the given string\n *\n * The output is 64 bit number encoded as a decimal string\n *\n * based on:\n * https://github.com/google/closure-compiler/blob/master/src/com/google/javascript/jscomp/GoogleJsMessageIdGenerator.java\n */\nfunction fingerprint(str) {\n    textEncoder ??= new TextEncoder();\n    const utf8 = textEncoder.encode(str);\n    const view = new DataView(utf8.buffer, utf8.byteOffset, utf8.byteLength);\n    let hi = hash32(view, utf8.length, 0);\n    let lo = hash32(view, utf8.length, 102072);\n    if (hi == 0 && (lo == 0 || lo == 1)) {\n        hi = hi ^ 0x130f9bef;\n        lo = lo ^ -0x6b5f56d8;\n    }\n    return (BigInt.asUintN(32, BigInt(hi)) << BigInt(32)) | BigInt.asUintN(32, BigInt(lo));\n}\nfunction computeMsgId(msg, meaning = '') {\n    let msgFingerprint = fingerprint(msg);\n    if (meaning) {\n        // Rotate the 64-bit message fingerprint one bit to the left and then add the meaning\n        // fingerprint.\n        msgFingerprint = BigInt.asUintN(64, msgFingerprint << BigInt(1)) |\n            ((msgFingerprint >> BigInt(63)) & BigInt(1));\n        msgFingerprint += fingerprint(meaning);\n    }\n    return BigInt.asUintN(63, msgFingerprint).toString();\n}\nfunction hash32(view, length, c) {\n    let a = 0x9e3779b9, b = 0x9e3779b9;\n    let index = 0;\n    const end = length - 12;\n    for (; index <= end; index += 12) {\n        a += view.getUint32(index, true);\n        b += view.getUint32(index + 4, true);\n        c += view.getUint32(index + 8, true);\n        const res = mix(a, b, c);\n        a = res[0], b = res[1], c = res[2];\n    }\n    const remainder = length - index;\n    // the first byte of c is reserved for the length\n    c += length;\n    if (remainder >= 4) {\n        a += view.getUint32(index, true);\n        index += 4;\n        if (remainder >= 8) {\n            b += view.getUint32(index, true);\n            index += 4;\n            // Partial 32-bit word for c\n            if (remainder >= 9) {\n                c += view.getUint8(index++) << 8;\n            }\n            if (remainder >= 10) {\n                c += view.getUint8(index++) << 16;\n            }\n            if (remainder === 11) {\n                c += view.getUint8(index++) << 24;\n            }\n        }\n        else {\n            // Partial 32-bit word for b\n            if (remainder >= 5) {\n                b += view.getUint8(index++);\n            }\n            if (remainder >= 6) {\n                b += view.getUint8(index++) << 8;\n            }\n            if (remainder === 7) {\n                b += view.getUint8(index++) << 16;\n            }\n        }\n    }\n    else {\n        // Partial 32-bit word for a\n        if (remainder >= 1) {\n            a += view.getUint8(index++);\n        }\n        if (remainder >= 2) {\n            a += view.getUint8(index++) << 8;\n        }\n        if (remainder === 3) {\n            a += view.getUint8(index++) << 16;\n        }\n    }\n    return mix(a, b, c)[2];\n}\n// clang-format off\nfunction mix(a, b, c) {\n    a -= b;\n    a -= c;\n    a ^= c >>> 13;\n    b -= c;\n    b -= a;\n    b ^= a << 8;\n    c -= a;\n    c -= b;\n    c ^= b >>> 13;\n    a -= b;\n    a -= c;\n    a ^= c >>> 12;\n    b -= c;\n    b -= a;\n    b ^= a << 16;\n    c -= a;\n    c -= b;\n    c ^= b >>> 5;\n    a -= b;\n    a -= c;\n    a ^= c >>> 3;\n    b -= c;\n    b -= a;\n    b ^= a << 10;\n    c -= a;\n    c -= b;\n    c ^= b >>> 15;\n    return [a, b, c];\n}\n// clang-format on\n// Utils\nvar Endian;\n(function (Endian) {\n    Endian[Endian[\"Little\"] = 0] = \"Little\";\n    Endian[Endian[\"Big\"] = 1] = \"Big\";\n})(Endian || (Endian = {}));\nfunction add32(a, b) {\n    return add32to64(a, b)[1];\n}\nfunction add32to64(a, b) {\n    const low = (a & 0xffff) + (b & 0xffff);\n    const high = (a >>> 16) + (b >>> 16) + (low >>> 16);\n    return [high >>> 16, (high << 16) | (low & 0xffff)];\n}\n// Rotate a 32b number left `count` position\nfunction rol32(a, count) {\n    return (a << count) | (a >>> (32 - count));\n}\nfunction bytesToWords32(bytes, endian) {\n    const size = (bytes.length + 3) >>> 2;\n    const words32 = [];\n    for (let i = 0; i < size; i++) {\n        words32[i] = wordAt(bytes, i * 4, endian);\n    }\n    return words32;\n}\nfunction byteAt(bytes, index) {\n    return index >= bytes.length ? 0 : bytes[index];\n}\nfunction wordAt(bytes, index, endian) {\n    let word = 0;\n    if (endian === Endian.Big) {\n        for (let i = 0; i < 4; i++) {\n            word += byteAt(bytes, index + i) << (24 - 8 * i);\n        }\n    }\n    else {\n        for (let i = 0; i < 4; i++) {\n            word += byteAt(bytes, index + i) << 8 * i;\n        }\n    }\n    return word;\n}\n\n// This module specifier is intentionally a relative path to allow bundling the code directly\n/**\n * Parse a `$localize` tagged string into a structure that can be used for translation or\n * extraction.\n *\n * See `ParsedMessage` for an example.\n */\nfunction parseMessage(messageParts, expressions, location, messagePartLocations, expressionLocations = []) {\n    const substitutions = {};\n    const substitutionLocations = {};\n    const associatedMessageIds = {};\n    const metadata = parseMetadata(messageParts[0], messageParts.raw[0]);\n    const cleanedMessageParts = [metadata.text];\n    const placeholderNames = [];\n    let messageString = metadata.text;\n    for (let i = 1; i < messageParts.length; i++) {\n        const { messagePart, placeholderName = computePlaceholderName(i), associatedMessageId } = parsePlaceholder(messageParts[i], messageParts.raw[i]);\n        messageString += `{$${placeholderName}}${messagePart}`;\n        if (expressions !== undefined) {\n            substitutions[placeholderName] = expressions[i - 1];\n            substitutionLocations[placeholderName] = expressionLocations[i - 1];\n        }\n        placeholderNames.push(placeholderName);\n        if (associatedMessageId !== undefined) {\n            associatedMessageIds[placeholderName] = associatedMessageId;\n        }\n        cleanedMessageParts.push(messagePart);\n    }\n    const messageId = metadata.customId || computeMsgId(messageString, metadata.meaning || '');\n    const legacyIds = metadata.legacyIds ? metadata.legacyIds.filter(id => id !== messageId) : [];\n    return {\n        id: messageId,\n        legacyIds,\n        substitutions,\n        substitutionLocations,\n        text: messageString,\n        customId: metadata.customId,\n        meaning: metadata.meaning || '',\n        description: metadata.description || '',\n        messageParts: cleanedMessageParts,\n        messagePartLocations,\n        placeholderNames,\n        associatedMessageIds,\n        location,\n    };\n}\n/**\n * Parse the given message part (`cooked` + `raw`) to extract the message metadata from the text.\n *\n * If the message part has a metadata block this function will extract the `meaning`,\n * `description`, `customId` and `legacyId` (if provided) from the block. These metadata properties\n * are serialized in the string delimited by `|`, `@@` and `␟` respectively.\n *\n * (Note that `␟` is the `LEGACY_ID_INDICATOR` - see `constants.ts`.)\n *\n * For example:\n *\n * ```ts\n * `:meaning|description@@custom-id:`\n * `:meaning|@@custom-id:`\n * `:meaning|description:`\n * `:description@@custom-id:`\n * `:meaning|:`\n * `:description:`\n * `:@@custom-id:`\n * `:meaning|description@@custom-id␟legacy-id-1␟legacy-id-2:`\n * ```\n *\n * @param cooked The cooked version of the message part to parse.\n * @param raw The raw version of the message part to parse.\n * @returns A object containing any metadata that was parsed from the message part.\n */\nfunction parseMetadata(cooked, raw) {\n    const { text: messageString, block } = splitBlock(cooked, raw);\n    if (block === undefined) {\n        return { text: messageString };\n    }\n    else {\n        const [meaningDescAndId, ...legacyIds] = block.split(LEGACY_ID_INDICATOR);\n        const [meaningAndDesc, customId] = meaningDescAndId.split(ID_SEPARATOR, 2);\n        let [meaning, description] = meaningAndDesc.split(MEANING_SEPARATOR, 2);\n        if (description === undefined) {\n            description = meaning;\n            meaning = undefined;\n        }\n        if (description === '') {\n            description = undefined;\n        }\n        return { text: messageString, meaning, description, customId, legacyIds };\n    }\n}\n/**\n * Parse the given message part (`cooked` + `raw`) to extract any placeholder metadata from the\n * text.\n *\n * If the message part has a metadata block this function will extract the `placeholderName` and\n * `associatedMessageId` (if provided) from the block.\n *\n * These metadata properties are serialized in the string delimited by `@@`.\n *\n * For example:\n *\n * ```ts\n * `:placeholder-name@@associated-id:`\n * ```\n *\n * @param cooked The cooked version of the message part to parse.\n * @param raw The raw version of the message part to parse.\n * @returns A object containing the metadata (`placeholderName` and `associatedMessageId`) of the\n *     preceding placeholder, along with the static text that follows.\n */\nfunction parsePlaceholder(cooked, raw) {\n    const { text: messagePart, block } = splitBlock(cooked, raw);\n    if (block === undefined) {\n        return { messagePart };\n    }\n    else {\n        const [placeholderName, associatedMessageId] = block.split(ID_SEPARATOR);\n        return { messagePart, placeholderName, associatedMessageId };\n    }\n}\n/**\n * Split a message part (`cooked` + `raw`) into an optional delimited \"block\" off the front and the\n * rest of the text of the message part.\n *\n * Blocks appear at the start of message parts. They are delimited by a colon `:` character at the\n * start and end of the block.\n *\n * If the block is in the first message part then it will be metadata about the whole message:\n * meaning, description, id.  Otherwise it will be metadata about the immediately preceding\n * substitution: placeholder name.\n *\n * Since blocks are optional, it is possible that the content of a message block actually starts\n * with a block marker. In this case the marker must be escaped `\\:`.\n *\n * @param cooked The cooked version of the message part to parse.\n * @param raw The raw version of the message part to parse.\n * @returns An object containing the `text` of the message part and the text of the `block`, if it\n * exists.\n * @throws an error if the `block` is unterminated\n */\nfunction splitBlock(cooked, raw) {\n    if (raw.charAt(0) !== BLOCK_MARKER$1) {\n        return { text: cooked };\n    }\n    else {\n        const endOfBlock = findEndOfBlock(cooked, raw);\n        return {\n            block: cooked.substring(1, endOfBlock),\n            text: cooked.substring(endOfBlock + 1),\n        };\n    }\n}\nfunction computePlaceholderName(index) {\n    return index === 1 ? 'PH' : `PH_${index - 1}`;\n}\n/**\n * Find the end of a \"marked block\" indicated by the first non-escaped colon.\n *\n * @param cooked The cooked string (where escaped chars have been processed)\n * @param raw The raw string (where escape sequences are still in place)\n *\n * @returns the index of the end of block marker\n * @throws an error if the block is unterminated\n */\nfunction findEndOfBlock(cooked, raw) {\n    for (let cookedIndex = 1, rawIndex = 1; cookedIndex < cooked.length; cookedIndex++, rawIndex++) {\n        if (raw[rawIndex] === '\\\\') {\n            rawIndex++;\n        }\n        else if (cooked[cookedIndex] === BLOCK_MARKER$1) {\n            return cookedIndex;\n        }\n    }\n    throw new Error(`Unterminated $localize metadata block in \"${raw}\".`);\n}\n\nclass MissingTranslationError extends Error {\n    constructor(parsedMessage) {\n        super(`No translation found for ${describeMessage(parsedMessage)}.`);\n        this.parsedMessage = parsedMessage;\n        this.type = 'MissingTranslationError';\n    }\n}\nfunction isMissingTranslationError(e) {\n    return e.type === 'MissingTranslationError';\n}\n/**\n * Translate the text of the `$localize` tagged-string (i.e. `messageParts` and\n * `substitutions`) using the given `translations`.\n *\n * The tagged-string is parsed to extract its `messageId` which is used to find an appropriate\n * `ParsedTranslation`. If this doesn't match and there are legacy ids then try matching a\n * translation using those.\n *\n * If one is found then it is used to translate the message into a new set of `messageParts` and\n * `substitutions`.\n * The translation may reorder (or remove) substitutions as appropriate.\n *\n * If there is no translation with a matching message id then an error is thrown.\n * If a translation contains a placeholder that is not found in the message being translated then an\n * error is thrown.\n */\nfunction translate$1(translations, messageParts, substitutions) {\n    const message = parseMessage(messageParts, substitutions);\n    // Look up the translation using the messageId, and then the legacyId if available.\n    let translation = translations[message.id];\n    // If the messageId did not match a translation, try matching the legacy ids instead\n    if (message.legacyIds !== undefined) {\n        for (let i = 0; i < message.legacyIds.length && translation === undefined; i++) {\n            translation = translations[message.legacyIds[i]];\n        }\n    }\n    if (translation === undefined) {\n        throw new MissingTranslationError(message);\n    }\n    return [\n        translation.messageParts, translation.placeholderNames.map(placeholder => {\n            if (message.substitutions.hasOwnProperty(placeholder)) {\n                return message.substitutions[placeholder];\n            }\n            else {\n                throw new Error(`There is a placeholder name mismatch with the translation provided for the message ${describeMessage(message)}.\\n` +\n                    `The translation contains a placeholder with name ${placeholder}, which does not exist in the message.`);\n            }\n        })\n    ];\n}\n/**\n * Parse the `messageParts` and `placeholderNames` out of a target `message`.\n *\n * Used by `loadTranslations()` to convert target message strings into a structure that is more\n * appropriate for doing translation.\n *\n * @param message the message to be parsed.\n */\nfunction parseTranslation(messageString) {\n    const parts = messageString.split(/{\\$([^}]*)}/);\n    const messageParts = [parts[0]];\n    const placeholderNames = [];\n    for (let i = 1; i < parts.length - 1; i += 2) {\n        placeholderNames.push(parts[i]);\n        messageParts.push(`${parts[i + 1]}`);\n    }\n    const rawMessageParts = messageParts.map(part => part.charAt(0) === BLOCK_MARKER$1 ? '\\\\' + part : part);\n    return {\n        text: messageString,\n        messageParts: makeTemplateObject(messageParts, rawMessageParts),\n        placeholderNames,\n    };\n}\n/**\n * Create a `ParsedTranslation` from a set of `messageParts` and `placeholderNames`.\n *\n * @param messageParts The message parts to appear in the ParsedTranslation.\n * @param placeholderNames The names of the placeholders to intersperse between the `messageParts`.\n */\nfunction makeParsedTranslation(messageParts, placeholderNames = []) {\n    let messageString = messageParts[0];\n    for (let i = 0; i < placeholderNames.length; i++) {\n        messageString += `{$${placeholderNames[i]}}${messageParts[i + 1]}`;\n    }\n    return {\n        text: messageString,\n        messageParts: makeTemplateObject(messageParts, messageParts),\n        placeholderNames\n    };\n}\n/**\n * Create the specialized array that is passed to tagged-string tag functions.\n *\n * @param cooked The message parts with their escape codes processed.\n * @param raw The message parts with their escaped codes as-is.\n */\nfunction makeTemplateObject(cooked, raw) {\n    Object.defineProperty(cooked, 'raw', { value: raw });\n    return cooked;\n}\nfunction describeMessage(message) {\n    const meaningString = message.meaning && ` - \"${message.meaning}\"`;\n    const legacy = message.legacyIds && message.legacyIds.length > 0 ?\n        ` [${message.legacyIds.map(l => `\"${l}\"`).join(', ')}]` :\n        '';\n    return `\"${message.id}\"${legacy} (\"${message.text}\"${meaningString})`;\n}\n\n/**\n * Load translations for use by `$localize`, if doing runtime translation.\n *\n * If the `$localize` tagged strings are not going to be replaced at compiled time, it is possible\n * to load a set of translations that will be applied to the `$localize` tagged strings at runtime,\n * in the browser.\n *\n * Loading a new translation will overwrite a previous translation if it has the same `MessageId`.\n *\n * Note that `$localize` messages are only processed once, when the tagged string is first\n * encountered, and does not provide dynamic language changing without refreshing the browser.\n * Loading new translations later in the application life-cycle will not change the translated text\n * of messages that have already been translated.\n *\n * The message IDs and translations are in the same format as that rendered to \"simple JSON\"\n * translation files when extracting messages. In particular, placeholders in messages are rendered\n * using the `{$PLACEHOLDER_NAME}` syntax. For example the message from the following template:\n *\n * ```html\n * <div i18n>pre<span>inner-pre<b>bold</b>inner-post</span>post</div>\n * ```\n *\n * would have the following form in the `translations` map:\n *\n * ```ts\n * {\n *   \"2932901491976224757\":\n *      \"pre{$START_TAG_SPAN}inner-pre{$START_BOLD_TEXT}bold{$CLOSE_BOLD_TEXT}inner-post{$CLOSE_TAG_SPAN}post\"\n * }\n * ```\n *\n * @param translations A map from message ID to translated message.\n *\n * These messages are processed and added to a lookup based on their `MessageId`.\n *\n * @see {@link clearTranslations} for removing translations loaded using this function.\n * @see {@link $localize} for tagging messages as needing to be translated.\n * @publicApi\n */\nfunction loadTranslations(translations) {\n    // Ensure the translate function exists\n    if (!$localize.translate) {\n        $localize.translate = translate;\n    }\n    if (!$localize.TRANSLATIONS) {\n        $localize.TRANSLATIONS = {};\n    }\n    Object.keys(translations).forEach(key => {\n        $localize.TRANSLATIONS[key] = parseTranslation(translations[key]);\n    });\n}\n/**\n * Remove all translations for `$localize`, if doing runtime translation.\n *\n * All translations that had been loading into memory using `loadTranslations()` will be removed.\n *\n * @see {@link loadTranslations} for loading translations at runtime.\n * @see {@link $localize} for tagging messages as needing to be translated.\n *\n * @publicApi\n */\nfunction clearTranslations() {\n    $localize.translate = undefined;\n    $localize.TRANSLATIONS = {};\n}\n/**\n * Translate the text of the given message, using the loaded translations.\n *\n * This function may reorder (or remove) substitutions as indicated in the matching translation.\n */\nfunction translate(messageParts, substitutions) {\n    try {\n        return translate$1($localize.TRANSLATIONS, messageParts, substitutions);\n    }\n    catch (e) {\n        console.warn(e.message);\n        return [messageParts, substitutions];\n    }\n}\n\n/**\n * Tag a template literal string for localization.\n *\n * For example:\n *\n * ```ts\n * $localize `some string to localize`\n * ```\n *\n * **Providing meaning, description and id**\n *\n * You can optionally specify one or more of `meaning`, `description` and `id` for a localized\n * string by pre-pending it with a colon delimited block of the form:\n *\n * ```ts\n * $localize`:meaning|description@@id:source message text`;\n *\n * $localize`:meaning|:source message text`;\n * $localize`:description:source message text`;\n * $localize`:@@id:source message text`;\n * ```\n *\n * This format is the same as that used for `i18n` markers in Angular templates. See the\n * [Angular i18n guide](guide/i18n-common-prepare#mark-text-in-component-template).\n *\n * **Naming placeholders**\n *\n * If the template literal string contains expressions, then the expressions will be automatically\n * associated with placeholder names for you.\n *\n * For example:\n *\n * ```ts\n * $localize `Hi ${name}! There are ${items.length} items.`;\n * ```\n *\n * will generate a message-source of `Hi {$PH}! There are {$PH_1} items`.\n *\n * The recommended practice is to name the placeholder associated with each expression though.\n *\n * Do this by providing the placeholder name wrapped in `:` characters directly after the\n * expression. These placeholder names are stripped out of the rendered localized string.\n *\n * For example, to name the `items.length` expression placeholder `itemCount` you write:\n *\n * ```ts\n * $localize `There are ${items.length}:itemCount: items`;\n * ```\n *\n * **Escaping colon markers**\n *\n * If you need to use a `:` character directly at the start of a tagged string that has no\n * metadata block, or directly after a substitution expression that has no name you must escape\n * the `:` by preceding it with a backslash:\n *\n * For example:\n *\n * ```ts\n * // message has a metadata block so no need to escape colon\n * $localize `:some description::this message starts with a colon (:)`;\n * // no metadata block so the colon must be escaped\n * $localize `\\:this message starts with a colon (:)`;\n * ```\n *\n * ```ts\n * // named substitution so no need to escape colon\n * $localize `${label}:label:: ${}`\n * // anonymous substitution so colon must be escaped\n * $localize `${label}\\: ${}`\n * ```\n *\n * **Processing localized strings:**\n *\n * There are three scenarios:\n *\n * * **compile-time inlining**: the `$localize` tag is transformed at compile time by a\n * transpiler, removing the tag and replacing the template literal string with a translated\n * literal string from a collection of translations provided to the transpilation tool.\n *\n * * **run-time evaluation**: the `$localize` tag is a run-time function that replaces and\n * reorders the parts (static strings and expressions) of the template literal string with strings\n * from a collection of translations loaded at run-time.\n *\n * * **pass-through evaluation**: the `$localize` tag is a run-time function that simply evaluates\n * the original template literal string without applying any translations to the parts. This\n * version is used during development or where there is no need to translate the localized\n * template literals.\n *\n * @param messageParts a collection of the static parts of the template string.\n * @param expressions a collection of the values of each placeholder in the template string.\n * @returns the translated string, with the `messageParts` and `expressions` interleaved together.\n *\n * @globalApi\n * @publicApi\n */\nconst $localize$1 = function (messageParts, ...expressions) {\n    if ($localize$1.translate) {\n        // Don't use array expansion here to avoid the compiler adding `__read()` helper unnecessarily.\n        const translation = $localize$1.translate(messageParts, expressions);\n        messageParts = translation[0];\n        expressions = translation[1];\n    }\n    let message = stripBlock(messageParts[0], messageParts.raw[0]);\n    for (let i = 1; i < messageParts.length; i++) {\n        message += expressions[i - 1] + stripBlock(messageParts[i], messageParts.raw[i]);\n    }\n    return message;\n};\nconst BLOCK_MARKER = ':';\n/**\n * Strip a delimited \"block\" from the start of the `messagePart`, if it is found.\n *\n * If a marker character (:) actually appears in the content at the start of a tagged string or\n * after a substitution expression, where a block has not been provided the character must be\n * escaped with a backslash, `\\:`. This function checks for this by looking at the `raw`\n * messagePart, which should still contain the backslash.\n *\n * @param messagePart The cooked message part to process.\n * @param rawMessagePart The raw message part to check.\n * @returns the message part with the placeholder name stripped, if found.\n * @throws an error if the block is unterminated\n */\nfunction stripBlock(messagePart, rawMessagePart) {\n    return rawMessagePart.charAt(0) === BLOCK_MARKER ?\n        messagePart.substring(findEndOfBlock(messagePart, rawMessagePart) + 1) :\n        messagePart;\n}\n\n// This file exports all the `utils` as private exports so that other parts of `@angular/localize`\n\n// This file contains the public API of the `@angular/localize` entry-point\n\n// DO NOT ADD public exports to this file.\n\nexport { clearTranslations, loadTranslations, $localize$1 as ɵ$localize, MissingTranslationError as ɵMissingTranslationError, computeMsgId as ɵcomputeMsgId, findEndOfBlock as ɵfindEndOfBlock, isMissingTranslationError as ɵisMissingTranslationError, makeParsedTranslation as ɵmakeParsedTranslation, makeTemplateObject as ɵmakeTemplateObject, parseMessage as ɵparseMessage, parseMetadata as ɵparseMetadata, parseTranslation as ɵparseTranslation, splitBlock as ɵsplitBlock, translate$1 as ɵtranslate };\n","/**\n * @license Angular v17.3.12\n * (c) 2010-2024 Google LLC. https://angular.io/\n * License: MIT\n */\n\nimport { ɵ$localize } from '@angular/localize';\nexport { ɵ$localize as $localize } from '@angular/localize';\n\n// Attach $localize to the global context, as a side-effect of this module.\nglobalThis.$localize = ɵ$localize;\n","/***************************************************************************************************\n * Load `$localize` onto the global scope - used if i18n tags appear in Angular templates.\n */\nimport '@angular/localize/init';\n/**\n * This file includes polyfills needed by Angular and is loaded before the app.\n * You can add your own extra polyfills to this file.\n *\n * This file is divided into 2 sections:\n *   1. Browser polyfills. These are applied before loading ZoneJS and are sorted by browsers.\n *   2. Application imports. Files imported after ZoneJS that should be loaded before your main\n *      file.\n *\n * The current setup is for so-called \"evergreen\" browsers; the last versions of browsers that\n * automatically update themselves. This includes Safari >= 10, Chrome >= 55 (including Opera),\n * Edge >= 13 on the desktop, and iOS 10 and Chrome on mobile.\n *\n * Learn more in https://angular.io/guide/browser-support\n */\n\n/***************************************************************************************************\n * BROWSER POLYFILLS\n */\n\n/**\n * By default, zone.js will patch all possible macroTask and DomEvents\n * user can disable parts of macroTask/DomEvents patch by setting following flags\n * because those flags need to be set before `zone.js` being loaded, and webpack\n * will put import in the top of bundle, so user need to create a separate file\n * in this directory (for example: zone-flags.ts), and put the following flags\n * into that file, and then add the following code before importing zone.js.\n * import './zone-flags.ts';\n *\n * The flags allowed in zone-flags.ts are listed here.\n *\n * The following flags will work for all browsers.\n *\n * (window as any).__Zone_disable_requestAnimationFrame = true; // disable patch requestAnimationFrame\n * (window as any).__Zone_disable_on_property = true; // disable patch onProperty such as onclick\n * (window as any).__zone_symbol__UNPATCHED_EVENTS = ['scroll', 'mousemove']; // disable patch specified eventNames\n *\n *  in IE/Edge developer tools, the addEventListener will also be wrapped by zone.js\n *  with the following flag, it will bypass `zone.js` patch for IE/Edge\n *\n *  (window as any).__Zone_enable_cross_context_check = true;\n *\n */\n\n/***************************************************************************************************\n * APPLICATION IMPORTS\n */\n\nimport './Scripts/lib/amplify.js'; // Required for AJAX request management\nimport './Scripts/lib/knockout-2.2.1.debug.js'; // Required for MVVM/Data Binding\nimport './Scripts/lib/knockout.validation.js'; // Knockout.js Validation Plugin\nimport './Scripts/lib/underscore.js'; // Utility class for JavaScript\nimport './Scripts/lib/jquery.signalr-2.2.0.min.js';\nimport { environment } from './environments/environment';\nwindow['environment'] = environment;\nwindow['urlConfig'] = environment.urlConfig;\nwindow['testConfig'] = environment.testConfig;\n","'use strict';\n/**\n * @license Angular v<unknown>\n * (c) 2010-2024 Google LLC. https://angular.io/\n * License: MIT\n */\nconst global = globalThis;\n// __Zone_symbol_prefix global can be used to override the default zone\n// symbol prefix with a custom one if needed.\nfunction __symbol__(name) {\n    const symbolPrefix = global['__Zone_symbol_prefix'] || '__zone_symbol__';\n    return symbolPrefix + name;\n}\nfunction initZone() {\n    const performance = global['performance'];\n    function mark(name) {\n        performance && performance['mark'] && performance['mark'](name);\n    }\n    function performanceMeasure(name, label) {\n        performance && performance['measure'] && performance['measure'](name, label);\n    }\n    mark('Zone');\n    class ZoneImpl {\n        // tslint:disable-next-line:require-internal-with-underscore\n        static { this.__symbol__ = __symbol__; }\n        static assertZonePatched() {\n            if (global['Promise'] !== patches['ZoneAwarePromise']) {\n                throw new Error('Zone.js has detected that ZoneAwarePromise `(window|global).Promise` ' +\n                    'has been overwritten.\\n' +\n                    'Most likely cause is that a Promise polyfill has been loaded ' +\n                    'after Zone.js (Polyfilling Promise api is not necessary when zone.js is loaded. ' +\n                    'If you must load one, do so before loading zone.js.)');\n            }\n        }\n        static get root() {\n            let zone = ZoneImpl.current;\n            while (zone.parent) {\n                zone = zone.parent;\n            }\n            return zone;\n        }\n        static get current() {\n            return _currentZoneFrame.zone;\n        }\n        static get currentTask() {\n            return _currentTask;\n        }\n        // tslint:disable-next-line:require-internal-with-underscore\n        static __load_patch(name, fn, ignoreDuplicate = false) {\n            if (patches.hasOwnProperty(name)) {\n                // `checkDuplicate` option is defined from global variable\n                // so it works for all modules.\n                // `ignoreDuplicate` can work for the specified module\n                const checkDuplicate = global[__symbol__('forceDuplicateZoneCheck')] === true;\n                if (!ignoreDuplicate && checkDuplicate) {\n                    throw Error('Already loaded patch: ' + name);\n                }\n            }\n            else if (!global['__Zone_disable_' + name]) {\n                const perfName = 'Zone:' + name;\n                mark(perfName);\n                patches[name] = fn(global, ZoneImpl, _api);\n                performanceMeasure(perfName, perfName);\n            }\n        }\n        get parent() {\n            return this._parent;\n        }\n        get name() {\n            return this._name;\n        }\n        constructor(parent, zoneSpec) {\n            this._parent = parent;\n            this._name = zoneSpec ? zoneSpec.name || 'unnamed' : '<root>';\n            this._properties = (zoneSpec && zoneSpec.properties) || {};\n            this._zoneDelegate = new _ZoneDelegate(this, this._parent && this._parent._zoneDelegate, zoneSpec);\n        }\n        get(key) {\n            const zone = this.getZoneWith(key);\n            if (zone)\n                return zone._properties[key];\n        }\n        getZoneWith(key) {\n            let current = this;\n            while (current) {\n                if (current._properties.hasOwnProperty(key)) {\n                    return current;\n                }\n                current = current._parent;\n            }\n            return null;\n        }\n        fork(zoneSpec) {\n            if (!zoneSpec)\n                throw new Error('ZoneSpec required!');\n            return this._zoneDelegate.fork(this, zoneSpec);\n        }\n        wrap(callback, source) {\n            if (typeof callback !== 'function') {\n                throw new Error('Expecting function got: ' + callback);\n            }\n            const _callback = this._zoneDelegate.intercept(this, callback, source);\n            const zone = this;\n            return function () {\n                return zone.runGuarded(_callback, this, arguments, source);\n            };\n        }\n        run(callback, applyThis, applyArgs, source) {\n            _currentZoneFrame = { parent: _currentZoneFrame, zone: this };\n            try {\n                return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);\n            }\n            finally {\n                _currentZoneFrame = _currentZoneFrame.parent;\n            }\n        }\n        runGuarded(callback, applyThis = null, applyArgs, source) {\n            _currentZoneFrame = { parent: _currentZoneFrame, zone: this };\n            try {\n                try {\n                    return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);\n                }\n                catch (error) {\n                    if (this._zoneDelegate.handleError(this, error)) {\n                        throw error;\n                    }\n                }\n            }\n            finally {\n                _currentZoneFrame = _currentZoneFrame.parent;\n            }\n        }\n        runTask(task, applyThis, applyArgs) {\n            if (task.zone != this) {\n                throw new Error('A task can only be run in the zone of creation! (Creation: ' +\n                    (task.zone || NO_ZONE).name +\n                    '; Execution: ' +\n                    this.name +\n                    ')');\n            }\n            const zoneTask = task;\n            // https://github.com/angular/zone.js/issues/778, sometimes eventTask\n            // will run in notScheduled(canceled) state, we should not try to\n            // run such kind of task but just return\n            const { type, data: { isPeriodic = false, isRefreshable = false } = {} } = task;\n            if (task.state === notScheduled && (type === eventTask || type === macroTask)) {\n                return;\n            }\n            const reEntryGuard = task.state != running;\n            reEntryGuard && zoneTask._transitionTo(running, scheduled);\n            const previousTask = _currentTask;\n            _currentTask = zoneTask;\n            _currentZoneFrame = { parent: _currentZoneFrame, zone: this };\n            try {\n                if (type == macroTask && task.data && !isPeriodic && !isRefreshable) {\n                    task.cancelFn = undefined;\n                }\n                try {\n                    return this._zoneDelegate.invokeTask(this, zoneTask, applyThis, applyArgs);\n                }\n                catch (error) {\n                    if (this._zoneDelegate.handleError(this, error)) {\n                        throw error;\n                    }\n                }\n            }\n            finally {\n                // if the task's state is notScheduled or unknown, then it has already been cancelled\n                // we should not reset the state to scheduled\n                const state = task.state;\n                if (state !== notScheduled && state !== unknown) {\n                    if (type == eventTask || isPeriodic || (isRefreshable && state === scheduling)) {\n                        reEntryGuard && zoneTask._transitionTo(scheduled, running, scheduling);\n                    }\n                    else {\n                        const zoneDelegates = zoneTask._zoneDelegates;\n                        this._updateTaskCount(zoneTask, -1);\n                        reEntryGuard && zoneTask._transitionTo(notScheduled, running, notScheduled);\n                        if (isRefreshable) {\n                            zoneTask._zoneDelegates = zoneDelegates;\n                        }\n                    }\n                }\n                _currentZoneFrame = _currentZoneFrame.parent;\n                _currentTask = previousTask;\n            }\n        }\n        scheduleTask(task) {\n            if (task.zone && task.zone !== this) {\n                // check if the task was rescheduled, the newZone\n                // should not be the children of the original zone\n                let newZone = this;\n                while (newZone) {\n                    if (newZone === task.zone) {\n                        throw Error(`can not reschedule task to ${this.name} which is descendants of the original zone ${task.zone.name}`);\n                    }\n                    newZone = newZone.parent;\n                }\n            }\n            task._transitionTo(scheduling, notScheduled);\n            const zoneDelegates = [];\n            task._zoneDelegates = zoneDelegates;\n            task._zone = this;\n            try {\n                task = this._zoneDelegate.scheduleTask(this, task);\n            }\n            catch (err) {\n                // should set task's state to unknown when scheduleTask throw error\n                // because the err may from reschedule, so the fromState maybe notScheduled\n                task._transitionTo(unknown, scheduling, notScheduled);\n                // TODO: @JiaLiPassion, should we check the result from handleError?\n                this._zoneDelegate.handleError(this, err);\n                throw err;\n            }\n            if (task._zoneDelegates === zoneDelegates) {\n                // we have to check because internally the delegate can reschedule the task.\n                this._updateTaskCount(task, 1);\n            }\n            if (task.state == scheduling) {\n                task._transitionTo(scheduled, scheduling);\n            }\n            return task;\n        }\n        scheduleMicroTask(source, callback, data, customSchedule) {\n            return this.scheduleTask(new ZoneTask(microTask, source, callback, data, customSchedule, undefined));\n        }\n        scheduleMacroTask(source, callback, data, customSchedule, customCancel) {\n            return this.scheduleTask(new ZoneTask(macroTask, source, callback, data, customSchedule, customCancel));\n        }\n        scheduleEventTask(source, callback, data, customSchedule, customCancel) {\n            return this.scheduleTask(new ZoneTask(eventTask, source, callback, data, customSchedule, customCancel));\n        }\n        cancelTask(task) {\n            if (task.zone != this)\n                throw new Error('A task can only be cancelled in the zone of creation! (Creation: ' +\n                    (task.zone || NO_ZONE).name +\n                    '; Execution: ' +\n                    this.name +\n                    ')');\n            if (task.state !== scheduled && task.state !== running) {\n                return;\n            }\n            task._transitionTo(canceling, scheduled, running);\n            try {\n                this._zoneDelegate.cancelTask(this, task);\n            }\n            catch (err) {\n                // if error occurs when cancelTask, transit the state to unknown\n                task._transitionTo(unknown, canceling);\n                this._zoneDelegate.handleError(this, err);\n                throw err;\n            }\n            this._updateTaskCount(task, -1);\n            task._transitionTo(notScheduled, canceling);\n            task.runCount = -1;\n            return task;\n        }\n        _updateTaskCount(task, count) {\n            const zoneDelegates = task._zoneDelegates;\n            if (count == -1) {\n                task._zoneDelegates = null;\n            }\n            for (let i = 0; i < zoneDelegates.length; i++) {\n                zoneDelegates[i]._updateTaskCount(task.type, count);\n            }\n        }\n    }\n    const DELEGATE_ZS = {\n        name: '',\n        onHasTask: (delegate, _, target, hasTaskState) => delegate.hasTask(target, hasTaskState),\n        onScheduleTask: (delegate, _, target, task) => delegate.scheduleTask(target, task),\n        onInvokeTask: (delegate, _, target, task, applyThis, applyArgs) => delegate.invokeTask(target, task, applyThis, applyArgs),\n        onCancelTask: (delegate, _, target, task) => delegate.cancelTask(target, task),\n    };\n    class _ZoneDelegate {\n        get zone() {\n            return this._zone;\n        }\n        constructor(zone, parentDelegate, zoneSpec) {\n            this._taskCounts = {\n                'microTask': 0,\n                'macroTask': 0,\n                'eventTask': 0,\n            };\n            this._zone = zone;\n            this._parentDelegate = parentDelegate;\n            this._forkZS = zoneSpec && (zoneSpec && zoneSpec.onFork ? zoneSpec : parentDelegate._forkZS);\n            this._forkDlgt = zoneSpec && (zoneSpec.onFork ? parentDelegate : parentDelegate._forkDlgt);\n            this._forkCurrZone =\n                zoneSpec && (zoneSpec.onFork ? this._zone : parentDelegate._forkCurrZone);\n            this._interceptZS =\n                zoneSpec && (zoneSpec.onIntercept ? zoneSpec : parentDelegate._interceptZS);\n            this._interceptDlgt =\n                zoneSpec && (zoneSpec.onIntercept ? parentDelegate : parentDelegate._interceptDlgt);\n            this._interceptCurrZone =\n                zoneSpec && (zoneSpec.onIntercept ? this._zone : parentDelegate._interceptCurrZone);\n            this._invokeZS = zoneSpec && (zoneSpec.onInvoke ? zoneSpec : parentDelegate._invokeZS);\n            this._invokeDlgt =\n                zoneSpec && (zoneSpec.onInvoke ? parentDelegate : parentDelegate._invokeDlgt);\n            this._invokeCurrZone =\n                zoneSpec && (zoneSpec.onInvoke ? this._zone : parentDelegate._invokeCurrZone);\n            this._handleErrorZS =\n                zoneSpec && (zoneSpec.onHandleError ? zoneSpec : parentDelegate._handleErrorZS);\n            this._handleErrorDlgt =\n                zoneSpec && (zoneSpec.onHandleError ? parentDelegate : parentDelegate._handleErrorDlgt);\n            this._handleErrorCurrZone =\n                zoneSpec && (zoneSpec.onHandleError ? this._zone : parentDelegate._handleErrorCurrZone);\n            this._scheduleTaskZS =\n                zoneSpec && (zoneSpec.onScheduleTask ? zoneSpec : parentDelegate._scheduleTaskZS);\n            this._scheduleTaskDlgt =\n                zoneSpec && (zoneSpec.onScheduleTask ? parentDelegate : parentDelegate._scheduleTaskDlgt);\n            this._scheduleTaskCurrZone =\n                zoneSpec && (zoneSpec.onScheduleTask ? this._zone : parentDelegate._scheduleTaskCurrZone);\n            this._invokeTaskZS =\n                zoneSpec && (zoneSpec.onInvokeTask ? zoneSpec : parentDelegate._invokeTaskZS);\n            this._invokeTaskDlgt =\n                zoneSpec && (zoneSpec.onInvokeTask ? parentDelegate : parentDelegate._invokeTaskDlgt);\n            this._invokeTaskCurrZone =\n                zoneSpec && (zoneSpec.onInvokeTask ? this._zone : parentDelegate._invokeTaskCurrZone);\n            this._cancelTaskZS =\n                zoneSpec && (zoneSpec.onCancelTask ? zoneSpec : parentDelegate._cancelTaskZS);\n            this._cancelTaskDlgt =\n                zoneSpec && (zoneSpec.onCancelTask ? parentDelegate : parentDelegate._cancelTaskDlgt);\n            this._cancelTaskCurrZone =\n                zoneSpec && (zoneSpec.onCancelTask ? this._zone : parentDelegate._cancelTaskCurrZone);\n            this._hasTaskZS = null;\n            this._hasTaskDlgt = null;\n            this._hasTaskDlgtOwner = null;\n            this._hasTaskCurrZone = null;\n            const zoneSpecHasTask = zoneSpec && zoneSpec.onHasTask;\n            const parentHasTask = parentDelegate && parentDelegate._hasTaskZS;\n            if (zoneSpecHasTask || parentHasTask) {\n                // If we need to report hasTask, than this ZS needs to do ref counting on tasks. In such\n                // a case all task related interceptors must go through this ZD. We can't short circuit it.\n                this._hasTaskZS = zoneSpecHasTask ? zoneSpec : DELEGATE_ZS;\n                this._hasTaskDlgt = parentDelegate;\n                this._hasTaskDlgtOwner = this;\n                this._hasTaskCurrZone = this._zone;\n                if (!zoneSpec.onScheduleTask) {\n                    this._scheduleTaskZS = DELEGATE_ZS;\n                    this._scheduleTaskDlgt = parentDelegate;\n                    this._scheduleTaskCurrZone = this._zone;\n                }\n                if (!zoneSpec.onInvokeTask) {\n                    this._invokeTaskZS = DELEGATE_ZS;\n                    this._invokeTaskDlgt = parentDelegate;\n                    this._invokeTaskCurrZone = this._zone;\n                }\n                if (!zoneSpec.onCancelTask) {\n                    this._cancelTaskZS = DELEGATE_ZS;\n                    this._cancelTaskDlgt = parentDelegate;\n                    this._cancelTaskCurrZone = this._zone;\n                }\n            }\n        }\n        fork(targetZone, zoneSpec) {\n            return this._forkZS\n                ? this._forkZS.onFork(this._forkDlgt, this.zone, targetZone, zoneSpec)\n                : new ZoneImpl(targetZone, zoneSpec);\n        }\n        intercept(targetZone, callback, source) {\n            return this._interceptZS\n                ? this._interceptZS.onIntercept(this._interceptDlgt, this._interceptCurrZone, targetZone, callback, source)\n                : callback;\n        }\n        invoke(targetZone, callback, applyThis, applyArgs, source) {\n            return this._invokeZS\n                ? this._invokeZS.onInvoke(this._invokeDlgt, this._invokeCurrZone, targetZone, callback, applyThis, applyArgs, source)\n                : callback.apply(applyThis, applyArgs);\n        }\n        handleError(targetZone, error) {\n            return this._handleErrorZS\n                ? this._handleErrorZS.onHandleError(this._handleErrorDlgt, this._handleErrorCurrZone, targetZone, error)\n                : true;\n        }\n        scheduleTask(targetZone, task) {\n            let returnTask = task;\n            if (this._scheduleTaskZS) {\n                if (this._hasTaskZS) {\n                    returnTask._zoneDelegates.push(this._hasTaskDlgtOwner);\n                }\n                returnTask = this._scheduleTaskZS.onScheduleTask(this._scheduleTaskDlgt, this._scheduleTaskCurrZone, targetZone, task);\n                if (!returnTask)\n                    returnTask = task;\n            }\n            else {\n                if (task.scheduleFn) {\n                    task.scheduleFn(task);\n                }\n                else if (task.type == microTask) {\n                    scheduleMicroTask(task);\n                }\n                else {\n                    throw new Error('Task is missing scheduleFn.');\n                }\n            }\n            return returnTask;\n        }\n        invokeTask(targetZone, task, applyThis, applyArgs) {\n            return this._invokeTaskZS\n                ? this._invokeTaskZS.onInvokeTask(this._invokeTaskDlgt, this._invokeTaskCurrZone, targetZone, task, applyThis, applyArgs)\n                : task.callback.apply(applyThis, applyArgs);\n        }\n        cancelTask(targetZone, task) {\n            let value;\n            if (this._cancelTaskZS) {\n                value = this._cancelTaskZS.onCancelTask(this._cancelTaskDlgt, this._cancelTaskCurrZone, targetZone, task);\n            }\n            else {\n                if (!task.cancelFn) {\n                    throw Error('Task is not cancelable');\n                }\n                value = task.cancelFn(task);\n            }\n            return value;\n        }\n        hasTask(targetZone, isEmpty) {\n            // hasTask should not throw error so other ZoneDelegate\n            // can still trigger hasTask callback\n            try {\n                this._hasTaskZS &&\n                    this._hasTaskZS.onHasTask(this._hasTaskDlgt, this._hasTaskCurrZone, targetZone, isEmpty);\n            }\n            catch (err) {\n                this.handleError(targetZone, err);\n            }\n        }\n        // tslint:disable-next-line:require-internal-with-underscore\n        _updateTaskCount(type, count) {\n            const counts = this._taskCounts;\n            const prev = counts[type];\n            const next = (counts[type] = prev + count);\n            if (next < 0) {\n                throw new Error('More tasks executed then were scheduled.');\n            }\n            if (prev == 0 || next == 0) {\n                const isEmpty = {\n                    microTask: counts['microTask'] > 0,\n                    macroTask: counts['macroTask'] > 0,\n                    eventTask: counts['eventTask'] > 0,\n                    change: type,\n                };\n                this.hasTask(this._zone, isEmpty);\n            }\n        }\n    }\n    class ZoneTask {\n        constructor(type, source, callback, options, scheduleFn, cancelFn) {\n            // tslint:disable-next-line:require-internal-with-underscore\n            this._zone = null;\n            this.runCount = 0;\n            // tslint:disable-next-line:require-internal-with-underscore\n            this._zoneDelegates = null;\n            // tslint:disable-next-line:require-internal-with-underscore\n            this._state = 'notScheduled';\n            this.type = type;\n            this.source = source;\n            this.data = options;\n            this.scheduleFn = scheduleFn;\n            this.cancelFn = cancelFn;\n            if (!callback) {\n                throw new Error('callback is not defined');\n            }\n            this.callback = callback;\n            const self = this;\n            // TODO: @JiaLiPassion options should have interface\n            if (type === eventTask && options && options.useG) {\n                this.invoke = ZoneTask.invokeTask;\n            }\n            else {\n                this.invoke = function () {\n                    return ZoneTask.invokeTask.call(global, self, this, arguments);\n                };\n            }\n        }\n        static invokeTask(task, target, args) {\n            if (!task) {\n                task = this;\n            }\n            _numberOfNestedTaskFrames++;\n            try {\n                task.runCount++;\n                return task.zone.runTask(task, target, args);\n            }\n            finally {\n                if (_numberOfNestedTaskFrames == 1) {\n                    drainMicroTaskQueue();\n                }\n                _numberOfNestedTaskFrames--;\n            }\n        }\n        get zone() {\n            return this._zone;\n        }\n        get state() {\n            return this._state;\n        }\n        cancelScheduleRequest() {\n            this._transitionTo(notScheduled, scheduling);\n        }\n        // tslint:disable-next-line:require-internal-with-underscore\n        _transitionTo(toState, fromState1, fromState2) {\n            if (this._state === fromState1 || this._state === fromState2) {\n                this._state = toState;\n                if (toState == notScheduled) {\n                    this._zoneDelegates = null;\n                }\n            }\n            else {\n                throw new Error(`${this.type} '${this.source}': can not transition to '${toState}', expecting state '${fromState1}'${fromState2 ? \" or '\" + fromState2 + \"'\" : ''}, was '${this._state}'.`);\n            }\n        }\n        toString() {\n            if (this.data && typeof this.data.handleId !== 'undefined') {\n                return this.data.handleId.toString();\n            }\n            else {\n                return Object.prototype.toString.call(this);\n            }\n        }\n        // add toJSON method to prevent cyclic error when\n        // call JSON.stringify(zoneTask)\n        toJSON() {\n            return {\n                type: this.type,\n                state: this.state,\n                source: this.source,\n                zone: this.zone.name,\n                runCount: this.runCount,\n            };\n        }\n    }\n    //////////////////////////////////////////////////////\n    //////////////////////////////////////////////////////\n    ///  MICROTASK QUEUE\n    //////////////////////////////////////////////////////\n    //////////////////////////////////////////////////////\n    const symbolSetTimeout = __symbol__('setTimeout');\n    const symbolPromise = __symbol__('Promise');\n    const symbolThen = __symbol__('then');\n    let _microTaskQueue = [];\n    let _isDrainingMicrotaskQueue = false;\n    let nativeMicroTaskQueuePromise;\n    function nativeScheduleMicroTask(func) {\n        if (!nativeMicroTaskQueuePromise) {\n            if (global[symbolPromise]) {\n                nativeMicroTaskQueuePromise = global[symbolPromise].resolve(0);\n            }\n        }\n        if (nativeMicroTaskQueuePromise) {\n            let nativeThen = nativeMicroTaskQueuePromise[symbolThen];\n            if (!nativeThen) {\n                // native Promise is not patchable, we need to use `then` directly\n                // issue 1078\n                nativeThen = nativeMicroTaskQueuePromise['then'];\n            }\n            nativeThen.call(nativeMicroTaskQueuePromise, func);\n        }\n        else {\n            global[symbolSetTimeout](func, 0);\n        }\n    }\n    function scheduleMicroTask(task) {\n        // if we are not running in any task, and there has not been anything scheduled\n        // we must bootstrap the initial task creation by manually scheduling the drain\n        if (_numberOfNestedTaskFrames === 0 && _microTaskQueue.length === 0) {\n            // We are not running in Task, so we need to kickstart the microtask queue.\n            nativeScheduleMicroTask(drainMicroTaskQueue);\n        }\n        task && _microTaskQueue.push(task);\n    }\n    function drainMicroTaskQueue() {\n        if (!_isDrainingMicrotaskQueue) {\n            _isDrainingMicrotaskQueue = true;\n            while (_microTaskQueue.length) {\n                const queue = _microTaskQueue;\n                _microTaskQueue = [];\n                for (let i = 0; i < queue.length; i++) {\n                    const task = queue[i];\n                    try {\n                        task.zone.runTask(task, null, null);\n                    }\n                    catch (error) {\n                        _api.onUnhandledError(error);\n                    }\n                }\n            }\n            _api.microtaskDrainDone();\n            _isDrainingMicrotaskQueue = false;\n        }\n    }\n    //////////////////////////////////////////////////////\n    //////////////////////////////////////////////////////\n    ///  BOOTSTRAP\n    //////////////////////////////////////////////////////\n    //////////////////////////////////////////////////////\n    const NO_ZONE = { name: 'NO ZONE' };\n    const notScheduled = 'notScheduled', scheduling = 'scheduling', scheduled = 'scheduled', running = 'running', canceling = 'canceling', unknown = 'unknown';\n    const microTask = 'microTask', macroTask = 'macroTask', eventTask = 'eventTask';\n    const patches = {};\n    const _api = {\n        symbol: __symbol__,\n        currentZoneFrame: () => _currentZoneFrame,\n        onUnhandledError: noop,\n        microtaskDrainDone: noop,\n        scheduleMicroTask: scheduleMicroTask,\n        showUncaughtError: () => !ZoneImpl[__symbol__('ignoreConsoleErrorUncaughtError')],\n        patchEventTarget: () => [],\n        patchOnProperties: noop,\n        patchMethod: () => noop,\n        bindArguments: () => [],\n        patchThen: () => noop,\n        patchMacroTask: () => noop,\n        patchEventPrototype: () => noop,\n        isIEOrEdge: () => false,\n        getGlobalObjects: () => undefined,\n        ObjectDefineProperty: () => noop,\n        ObjectGetOwnPropertyDescriptor: () => undefined,\n        ObjectCreate: () => undefined,\n        ArraySlice: () => [],\n        patchClass: () => noop,\n        wrapWithCurrentZone: () => noop,\n        filterProperties: () => [],\n        attachOriginToPatched: () => noop,\n        _redefineProperty: () => noop,\n        patchCallbacks: () => noop,\n        nativeScheduleMicroTask: nativeScheduleMicroTask,\n    };\n    let _currentZoneFrame = { parent: null, zone: new ZoneImpl(null, null) };\n    let _currentTask = null;\n    let _numberOfNestedTaskFrames = 0;\n    function noop() { }\n    performanceMeasure('Zone', 'Zone');\n    return ZoneImpl;\n}\n\nfunction loadZone() {\n    // if global['Zone'] already exists (maybe zone.js was already loaded or\n    // some other lib also registered a global object named Zone), we may need\n    // to throw an error, but sometimes user may not want this error.\n    // For example,\n    // we have two web pages, page1 includes zone.js, page2 doesn't.\n    // and the 1st time user load page1 and page2, everything work fine,\n    // but when user load page2 again, error occurs because global['Zone'] already exists.\n    // so we add a flag to let user choose whether to throw this error or not.\n    // By default, if existing Zone is from zone.js, we will not throw the error.\n    const global = globalThis;\n    const checkDuplicate = global[__symbol__('forceDuplicateZoneCheck')] === true;\n    if (global['Zone'] && (checkDuplicate || typeof global['Zone'].__symbol__ !== 'function')) {\n        throw new Error('Zone already loaded.');\n    }\n    // Initialize global `Zone` constant.\n    global['Zone'] ??= initZone();\n    return global['Zone'];\n}\n\n/**\n * Suppress closure compiler errors about unknown 'Zone' variable\n * @fileoverview\n * @suppress {undefinedVars,globalThis,missingRequire}\n */\n// issue #989, to reduce bundle size, use short name\n/** Object.getOwnPropertyDescriptor */\nconst ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n/** Object.defineProperty */\nconst ObjectDefineProperty = Object.defineProperty;\n/** Object.getPrototypeOf */\nconst ObjectGetPrototypeOf = Object.getPrototypeOf;\n/** Object.create */\nconst ObjectCreate = Object.create;\n/** Array.prototype.slice */\nconst ArraySlice = Array.prototype.slice;\n/** addEventListener string const */\nconst ADD_EVENT_LISTENER_STR = 'addEventListener';\n/** removeEventListener string const */\nconst REMOVE_EVENT_LISTENER_STR = 'removeEventListener';\n/** zoneSymbol addEventListener */\nconst ZONE_SYMBOL_ADD_EVENT_LISTENER = __symbol__(ADD_EVENT_LISTENER_STR);\n/** zoneSymbol removeEventListener */\nconst ZONE_SYMBOL_REMOVE_EVENT_LISTENER = __symbol__(REMOVE_EVENT_LISTENER_STR);\n/** true string const */\nconst TRUE_STR = 'true';\n/** false string const */\nconst FALSE_STR = 'false';\n/** Zone symbol prefix string const. */\nconst ZONE_SYMBOL_PREFIX = __symbol__('');\nfunction wrapWithCurrentZone(callback, source) {\n    return Zone.current.wrap(callback, source);\n}\nfunction scheduleMacroTaskWithCurrentZone(source, callback, data, customSchedule, customCancel) {\n    return Zone.current.scheduleMacroTask(source, callback, data, customSchedule, customCancel);\n}\nconst zoneSymbol = __symbol__;\nconst isWindowExists = typeof window !== 'undefined';\nconst internalWindow = isWindowExists ? window : undefined;\nconst _global = (isWindowExists && internalWindow) || globalThis;\nconst REMOVE_ATTRIBUTE = 'removeAttribute';\nfunction bindArguments(args, source) {\n    for (let i = args.length - 1; i >= 0; i--) {\n        if (typeof args[i] === 'function') {\n            args[i] = wrapWithCurrentZone(args[i], source + '_' + i);\n        }\n    }\n    return args;\n}\nfunction patchPrototype(prototype, fnNames) {\n    const source = prototype.constructor['name'];\n    for (let i = 0; i < fnNames.length; i++) {\n        const name = fnNames[i];\n        const delegate = prototype[name];\n        if (delegate) {\n            const prototypeDesc = ObjectGetOwnPropertyDescriptor(prototype, name);\n            if (!isPropertyWritable(prototypeDesc)) {\n                continue;\n            }\n            prototype[name] = ((delegate) => {\n                const patched = function () {\n                    return delegate.apply(this, bindArguments(arguments, source + '.' + name));\n                };\n                attachOriginToPatched(patched, delegate);\n                return patched;\n            })(delegate);\n        }\n    }\n}\nfunction isPropertyWritable(propertyDesc) {\n    if (!propertyDesc) {\n        return true;\n    }\n    if (propertyDesc.writable === false) {\n        return false;\n    }\n    return !(typeof propertyDesc.get === 'function' && typeof propertyDesc.set === 'undefined');\n}\nconst isWebWorker = typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope;\n// Make sure to access `process` through `_global` so that WebPack does not accidentally browserify\n// this code.\nconst isNode = !('nw' in _global) &&\n    typeof _global.process !== 'undefined' &&\n    _global.process.toString() === '[object process]';\nconst isBrowser = !isNode && !isWebWorker && !!(isWindowExists && internalWindow['HTMLElement']);\n// we are in electron of nw, so we are both browser and nodejs\n// Make sure to access `process` through `_global` so that WebPack does not accidentally browserify\n// this code.\nconst isMix = typeof _global.process !== 'undefined' &&\n    _global.process.toString() === '[object process]' &&\n    !isWebWorker &&\n    !!(isWindowExists && internalWindow['HTMLElement']);\nconst zoneSymbolEventNames$1 = {};\nconst enableBeforeunloadSymbol = zoneSymbol('enable_beforeunload');\nconst wrapFn = function (event) {\n    // https://github.com/angular/zone.js/issues/911, in IE, sometimes\n    // event will be undefined, so we need to use window.event\n    event = event || _global.event;\n    if (!event) {\n        return;\n    }\n    let eventNameSymbol = zoneSymbolEventNames$1[event.type];\n    if (!eventNameSymbol) {\n        eventNameSymbol = zoneSymbolEventNames$1[event.type] = zoneSymbol('ON_PROPERTY' + event.type);\n    }\n    const target = this || event.target || _global;\n    const listener = target[eventNameSymbol];\n    let result;\n    if (isBrowser && target === internalWindow && event.type === 'error') {\n        // window.onerror have different signature\n        // https://developer.mozilla.org/en-US/docs/Web/API/GlobalEventHandlers/onerror#window.onerror\n        // and onerror callback will prevent default when callback return true\n        const errorEvent = event;\n        result =\n            listener &&\n                listener.call(this, errorEvent.message, errorEvent.filename, errorEvent.lineno, errorEvent.colno, errorEvent.error);\n        if (result === true) {\n            event.preventDefault();\n        }\n    }\n    else {\n        result = listener && listener.apply(this, arguments);\n        if (\n        // https://github.com/angular/angular/issues/47579\n        // https://www.w3.org/TR/2011/WD-html5-20110525/history.html#beforeunloadevent\n        // This is the only specific case we should check for. The spec defines that the\n        // `returnValue` attribute represents the message to show the user. When the event\n        // is created, this attribute must be set to the empty string.\n        event.type === 'beforeunload' &&\n            // To prevent any breaking changes resulting from this change, given that\n            // it was already causing a significant number of failures in G3, we have hidden\n            // that behavior behind a global configuration flag. Consumers can enable this\n            // flag explicitly if they want the `beforeunload` event to be handled as defined\n            // in the specification.\n            _global[enableBeforeunloadSymbol] &&\n            // The IDL event definition is `attribute DOMString returnValue`, so we check whether\n            // `typeof result` is a string.\n            typeof result === 'string') {\n            event.returnValue = result;\n        }\n        else if (result != undefined && !result) {\n            event.preventDefault();\n        }\n    }\n    return result;\n};\nfunction patchProperty(obj, prop, prototype) {\n    let desc = ObjectGetOwnPropertyDescriptor(obj, prop);\n    if (!desc && prototype) {\n        // when patch window object, use prototype to check prop exist or not\n        const prototypeDesc = ObjectGetOwnPropertyDescriptor(prototype, prop);\n        if (prototypeDesc) {\n            desc = { enumerable: true, configurable: true };\n        }\n    }\n    // if the descriptor not exists or is not configurable\n    // just return\n    if (!desc || !desc.configurable) {\n        return;\n    }\n    const onPropPatchedSymbol = zoneSymbol('on' + prop + 'patched');\n    if (obj.hasOwnProperty(onPropPatchedSymbol) && obj[onPropPatchedSymbol]) {\n        return;\n    }\n    // A property descriptor cannot have getter/setter and be writable\n    // deleting the writable and value properties avoids this error:\n    //\n    // TypeError: property descriptors must not specify a value or be writable when a\n    // getter or setter has been specified\n    delete desc.writable;\n    delete desc.value;\n    const originalDescGet = desc.get;\n    const originalDescSet = desc.set;\n    // slice(2) cuz 'onclick' -> 'click', etc\n    const eventName = prop.slice(2);\n    let eventNameSymbol = zoneSymbolEventNames$1[eventName];\n    if (!eventNameSymbol) {\n        eventNameSymbol = zoneSymbolEventNames$1[eventName] = zoneSymbol('ON_PROPERTY' + eventName);\n    }\n    desc.set = function (newValue) {\n        // in some of windows's onproperty callback, this is undefined\n        // so we need to check it\n        let target = this;\n        if (!target && obj === _global) {\n            target = _global;\n        }\n        if (!target) {\n            return;\n        }\n        const previousValue = target[eventNameSymbol];\n        if (typeof previousValue === 'function') {\n            target.removeEventListener(eventName, wrapFn);\n        }\n        // issue #978, when onload handler was added before loading zone.js\n        // we should remove it with originalDescSet\n        originalDescSet && originalDescSet.call(target, null);\n        target[eventNameSymbol] = newValue;\n        if (typeof newValue === 'function') {\n            target.addEventListener(eventName, wrapFn, false);\n        }\n    };\n    // The getter would return undefined for unassigned properties but the default value of an\n    // unassigned property is null\n    desc.get = function () {\n        // in some of windows's onproperty callback, this is undefined\n        // so we need to check it\n        let target = this;\n        if (!target && obj === _global) {\n            target = _global;\n        }\n        if (!target) {\n            return null;\n        }\n        const listener = target[eventNameSymbol];\n        if (listener) {\n            return listener;\n        }\n        else if (originalDescGet) {\n            // result will be null when use inline event attribute,\n            // such as <button onclick=\"func();\">OK</button>\n            // because the onclick function is internal raw uncompiled handler\n            // the onclick will be evaluated when first time event was triggered or\n            // the property is accessed, https://github.com/angular/zone.js/issues/525\n            // so we should use original native get to retrieve the handler\n            let value = originalDescGet.call(this);\n            if (value) {\n                desc.set.call(this, value);\n                if (typeof target[REMOVE_ATTRIBUTE] === 'function') {\n                    target.removeAttribute(prop);\n                }\n                return value;\n            }\n        }\n        return null;\n    };\n    ObjectDefineProperty(obj, prop, desc);\n    obj[onPropPatchedSymbol] = true;\n}\nfunction patchOnProperties(obj, properties, prototype) {\n    if (properties) {\n        for (let i = 0; i < properties.length; i++) {\n            patchProperty(obj, 'on' + properties[i], prototype);\n        }\n    }\n    else {\n        const onProperties = [];\n        for (const prop in obj) {\n            if (prop.slice(0, 2) == 'on') {\n                onProperties.push(prop);\n            }\n        }\n        for (let j = 0; j < onProperties.length; j++) {\n            patchProperty(obj, onProperties[j], prototype);\n        }\n    }\n}\nconst originalInstanceKey = zoneSymbol('originalInstance');\n// wrap some native API on `window`\nfunction patchClass(className) {\n    const OriginalClass = _global[className];\n    if (!OriginalClass)\n        return;\n    // keep original class in global\n    _global[zoneSymbol(className)] = OriginalClass;\n    _global[className] = function () {\n        const a = bindArguments(arguments, className);\n        switch (a.length) {\n            case 0:\n                this[originalInstanceKey] = new OriginalClass();\n                break;\n            case 1:\n                this[originalInstanceKey] = new OriginalClass(a[0]);\n                break;\n            case 2:\n                this[originalInstanceKey] = new OriginalClass(a[0], a[1]);\n                break;\n            case 3:\n                this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2]);\n                break;\n            case 4:\n                this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2], a[3]);\n                break;\n            default:\n                throw new Error('Arg list too long.');\n        }\n    };\n    // attach original delegate to patched function\n    attachOriginToPatched(_global[className], OriginalClass);\n    const instance = new OriginalClass(function () { });\n    let prop;\n    for (prop in instance) {\n        // https://bugs.webkit.org/show_bug.cgi?id=44721\n        if (className === 'XMLHttpRequest' && prop === 'responseBlob')\n            continue;\n        (function (prop) {\n            if (typeof instance[prop] === 'function') {\n                _global[className].prototype[prop] = function () {\n                    return this[originalInstanceKey][prop].apply(this[originalInstanceKey], arguments);\n                };\n            }\n            else {\n                ObjectDefineProperty(_global[className].prototype, prop, {\n                    set: function (fn) {\n                        if (typeof fn === 'function') {\n                            this[originalInstanceKey][prop] = wrapWithCurrentZone(fn, className + '.' + prop);\n                            // keep callback in wrapped function so we can\n                            // use it in Function.prototype.toString to return\n                            // the native one.\n                            attachOriginToPatched(this[originalInstanceKey][prop], fn);\n                        }\n                        else {\n                            this[originalInstanceKey][prop] = fn;\n                        }\n                    },\n                    get: function () {\n                        return this[originalInstanceKey][prop];\n                    },\n                });\n            }\n        })(prop);\n    }\n    for (prop in OriginalClass) {\n        if (prop !== 'prototype' && OriginalClass.hasOwnProperty(prop)) {\n            _global[className][prop] = OriginalClass[prop];\n        }\n    }\n}\nfunction patchMethod(target, name, patchFn) {\n    let proto = target;\n    while (proto && !proto.hasOwnProperty(name)) {\n        proto = ObjectGetPrototypeOf(proto);\n    }\n    if (!proto && target[name]) {\n        // somehow we did not find it, but we can see it. This happens on IE for Window properties.\n        proto = target;\n    }\n    const delegateName = zoneSymbol(name);\n    let delegate = null;\n    if (proto && (!(delegate = proto[delegateName]) || !proto.hasOwnProperty(delegateName))) {\n        delegate = proto[delegateName] = proto[name];\n        // check whether proto[name] is writable\n        // some property is readonly in safari, such as HtmlCanvasElement.prototype.toBlob\n        const desc = proto && ObjectGetOwnPropertyDescriptor(proto, name);\n        if (isPropertyWritable(desc)) {\n            const patchDelegate = patchFn(delegate, delegateName, name);\n            proto[name] = function () {\n                return patchDelegate(this, arguments);\n            };\n            attachOriginToPatched(proto[name], delegate);\n        }\n    }\n    return delegate;\n}\n// TODO: @JiaLiPassion, support cancel task later if necessary\nfunction patchMacroTask(obj, funcName, metaCreator) {\n    let setNative = null;\n    function scheduleTask(task) {\n        const data = task.data;\n        data.args[data.cbIdx] = function () {\n            task.invoke.apply(this, arguments);\n        };\n        setNative.apply(data.target, data.args);\n        return task;\n    }\n    setNative = patchMethod(obj, funcName, (delegate) => function (self, args) {\n        const meta = metaCreator(self, args);\n        if (meta.cbIdx >= 0 && typeof args[meta.cbIdx] === 'function') {\n            return scheduleMacroTaskWithCurrentZone(meta.name, args[meta.cbIdx], meta, scheduleTask);\n        }\n        else {\n            // cause an error by calling it directly.\n            return delegate.apply(self, args);\n        }\n    });\n}\nfunction attachOriginToPatched(patched, original) {\n    patched[zoneSymbol('OriginalDelegate')] = original;\n}\nlet isDetectedIEOrEdge = false;\nlet ieOrEdge = false;\nfunction isIE() {\n    try {\n        const ua = internalWindow.navigator.userAgent;\n        if (ua.indexOf('MSIE ') !== -1 || ua.indexOf('Trident/') !== -1) {\n            return true;\n        }\n    }\n    catch (error) { }\n    return false;\n}\nfunction isIEOrEdge() {\n    if (isDetectedIEOrEdge) {\n        return ieOrEdge;\n    }\n    isDetectedIEOrEdge = true;\n    try {\n        const ua = internalWindow.navigator.userAgent;\n        if (ua.indexOf('MSIE ') !== -1 || ua.indexOf('Trident/') !== -1 || ua.indexOf('Edge/') !== -1) {\n            ieOrEdge = true;\n        }\n    }\n    catch (error) { }\n    return ieOrEdge;\n}\nfunction isFunction(value) {\n    return typeof value === 'function';\n}\nfunction isNumber(value) {\n    return typeof value === 'number';\n}\n\n/**\n * @fileoverview\n * @suppress {missingRequire}\n */\n// Note that passive event listeners are now supported by most modern browsers,\n// including Chrome, Firefox, Safari, and Edge. There's a pending change that\n// would remove support for legacy browsers by zone.js. Removing `passiveSupported`\n// from the codebase will reduce the final code size for existing apps that still use zone.js.\nlet passiveSupported = false;\nif (typeof window !== 'undefined') {\n    try {\n        const options = Object.defineProperty({}, 'passive', {\n            get: function () {\n                passiveSupported = true;\n            },\n        });\n        // Note: We pass the `options` object as the event handler too. This is not compatible with the\n        // signature of `addEventListener` or `removeEventListener` but enables us to remove the handler\n        // without an actual handler.\n        window.addEventListener('test', options, options);\n        window.removeEventListener('test', options, options);\n    }\n    catch (err) {\n        passiveSupported = false;\n    }\n}\n// an identifier to tell ZoneTask do not create a new invoke closure\nconst OPTIMIZED_ZONE_EVENT_TASK_DATA = {\n    useG: true,\n};\nconst zoneSymbolEventNames = {};\nconst globalSources = {};\nconst EVENT_NAME_SYMBOL_REGX = new RegExp('^' + ZONE_SYMBOL_PREFIX + '(\\\\w+)(true|false)$');\nconst IMMEDIATE_PROPAGATION_SYMBOL = zoneSymbol('propagationStopped');\nfunction prepareEventNames(eventName, eventNameToString) {\n    const falseEventName = (eventNameToString ? eventNameToString(eventName) : eventName) + FALSE_STR;\n    const trueEventName = (eventNameToString ? eventNameToString(eventName) : eventName) + TRUE_STR;\n    const symbol = ZONE_SYMBOL_PREFIX + falseEventName;\n    const symbolCapture = ZONE_SYMBOL_PREFIX + trueEventName;\n    zoneSymbolEventNames[eventName] = {};\n    zoneSymbolEventNames[eventName][FALSE_STR] = symbol;\n    zoneSymbolEventNames[eventName][TRUE_STR] = symbolCapture;\n}\nfunction patchEventTarget(_global, api, apis, patchOptions) {\n    const ADD_EVENT_LISTENER = (patchOptions && patchOptions.add) || ADD_EVENT_LISTENER_STR;\n    const REMOVE_EVENT_LISTENER = (patchOptions && patchOptions.rm) || REMOVE_EVENT_LISTENER_STR;\n    const LISTENERS_EVENT_LISTENER = (patchOptions && patchOptions.listeners) || 'eventListeners';\n    const REMOVE_ALL_LISTENERS_EVENT_LISTENER = (patchOptions && patchOptions.rmAll) || 'removeAllListeners';\n    const zoneSymbolAddEventListener = zoneSymbol(ADD_EVENT_LISTENER);\n    const ADD_EVENT_LISTENER_SOURCE = '.' + ADD_EVENT_LISTENER + ':';\n    const PREPEND_EVENT_LISTENER = 'prependListener';\n    const PREPEND_EVENT_LISTENER_SOURCE = '.' + PREPEND_EVENT_LISTENER + ':';\n    const invokeTask = function (task, target, event) {\n        // for better performance, check isRemoved which is set\n        // by removeEventListener\n        if (task.isRemoved) {\n            return;\n        }\n        const delegate = task.callback;\n        if (typeof delegate === 'object' && delegate.handleEvent) {\n            // create the bind version of handleEvent when invoke\n            task.callback = (event) => delegate.handleEvent(event);\n            task.originalDelegate = delegate;\n        }\n        // invoke static task.invoke\n        // need to try/catch error here, otherwise, the error in one event listener\n        // will break the executions of the other event listeners. Also error will\n        // not remove the event listener when `once` options is true.\n        let error;\n        try {\n            task.invoke(task, target, [event]);\n        }\n        catch (err) {\n            error = err;\n        }\n        const options = task.options;\n        if (options && typeof options === 'object' && options.once) {\n            // if options.once is true, after invoke once remove listener here\n            // only browser need to do this, nodejs eventEmitter will cal removeListener\n            // inside EventEmitter.once\n            const delegate = task.originalDelegate ? task.originalDelegate : task.callback;\n            target[REMOVE_EVENT_LISTENER].call(target, event.type, delegate, options);\n        }\n        return error;\n    };\n    function globalCallback(context, event, isCapture) {\n        // https://github.com/angular/zone.js/issues/911, in IE, sometimes\n        // event will be undefined, so we need to use window.event\n        event = event || _global.event;\n        if (!event) {\n            return;\n        }\n        // event.target is needed for Samsung TV and SourceBuffer\n        // || global is needed https://github.com/angular/zone.js/issues/190\n        const target = context || event.target || _global;\n        const tasks = target[zoneSymbolEventNames[event.type][isCapture ? TRUE_STR : FALSE_STR]];\n        if (tasks) {\n            const errors = [];\n            // invoke all tasks which attached to current target with given event.type and capture = false\n            // for performance concern, if task.length === 1, just invoke\n            if (tasks.length === 1) {\n                const err = invokeTask(tasks[0], target, event);\n                err && errors.push(err);\n            }\n            else {\n                // https://github.com/angular/zone.js/issues/836\n                // copy the tasks array before invoke, to avoid\n                // the callback will remove itself or other listener\n                const copyTasks = tasks.slice();\n                for (let i = 0; i < copyTasks.length; i++) {\n                    if (event && event[IMMEDIATE_PROPAGATION_SYMBOL] === true) {\n                        break;\n                    }\n                    const err = invokeTask(copyTasks[i], target, event);\n                    err && errors.push(err);\n                }\n            }\n            // Since there is only one error, we don't need to schedule microTask\n            // to throw the error.\n            if (errors.length === 1) {\n                throw errors[0];\n            }\n            else {\n                for (let i = 0; i < errors.length; i++) {\n                    const err = errors[i];\n                    api.nativeScheduleMicroTask(() => {\n                        throw err;\n                    });\n                }\n            }\n        }\n    }\n    // global shared zoneAwareCallback to handle all event callback with capture = false\n    const globalZoneAwareCallback = function (event) {\n        return globalCallback(this, event, false);\n    };\n    // global shared zoneAwareCallback to handle all event callback with capture = true\n    const globalZoneAwareCaptureCallback = function (event) {\n        return globalCallback(this, event, true);\n    };\n    function patchEventTargetMethods(obj, patchOptions) {\n        if (!obj) {\n            return false;\n        }\n        let useGlobalCallback = true;\n        if (patchOptions && patchOptions.useG !== undefined) {\n            useGlobalCallback = patchOptions.useG;\n        }\n        const validateHandler = patchOptions && patchOptions.vh;\n        let checkDuplicate = true;\n        if (patchOptions && patchOptions.chkDup !== undefined) {\n            checkDuplicate = patchOptions.chkDup;\n        }\n        let returnTarget = false;\n        if (patchOptions && patchOptions.rt !== undefined) {\n            returnTarget = patchOptions.rt;\n        }\n        let proto = obj;\n        while (proto && !proto.hasOwnProperty(ADD_EVENT_LISTENER)) {\n            proto = ObjectGetPrototypeOf(proto);\n        }\n        if (!proto && obj[ADD_EVENT_LISTENER]) {\n            // somehow we did not find it, but we can see it. This happens on IE for Window properties.\n            proto = obj;\n        }\n        if (!proto) {\n            return false;\n        }\n        if (proto[zoneSymbolAddEventListener]) {\n            return false;\n        }\n        const eventNameToString = patchOptions && patchOptions.eventNameToString;\n        // We use a shared global `taskData` to pass data for `scheduleEventTask`,\n        // eliminating the need to create a new object solely for passing data.\n        // WARNING: This object has a static lifetime, meaning it is not created\n        // each time `addEventListener` is called. It is instantiated only once\n        // and captured by reference inside the `addEventListener` and\n        // `removeEventListener` functions. Do not add any new properties to this\n        // object, as doing so would necessitate maintaining the information\n        // between `addEventListener` calls.\n        const taskData = {};\n        const nativeAddEventListener = (proto[zoneSymbolAddEventListener] = proto[ADD_EVENT_LISTENER]);\n        const nativeRemoveEventListener = (proto[zoneSymbol(REMOVE_EVENT_LISTENER)] =\n            proto[REMOVE_EVENT_LISTENER]);\n        const nativeListeners = (proto[zoneSymbol(LISTENERS_EVENT_LISTENER)] =\n            proto[LISTENERS_EVENT_LISTENER]);\n        const nativeRemoveAllListeners = (proto[zoneSymbol(REMOVE_ALL_LISTENERS_EVENT_LISTENER)] =\n            proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER]);\n        let nativePrependEventListener;\n        if (patchOptions && patchOptions.prepend) {\n            nativePrependEventListener = proto[zoneSymbol(patchOptions.prepend)] =\n                proto[patchOptions.prepend];\n        }\n        /**\n         * This util function will build an option object with passive option\n         * to handle all possible input from the user.\n         */\n        function buildEventListenerOptions(options, passive) {\n            if (!passiveSupported && typeof options === 'object' && options) {\n                // doesn't support passive but user want to pass an object as options.\n                // this will not work on some old browser, so we just pass a boolean\n                // as useCapture parameter\n                return !!options.capture;\n            }\n            if (!passiveSupported || !passive) {\n                return options;\n            }\n            if (typeof options === 'boolean') {\n                return { capture: options, passive: true };\n            }\n            if (!options) {\n                return { passive: true };\n            }\n            if (typeof options === 'object' && options.passive !== false) {\n                return { ...options, passive: true };\n            }\n            return options;\n        }\n        const customScheduleGlobal = function (task) {\n            // if there is already a task for the eventName + capture,\n            // just return, because we use the shared globalZoneAwareCallback here.\n            if (taskData.isExisting) {\n                return;\n            }\n            return nativeAddEventListener.call(taskData.target, taskData.eventName, taskData.capture ? globalZoneAwareCaptureCallback : globalZoneAwareCallback, taskData.options);\n        };\n        /**\n         * In the context of events and listeners, this function will be\n         * called at the end by `cancelTask`, which, in turn, calls `task.cancelFn`.\n         * Cancelling a task is primarily used to remove event listeners from\n         * the task target.\n         */\n        const customCancelGlobal = function (task) {\n            // if task is not marked as isRemoved, this call is directly\n            // from Zone.prototype.cancelTask, we should remove the task\n            // from tasksList of target first\n            if (!task.isRemoved) {\n                const symbolEventNames = zoneSymbolEventNames[task.eventName];\n                let symbolEventName;\n                if (symbolEventNames) {\n                    symbolEventName = symbolEventNames[task.capture ? TRUE_STR : FALSE_STR];\n                }\n                const existingTasks = symbolEventName && task.target[symbolEventName];\n                if (existingTasks) {\n                    for (let i = 0; i < existingTasks.length; i++) {\n                        const existingTask = existingTasks[i];\n                        if (existingTask === task) {\n                            existingTasks.splice(i, 1);\n                            // set isRemoved to data for faster invokeTask check\n                            task.isRemoved = true;\n                            if (task.removeAbortListener) {\n                                task.removeAbortListener();\n                                task.removeAbortListener = null;\n                            }\n                            if (existingTasks.length === 0) {\n                                // all tasks for the eventName + capture have gone,\n                                // remove globalZoneAwareCallback and remove the task cache from target\n                                task.allRemoved = true;\n                                task.target[symbolEventName] = null;\n                            }\n                            break;\n                        }\n                    }\n                }\n            }\n            // if all tasks for the eventName + capture have gone,\n            // we will really remove the global event callback,\n            // if not, return\n            if (!task.allRemoved) {\n                return;\n            }\n            return nativeRemoveEventListener.call(task.target, task.eventName, task.capture ? globalZoneAwareCaptureCallback : globalZoneAwareCallback, task.options);\n        };\n        const customScheduleNonGlobal = function (task) {\n            return nativeAddEventListener.call(taskData.target, taskData.eventName, task.invoke, taskData.options);\n        };\n        const customSchedulePrepend = function (task) {\n            return nativePrependEventListener.call(taskData.target, taskData.eventName, task.invoke, taskData.options);\n        };\n        const customCancelNonGlobal = function (task) {\n            return nativeRemoveEventListener.call(task.target, task.eventName, task.invoke, task.options);\n        };\n        const customSchedule = useGlobalCallback ? customScheduleGlobal : customScheduleNonGlobal;\n        const customCancel = useGlobalCallback ? customCancelGlobal : customCancelNonGlobal;\n        const compareTaskCallbackVsDelegate = function (task, delegate) {\n            const typeOfDelegate = typeof delegate;\n            return ((typeOfDelegate === 'function' && task.callback === delegate) ||\n                (typeOfDelegate === 'object' && task.originalDelegate === delegate));\n        };\n        const compare = patchOptions && patchOptions.diff ? patchOptions.diff : compareTaskCallbackVsDelegate;\n        const unpatchedEvents = Zone[zoneSymbol('UNPATCHED_EVENTS')];\n        const passiveEvents = _global[zoneSymbol('PASSIVE_EVENTS')];\n        function copyEventListenerOptions(options) {\n            if (typeof options === 'object' && options !== null) {\n                // We need to destructure the target `options` object since it may\n                // be frozen or sealed (possibly provided implicitly by a third-party\n                // library), or its properties may be readonly.\n                const newOptions = { ...options };\n                // The `signal` option was recently introduced, which caused regressions in\n                // third-party scenarios where `AbortController` was directly provided to\n                // `addEventListener` as options. For instance, in cases like\n                // `document.addEventListener('keydown', callback, abortControllerInstance)`,\n                // which is valid because `AbortController` includes a `signal` getter, spreading\n                // `{...options}` wouldn't copy the `signal`. Additionally, using `Object.create`\n                // isn't feasible since `AbortController` is a built-in object type, and attempting\n                // to create a new object directly with it as the prototype might result in\n                // unexpected behavior.\n                if (options.signal) {\n                    newOptions.signal = options.signal;\n                }\n                return newOptions;\n            }\n            return options;\n        }\n        const makeAddListener = function (nativeListener, addSource, customScheduleFn, customCancelFn, returnTarget = false, prepend = false) {\n            return function () {\n                const target = this || _global;\n                let eventName = arguments[0];\n                if (patchOptions && patchOptions.transferEventName) {\n                    eventName = patchOptions.transferEventName(eventName);\n                }\n                let delegate = arguments[1];\n                if (!delegate) {\n                    return nativeListener.apply(this, arguments);\n                }\n                if (isNode && eventName === 'uncaughtException') {\n                    // don't patch uncaughtException of nodejs to prevent endless loop\n                    return nativeListener.apply(this, arguments);\n                }\n                // don't create the bind delegate function for handleEvent\n                // case here to improve addEventListener performance\n                // we will create the bind delegate when invoke\n                let isHandleEvent = false;\n                if (typeof delegate !== 'function') {\n                    if (!delegate.handleEvent) {\n                        return nativeListener.apply(this, arguments);\n                    }\n                    isHandleEvent = true;\n                }\n                if (validateHandler && !validateHandler(nativeListener, delegate, target, arguments)) {\n                    return;\n                }\n                const passive = passiveSupported && !!passiveEvents && passiveEvents.indexOf(eventName) !== -1;\n                const options = copyEventListenerOptions(buildEventListenerOptions(arguments[2], passive));\n                const signal = options?.signal;\n                if (signal?.aborted) {\n                    // the signal is an aborted one, just return without attaching the event listener.\n                    return;\n                }\n                if (unpatchedEvents) {\n                    // check unpatched list\n                    for (let i = 0; i < unpatchedEvents.length; i++) {\n                        if (eventName === unpatchedEvents[i]) {\n                            if (passive) {\n                                return nativeListener.call(target, eventName, delegate, options);\n                            }\n                            else {\n                                return nativeListener.apply(this, arguments);\n                            }\n                        }\n                    }\n                }\n                const capture = !options ? false : typeof options === 'boolean' ? true : options.capture;\n                const once = options && typeof options === 'object' ? options.once : false;\n                const zone = Zone.current;\n                let symbolEventNames = zoneSymbolEventNames[eventName];\n                if (!symbolEventNames) {\n                    prepareEventNames(eventName, eventNameToString);\n                    symbolEventNames = zoneSymbolEventNames[eventName];\n                }\n                const symbolEventName = symbolEventNames[capture ? TRUE_STR : FALSE_STR];\n                let existingTasks = target[symbolEventName];\n                let isExisting = false;\n                if (existingTasks) {\n                    // already have task registered\n                    isExisting = true;\n                    if (checkDuplicate) {\n                        for (let i = 0; i < existingTasks.length; i++) {\n                            if (compare(existingTasks[i], delegate)) {\n                                // same callback, same capture, same event name, just return\n                                return;\n                            }\n                        }\n                    }\n                }\n                else {\n                    existingTasks = target[symbolEventName] = [];\n                }\n                let source;\n                const constructorName = target.constructor['name'];\n                const targetSource = globalSources[constructorName];\n                if (targetSource) {\n                    source = targetSource[eventName];\n                }\n                if (!source) {\n                    source =\n                        constructorName +\n                            addSource +\n                            (eventNameToString ? eventNameToString(eventName) : eventName);\n                }\n                // In the code below, `options` should no longer be reassigned; instead, it\n                // should only be mutated. This is because we pass that object to the native\n                // `addEventListener`.\n                // It's generally recommended to use the same object reference for options.\n                // This ensures consistency and avoids potential issues.\n                taskData.options = options;\n                if (once) {\n                    // When using `addEventListener` with the `once` option, we don't pass\n                    // the `once` option directly to the native `addEventListener` method.\n                    // Instead, we keep the `once` setting and handle it ourselves.\n                    taskData.options.once = false;\n                }\n                taskData.target = target;\n                taskData.capture = capture;\n                taskData.eventName = eventName;\n                taskData.isExisting = isExisting;\n                const data = useGlobalCallback ? OPTIMIZED_ZONE_EVENT_TASK_DATA : undefined;\n                // keep taskData into data to allow onScheduleEventTask to access the task information\n                if (data) {\n                    data.taskData = taskData;\n                }\n                if (signal) {\n                    // When using `addEventListener` with the `signal` option, we don't pass\n                    // the `signal` option directly to the native `addEventListener` method.\n                    // Instead, we keep the `signal` setting and handle it ourselves.\n                    taskData.options.signal = undefined;\n                }\n                // The `scheduleEventTask` function will ultimately call `customScheduleGlobal`,\n                // which in turn calls the native `addEventListener`. This is why `taskData.options`\n                // is updated before scheduling the task, as `customScheduleGlobal` uses\n                // `taskData.options` to pass it to the native `addEventListener`.\n                const task = zone.scheduleEventTask(source, delegate, data, customScheduleFn, customCancelFn);\n                if (signal) {\n                    // after task is scheduled, we need to store the signal back to task.options\n                    taskData.options.signal = signal;\n                    // Wrapping `task` in a weak reference would not prevent memory leaks. Weak references are\n                    // primarily used for preventing strong references cycles. `onAbort` is always reachable\n                    // as it's an event listener, so its closure retains a strong reference to the `task`.\n                    const onAbort = () => task.zone.cancelTask(task);\n                    nativeListener.call(signal, 'abort', onAbort, { once: true });\n                    // We need to remove the `abort` listener when the event listener is going to be removed,\n                    // as it creates a closure that captures `task`. This closure retains a reference to the\n                    // `task` object even after it goes out of scope, preventing `task` from being garbage\n                    // collected.\n                    task.removeAbortListener = () => signal.removeEventListener('abort', onAbort);\n                }\n                // should clear taskData.target to avoid memory leak\n                // issue, https://github.com/angular/angular/issues/20442\n                taskData.target = null;\n                // need to clear up taskData because it is a global object\n                if (data) {\n                    data.taskData = null;\n                }\n                // have to save those information to task in case\n                // application may call task.zone.cancelTask() directly\n                if (once) {\n                    taskData.options.once = true;\n                }\n                if (!(!passiveSupported && typeof task.options === 'boolean')) {\n                    // if not support passive, and we pass an option object\n                    // to addEventListener, we should save the options to task\n                    task.options = options;\n                }\n                task.target = target;\n                task.capture = capture;\n                task.eventName = eventName;\n                if (isHandleEvent) {\n                    // save original delegate for compare to check duplicate\n                    task.originalDelegate = delegate;\n                }\n                if (!prepend) {\n                    existingTasks.push(task);\n                }\n                else {\n                    existingTasks.unshift(task);\n                }\n                if (returnTarget) {\n                    return target;\n                }\n            };\n        };\n        proto[ADD_EVENT_LISTENER] = makeAddListener(nativeAddEventListener, ADD_EVENT_LISTENER_SOURCE, customSchedule, customCancel, returnTarget);\n        if (nativePrependEventListener) {\n            proto[PREPEND_EVENT_LISTENER] = makeAddListener(nativePrependEventListener, PREPEND_EVENT_LISTENER_SOURCE, customSchedulePrepend, customCancel, returnTarget, true);\n        }\n        proto[REMOVE_EVENT_LISTENER] = function () {\n            const target = this || _global;\n            let eventName = arguments[0];\n            if (patchOptions && patchOptions.transferEventName) {\n                eventName = patchOptions.transferEventName(eventName);\n            }\n            const options = arguments[2];\n            const capture = !options ? false : typeof options === 'boolean' ? true : options.capture;\n            const delegate = arguments[1];\n            if (!delegate) {\n                return nativeRemoveEventListener.apply(this, arguments);\n            }\n            if (validateHandler &&\n                !validateHandler(nativeRemoveEventListener, delegate, target, arguments)) {\n                return;\n            }\n            const symbolEventNames = zoneSymbolEventNames[eventName];\n            let symbolEventName;\n            if (symbolEventNames) {\n                symbolEventName = symbolEventNames[capture ? TRUE_STR : FALSE_STR];\n            }\n            const existingTasks = symbolEventName && target[symbolEventName];\n            // `existingTasks` may not exist if the `addEventListener` was called before\n            // it was patched by zone.js. Please refer to the attached issue for\n            // clarification, particularly after the `if` condition, before calling\n            // the native `removeEventListener`.\n            if (existingTasks) {\n                for (let i = 0; i < existingTasks.length; i++) {\n                    const existingTask = existingTasks[i];\n                    if (compare(existingTask, delegate)) {\n                        existingTasks.splice(i, 1);\n                        // set isRemoved to data for faster invokeTask check\n                        existingTask.isRemoved = true;\n                        if (existingTasks.length === 0) {\n                            // all tasks for the eventName + capture have gone,\n                            // remove globalZoneAwareCallback and remove the task cache from target\n                            existingTask.allRemoved = true;\n                            target[symbolEventName] = null;\n                            // in the target, we have an event listener which is added by on_property\n                            // such as target.onclick = function() {}, so we need to clear this internal\n                            // property too if all delegates with capture=false were removed\n                            // https:// github.com/angular/angular/issues/31643\n                            // https://github.com/angular/angular/issues/54581\n                            if (!capture && typeof eventName === 'string') {\n                                const onPropertySymbol = ZONE_SYMBOL_PREFIX + 'ON_PROPERTY' + eventName;\n                                target[onPropertySymbol] = null;\n                            }\n                        }\n                        // In all other conditions, when `addEventListener` is called after being\n                        // patched by zone.js, we would always find an event task on the `EventTarget`.\n                        // This will trigger `cancelFn` on the `existingTask`, leading to `customCancelGlobal`,\n                        // which ultimately removes an event listener and cleans up the abort listener\n                        // (if an `AbortSignal` was provided when scheduling a task).\n                        existingTask.zone.cancelTask(existingTask);\n                        if (returnTarget) {\n                            return target;\n                        }\n                        return;\n                    }\n                }\n            }\n            // https://github.com/angular/zone.js/issues/930\n            // We may encounter a situation where the `addEventListener` was\n            // called on the event target before zone.js is loaded, resulting\n            // in no task being stored on the event target due to its invocation\n            // of the native implementation. In this scenario, we simply need to\n            // invoke the native `removeEventListener`.\n            return nativeRemoveEventListener.apply(this, arguments);\n        };\n        proto[LISTENERS_EVENT_LISTENER] = function () {\n            const target = this || _global;\n            let eventName = arguments[0];\n            if (patchOptions && patchOptions.transferEventName) {\n                eventName = patchOptions.transferEventName(eventName);\n            }\n            const listeners = [];\n            const tasks = findEventTasks(target, eventNameToString ? eventNameToString(eventName) : eventName);\n            for (let i = 0; i < tasks.length; i++) {\n                const task = tasks[i];\n                let delegate = task.originalDelegate ? task.originalDelegate : task.callback;\n                listeners.push(delegate);\n            }\n            return listeners;\n        };\n        proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER] = function () {\n            const target = this || _global;\n            let eventName = arguments[0];\n            if (!eventName) {\n                const keys = Object.keys(target);\n                for (let i = 0; i < keys.length; i++) {\n                    const prop = keys[i];\n                    const match = EVENT_NAME_SYMBOL_REGX.exec(prop);\n                    let evtName = match && match[1];\n                    // in nodejs EventEmitter, removeListener event is\n                    // used for monitoring the removeListener call,\n                    // so just keep removeListener eventListener until\n                    // all other eventListeners are removed\n                    if (evtName && evtName !== 'removeListener') {\n                        this[REMOVE_ALL_LISTENERS_EVENT_LISTENER].call(this, evtName);\n                    }\n                }\n                // remove removeListener listener finally\n                this[REMOVE_ALL_LISTENERS_EVENT_LISTENER].call(this, 'removeListener');\n            }\n            else {\n                if (patchOptions && patchOptions.transferEventName) {\n                    eventName = patchOptions.transferEventName(eventName);\n                }\n                const symbolEventNames = zoneSymbolEventNames[eventName];\n                if (symbolEventNames) {\n                    const symbolEventName = symbolEventNames[FALSE_STR];\n                    const symbolCaptureEventName = symbolEventNames[TRUE_STR];\n                    const tasks = target[symbolEventName];\n                    const captureTasks = target[symbolCaptureEventName];\n                    if (tasks) {\n                        const removeTasks = tasks.slice();\n                        for (let i = 0; i < removeTasks.length; i++) {\n                            const task = removeTasks[i];\n                            let delegate = task.originalDelegate ? task.originalDelegate : task.callback;\n                            this[REMOVE_EVENT_LISTENER].call(this, eventName, delegate, task.options);\n                        }\n                    }\n                    if (captureTasks) {\n                        const removeTasks = captureTasks.slice();\n                        for (let i = 0; i < removeTasks.length; i++) {\n                            const task = removeTasks[i];\n                            let delegate = task.originalDelegate ? task.originalDelegate : task.callback;\n                            this[REMOVE_EVENT_LISTENER].call(this, eventName, delegate, task.options);\n                        }\n                    }\n                }\n            }\n            if (returnTarget) {\n                return this;\n            }\n        };\n        // for native toString patch\n        attachOriginToPatched(proto[ADD_EVENT_LISTENER], nativeAddEventListener);\n        attachOriginToPatched(proto[REMOVE_EVENT_LISTENER], nativeRemoveEventListener);\n        if (nativeRemoveAllListeners) {\n            attachOriginToPatched(proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER], nativeRemoveAllListeners);\n        }\n        if (nativeListeners) {\n            attachOriginToPatched(proto[LISTENERS_EVENT_LISTENER], nativeListeners);\n        }\n        return true;\n    }\n    let results = [];\n    for (let i = 0; i < apis.length; i++) {\n        results[i] = patchEventTargetMethods(apis[i], patchOptions);\n    }\n    return results;\n}\nfunction findEventTasks(target, eventName) {\n    if (!eventName) {\n        const foundTasks = [];\n        for (let prop in target) {\n            const match = EVENT_NAME_SYMBOL_REGX.exec(prop);\n            let evtName = match && match[1];\n            if (evtName && (!eventName || evtName === eventName)) {\n                const tasks = target[prop];\n                if (tasks) {\n                    for (let i = 0; i < tasks.length; i++) {\n                        foundTasks.push(tasks[i]);\n                    }\n                }\n            }\n        }\n        return foundTasks;\n    }\n    let symbolEventName = zoneSymbolEventNames[eventName];\n    if (!symbolEventName) {\n        prepareEventNames(eventName);\n        symbolEventName = zoneSymbolEventNames[eventName];\n    }\n    const captureFalseTasks = target[symbolEventName[FALSE_STR]];\n    const captureTrueTasks = target[symbolEventName[TRUE_STR]];\n    if (!captureFalseTasks) {\n        return captureTrueTasks ? captureTrueTasks.slice() : [];\n    }\n    else {\n        return captureTrueTasks\n            ? captureFalseTasks.concat(captureTrueTasks)\n            : captureFalseTasks.slice();\n    }\n}\nfunction patchEventPrototype(global, api) {\n    const Event = global['Event'];\n    if (Event && Event.prototype) {\n        api.patchMethod(Event.prototype, 'stopImmediatePropagation', (delegate) => function (self, args) {\n            self[IMMEDIATE_PROPAGATION_SYMBOL] = true;\n            // we need to call the native stopImmediatePropagation\n            // in case in some hybrid application, some part of\n            // application will be controlled by zone, some are not\n            delegate && delegate.apply(self, args);\n        });\n    }\n}\n\n/**\n * @fileoverview\n * @suppress {missingRequire}\n */\nfunction patchQueueMicrotask(global, api) {\n    api.patchMethod(global, 'queueMicrotask', (delegate) => {\n        return function (self, args) {\n            Zone.current.scheduleMicroTask('queueMicrotask', args[0]);\n        };\n    });\n}\n\n/**\n * @fileoverview\n * @suppress {missingRequire}\n */\nconst taskSymbol = zoneSymbol('zoneTask');\nfunction patchTimer(window, setName, cancelName, nameSuffix) {\n    let setNative = null;\n    let clearNative = null;\n    setName += nameSuffix;\n    cancelName += nameSuffix;\n    const tasksByHandleId = {};\n    function scheduleTask(task) {\n        const data = task.data;\n        data.args[0] = function () {\n            return task.invoke.apply(this, arguments);\n        };\n        const handleOrId = setNative.apply(window, data.args);\n        // Whlist on Node.js when get can the ID by using `[Symbol.toPrimitive]()` we do\n        // to this so that we do not cause potentally leaks when using `setTimeout`\n        // since this can be periodic when using `.refresh`.\n        if (isNumber(handleOrId)) {\n            data.handleId = handleOrId;\n        }\n        else {\n            data.handle = handleOrId;\n            // On Node.js a timeout and interval can be restarted over and over again by using the `.refresh` method.\n            data.isRefreshable = isFunction(handleOrId.refresh);\n        }\n        return task;\n    }\n    function clearTask(task) {\n        const { handle, handleId } = task.data;\n        return clearNative.call(window, handle ?? handleId);\n    }\n    setNative = patchMethod(window, setName, (delegate) => function (self, args) {\n        if (isFunction(args[0])) {\n            const options = {\n                isRefreshable: false,\n                isPeriodic: nameSuffix === 'Interval',\n                delay: nameSuffix === 'Timeout' || nameSuffix === 'Interval' ? args[1] || 0 : undefined,\n                args: args,\n            };\n            const callback = args[0];\n            args[0] = function timer() {\n                try {\n                    return callback.apply(this, arguments);\n                }\n                finally {\n                    // issue-934, task will be cancelled\n                    // even it is a periodic task such as\n                    // setInterval\n                    // https://github.com/angular/angular/issues/40387\n                    // Cleanup tasksByHandleId should be handled before scheduleTask\n                    // Since some zoneSpec may intercept and doesn't trigger\n                    // scheduleFn(scheduleTask) provided here.\n                    const { handle, handleId, isPeriodic, isRefreshable } = options;\n                    if (!isPeriodic && !isRefreshable) {\n                        if (handleId) {\n                            // in non-nodejs env, we remove timerId\n                            // from local cache\n                            delete tasksByHandleId[handleId];\n                        }\n                        else if (handle) {\n                            // Node returns complex objects as handleIds\n                            // we remove task reference from timer object\n                            handle[taskSymbol] = null;\n                        }\n                    }\n                }\n            };\n            const task = scheduleMacroTaskWithCurrentZone(setName, args[0], options, scheduleTask, clearTask);\n            if (!task) {\n                return task;\n            }\n            // Node.js must additionally support the ref and unref functions.\n            const { handleId, handle, isRefreshable, isPeriodic } = task.data;\n            if (handleId) {\n                // for non nodejs env, we save handleId: task\n                // mapping in local cache for clearTimeout\n                tasksByHandleId[handleId] = task;\n            }\n            else if (handle) {\n                // for nodejs env, we save task\n                // reference in timerId Object for clearTimeout\n                handle[taskSymbol] = task;\n                if (isRefreshable && !isPeriodic) {\n                    const originalRefresh = handle.refresh;\n                    handle.refresh = function () {\n                        const { zone, state } = task;\n                        if (state === 'notScheduled') {\n                            task._state = 'scheduled';\n                            zone._updateTaskCount(task, 1);\n                        }\n                        else if (state === 'running') {\n                            task._state = 'scheduling';\n                        }\n                        return originalRefresh.call(this);\n                    };\n                }\n            }\n            return handle ?? handleId ?? task;\n        }\n        else {\n            // cause an error by calling it directly.\n            return delegate.apply(window, args);\n        }\n    });\n    clearNative = patchMethod(window, cancelName, (delegate) => function (self, args) {\n        const id = args[0];\n        let task;\n        if (isNumber(id)) {\n            // non nodejs env.\n            task = tasksByHandleId[id];\n            delete tasksByHandleId[id];\n        }\n        else {\n            // nodejs env ?? other environments.\n            task = id?.[taskSymbol];\n            if (task) {\n                id[taskSymbol] = null;\n            }\n            else {\n                task = id;\n            }\n        }\n        if (task?.type) {\n            if (task.cancelFn) {\n                // Do not cancel already canceled functions\n                task.zone.cancelTask(task);\n            }\n        }\n        else {\n            // cause an error by calling it directly.\n            delegate.apply(window, args);\n        }\n    });\n}\n\nfunction patchCustomElements(_global, api) {\n    const { isBrowser, isMix } = api.getGlobalObjects();\n    if ((!isBrowser && !isMix) || !_global['customElements'] || !('customElements' in _global)) {\n        return;\n    }\n    // https://html.spec.whatwg.org/multipage/custom-elements.html#concept-custom-element-definition-lifecycle-callbacks\n    const callbacks = [\n        'connectedCallback',\n        'disconnectedCallback',\n        'adoptedCallback',\n        'attributeChangedCallback',\n        'formAssociatedCallback',\n        'formDisabledCallback',\n        'formResetCallback',\n        'formStateRestoreCallback',\n    ];\n    api.patchCallbacks(api, _global.customElements, 'customElements', 'define', callbacks);\n}\n\nfunction eventTargetPatch(_global, api) {\n    if (Zone[api.symbol('patchEventTarget')]) {\n        // EventTarget is already patched.\n        return;\n    }\n    const { eventNames, zoneSymbolEventNames, TRUE_STR, FALSE_STR, ZONE_SYMBOL_PREFIX } = api.getGlobalObjects();\n    //  predefine all __zone_symbol__ + eventName + true/false string\n    for (let i = 0; i < eventNames.length; i++) {\n        const eventName = eventNames[i];\n        const falseEventName = eventName + FALSE_STR;\n        const trueEventName = eventName + TRUE_STR;\n        const symbol = ZONE_SYMBOL_PREFIX + falseEventName;\n        const symbolCapture = ZONE_SYMBOL_PREFIX + trueEventName;\n        zoneSymbolEventNames[eventName] = {};\n        zoneSymbolEventNames[eventName][FALSE_STR] = symbol;\n        zoneSymbolEventNames[eventName][TRUE_STR] = symbolCapture;\n    }\n    const EVENT_TARGET = _global['EventTarget'];\n    if (!EVENT_TARGET || !EVENT_TARGET.prototype) {\n        return;\n    }\n    api.patchEventTarget(_global, api, [EVENT_TARGET && EVENT_TARGET.prototype]);\n    return true;\n}\nfunction patchEvent(global, api) {\n    api.patchEventPrototype(global, api);\n}\n\n/**\n * @fileoverview\n * @suppress {globalThis}\n */\nfunction filterProperties(target, onProperties, ignoreProperties) {\n    if (!ignoreProperties || ignoreProperties.length === 0) {\n        return onProperties;\n    }\n    const tip = ignoreProperties.filter((ip) => ip.target === target);\n    if (!tip || tip.length === 0) {\n        return onProperties;\n    }\n    const targetIgnoreProperties = tip[0].ignoreProperties;\n    return onProperties.filter((op) => targetIgnoreProperties.indexOf(op) === -1);\n}\nfunction patchFilteredProperties(target, onProperties, ignoreProperties, prototype) {\n    // check whether target is available, sometimes target will be undefined\n    // because different browser or some 3rd party plugin.\n    if (!target) {\n        return;\n    }\n    const filteredProperties = filterProperties(target, onProperties, ignoreProperties);\n    patchOnProperties(target, filteredProperties, prototype);\n}\n/**\n * Get all event name properties which the event name startsWith `on`\n * from the target object itself, inherited properties are not considered.\n */\nfunction getOnEventNames(target) {\n    return Object.getOwnPropertyNames(target)\n        .filter((name) => name.startsWith('on') && name.length > 2)\n        .map((name) => name.substring(2));\n}\nfunction propertyDescriptorPatch(api, _global) {\n    if (isNode && !isMix) {\n        return;\n    }\n    if (Zone[api.symbol('patchEvents')]) {\n        // events are already been patched by legacy patch.\n        return;\n    }\n    const ignoreProperties = _global['__Zone_ignore_on_properties'];\n    // for browsers that we can patch the descriptor:  Chrome & Firefox\n    let patchTargets = [];\n    if (isBrowser) {\n        const internalWindow = window;\n        patchTargets = patchTargets.concat([\n            'Document',\n            'SVGElement',\n            'Element',\n            'HTMLElement',\n            'HTMLBodyElement',\n            'HTMLMediaElement',\n            'HTMLFrameSetElement',\n            'HTMLFrameElement',\n            'HTMLIFrameElement',\n            'HTMLMarqueeElement',\n            'Worker',\n        ]);\n        const ignoreErrorProperties = isIE()\n            ? [{ target: internalWindow, ignoreProperties: ['error'] }]\n            : [];\n        // in IE/Edge, onProp not exist in window object, but in WindowPrototype\n        // so we need to pass WindowPrototype to check onProp exist or not\n        patchFilteredProperties(internalWindow, getOnEventNames(internalWindow), ignoreProperties ? ignoreProperties.concat(ignoreErrorProperties) : ignoreProperties, ObjectGetPrototypeOf(internalWindow));\n    }\n    patchTargets = patchTargets.concat([\n        'XMLHttpRequest',\n        'XMLHttpRequestEventTarget',\n        'IDBIndex',\n        'IDBRequest',\n        'IDBOpenDBRequest',\n        'IDBDatabase',\n        'IDBTransaction',\n        'IDBCursor',\n        'WebSocket',\n    ]);\n    for (let i = 0; i < patchTargets.length; i++) {\n        const target = _global[patchTargets[i]];\n        target &&\n            target.prototype &&\n            patchFilteredProperties(target.prototype, getOnEventNames(target.prototype), ignoreProperties);\n    }\n}\n\n/**\n * @fileoverview\n * @suppress {missingRequire}\n */\nfunction patchBrowser(Zone) {\n    Zone.__load_patch('legacy', (global) => {\n        const legacyPatch = global[Zone.__symbol__('legacyPatch')];\n        if (legacyPatch) {\n            legacyPatch();\n        }\n    });\n    Zone.__load_patch('timers', (global) => {\n        const set = 'set';\n        const clear = 'clear';\n        patchTimer(global, set, clear, 'Timeout');\n        patchTimer(global, set, clear, 'Interval');\n        patchTimer(global, set, clear, 'Immediate');\n    });\n    Zone.__load_patch('requestAnimationFrame', (global) => {\n        patchTimer(global, 'request', 'cancel', 'AnimationFrame');\n        patchTimer(global, 'mozRequest', 'mozCancel', 'AnimationFrame');\n        patchTimer(global, 'webkitRequest', 'webkitCancel', 'AnimationFrame');\n    });\n    Zone.__load_patch('blocking', (global, Zone) => {\n        const blockingMethods = ['alert', 'prompt', 'confirm'];\n        for (let i = 0; i < blockingMethods.length; i++) {\n            const name = blockingMethods[i];\n            patchMethod(global, name, (delegate, symbol, name) => {\n                return function (s, args) {\n                    return Zone.current.run(delegate, global, args, name);\n                };\n            });\n        }\n    });\n    Zone.__load_patch('EventTarget', (global, Zone, api) => {\n        patchEvent(global, api);\n        eventTargetPatch(global, api);\n        // patch XMLHttpRequestEventTarget's addEventListener/removeEventListener\n        const XMLHttpRequestEventTarget = global['XMLHttpRequestEventTarget'];\n        if (XMLHttpRequestEventTarget && XMLHttpRequestEventTarget.prototype) {\n            api.patchEventTarget(global, api, [XMLHttpRequestEventTarget.prototype]);\n        }\n    });\n    Zone.__load_patch('MutationObserver', (global, Zone, api) => {\n        patchClass('MutationObserver');\n        patchClass('WebKitMutationObserver');\n    });\n    Zone.__load_patch('IntersectionObserver', (global, Zone, api) => {\n        patchClass('IntersectionObserver');\n    });\n    Zone.__load_patch('FileReader', (global, Zone, api) => {\n        patchClass('FileReader');\n    });\n    Zone.__load_patch('on_property', (global, Zone, api) => {\n        propertyDescriptorPatch(api, global);\n    });\n    Zone.__load_patch('customElements', (global, Zone, api) => {\n        patchCustomElements(global, api);\n    });\n    Zone.__load_patch('XHR', (global, Zone) => {\n        // Treat XMLHttpRequest as a macrotask.\n        patchXHR(global);\n        const XHR_TASK = zoneSymbol('xhrTask');\n        const XHR_SYNC = zoneSymbol('xhrSync');\n        const XHR_LISTENER = zoneSymbol('xhrListener');\n        const XHR_SCHEDULED = zoneSymbol('xhrScheduled');\n        const XHR_URL = zoneSymbol('xhrURL');\n        const XHR_ERROR_BEFORE_SCHEDULED = zoneSymbol('xhrErrorBeforeScheduled');\n        function patchXHR(window) {\n            const XMLHttpRequest = window['XMLHttpRequest'];\n            if (!XMLHttpRequest) {\n                // XMLHttpRequest is not available in service worker\n                return;\n            }\n            const XMLHttpRequestPrototype = XMLHttpRequest.prototype;\n            function findPendingTask(target) {\n                return target[XHR_TASK];\n            }\n            let oriAddListener = XMLHttpRequestPrototype[ZONE_SYMBOL_ADD_EVENT_LISTENER];\n            let oriRemoveListener = XMLHttpRequestPrototype[ZONE_SYMBOL_REMOVE_EVENT_LISTENER];\n            if (!oriAddListener) {\n                const XMLHttpRequestEventTarget = window['XMLHttpRequestEventTarget'];\n                if (XMLHttpRequestEventTarget) {\n                    const XMLHttpRequestEventTargetPrototype = XMLHttpRequestEventTarget.prototype;\n                    oriAddListener = XMLHttpRequestEventTargetPrototype[ZONE_SYMBOL_ADD_EVENT_LISTENER];\n                    oriRemoveListener = XMLHttpRequestEventTargetPrototype[ZONE_SYMBOL_REMOVE_EVENT_LISTENER];\n                }\n            }\n            const READY_STATE_CHANGE = 'readystatechange';\n            const SCHEDULED = 'scheduled';\n            function scheduleTask(task) {\n                const data = task.data;\n                const target = data.target;\n                target[XHR_SCHEDULED] = false;\n                target[XHR_ERROR_BEFORE_SCHEDULED] = false;\n                // remove existing event listener\n                const listener = target[XHR_LISTENER];\n                if (!oriAddListener) {\n                    oriAddListener = target[ZONE_SYMBOL_ADD_EVENT_LISTENER];\n                    oriRemoveListener = target[ZONE_SYMBOL_REMOVE_EVENT_LISTENER];\n                }\n                if (listener) {\n                    oriRemoveListener.call(target, READY_STATE_CHANGE, listener);\n                }\n                const newListener = (target[XHR_LISTENER] = () => {\n                    if (target.readyState === target.DONE) {\n                        // sometimes on some browsers XMLHttpRequest will fire onreadystatechange with\n                        // readyState=4 multiple times, so we need to check task state here\n                        if (!data.aborted && target[XHR_SCHEDULED] && task.state === SCHEDULED) {\n                            // check whether the xhr has registered onload listener\n                            // if that is the case, the task should invoke after all\n                            // onload listeners finish.\n                            // Also if the request failed without response (status = 0), the load event handler\n                            // will not be triggered, in that case, we should also invoke the placeholder callback\n                            // to close the XMLHttpRequest::send macroTask.\n                            // https://github.com/angular/angular/issues/38795\n                            const loadTasks = target[Zone.__symbol__('loadfalse')];\n                            if (target.status !== 0 && loadTasks && loadTasks.length > 0) {\n                                const oriInvoke = task.invoke;\n                                task.invoke = function () {\n                                    // need to load the tasks again, because in other\n                                    // load listener, they may remove themselves\n                                    const loadTasks = target[Zone.__symbol__('loadfalse')];\n                                    for (let i = 0; i < loadTasks.length; i++) {\n                                        if (loadTasks[i] === task) {\n                                            loadTasks.splice(i, 1);\n                                        }\n                                    }\n                                    if (!data.aborted && task.state === SCHEDULED) {\n                                        oriInvoke.call(task);\n                                    }\n                                };\n                                loadTasks.push(task);\n                            }\n                            else {\n                                task.invoke();\n                            }\n                        }\n                        else if (!data.aborted && target[XHR_SCHEDULED] === false) {\n                            // error occurs when xhr.send()\n                            target[XHR_ERROR_BEFORE_SCHEDULED] = true;\n                        }\n                    }\n                });\n                oriAddListener.call(target, READY_STATE_CHANGE, newListener);\n                const storedTask = target[XHR_TASK];\n                if (!storedTask) {\n                    target[XHR_TASK] = task;\n                }\n                sendNative.apply(target, data.args);\n                target[XHR_SCHEDULED] = true;\n                return task;\n            }\n            function placeholderCallback() { }\n            function clearTask(task) {\n                const data = task.data;\n                // Note - ideally, we would call data.target.removeEventListener here, but it's too late\n                // to prevent it from firing. So instead, we store info for the event listener.\n                data.aborted = true;\n                return abortNative.apply(data.target, data.args);\n            }\n            const openNative = patchMethod(XMLHttpRequestPrototype, 'open', () => function (self, args) {\n                self[XHR_SYNC] = args[2] == false;\n                self[XHR_URL] = args[1];\n                return openNative.apply(self, args);\n            });\n            const XMLHTTPREQUEST_SOURCE = 'XMLHttpRequest.send';\n            const fetchTaskAborting = zoneSymbol('fetchTaskAborting');\n            const fetchTaskScheduling = zoneSymbol('fetchTaskScheduling');\n            const sendNative = patchMethod(XMLHttpRequestPrototype, 'send', () => function (self, args) {\n                if (Zone.current[fetchTaskScheduling] === true) {\n                    // a fetch is scheduling, so we are using xhr to polyfill fetch\n                    // and because we already schedule macroTask for fetch, we should\n                    // not schedule a macroTask for xhr again\n                    return sendNative.apply(self, args);\n                }\n                if (self[XHR_SYNC]) {\n                    // if the XHR is sync there is no task to schedule, just execute the code.\n                    return sendNative.apply(self, args);\n                }\n                else {\n                    const options = {\n                        target: self,\n                        url: self[XHR_URL],\n                        isPeriodic: false,\n                        args: args,\n                        aborted: false,\n                    };\n                    const task = scheduleMacroTaskWithCurrentZone(XMLHTTPREQUEST_SOURCE, placeholderCallback, options, scheduleTask, clearTask);\n                    if (self &&\n                        self[XHR_ERROR_BEFORE_SCHEDULED] === true &&\n                        !options.aborted &&\n                        task.state === SCHEDULED) {\n                        // xhr request throw error when send\n                        // we should invoke task instead of leaving a scheduled\n                        // pending macroTask\n                        task.invoke();\n                    }\n                }\n            });\n            const abortNative = patchMethod(XMLHttpRequestPrototype, 'abort', () => function (self, args) {\n                const task = findPendingTask(self);\n                if (task && typeof task.type == 'string') {\n                    // If the XHR has already completed, do nothing.\n                    // If the XHR has already been aborted, do nothing.\n                    // Fix #569, call abort multiple times before done will cause\n                    // macroTask task count be negative number\n                    if (task.cancelFn == null || (task.data && task.data.aborted)) {\n                        return;\n                    }\n                    task.zone.cancelTask(task);\n                }\n                else if (Zone.current[fetchTaskAborting] === true) {\n                    // the abort is called from fetch polyfill, we need to call native abort of XHR.\n                    return abortNative.apply(self, args);\n                }\n                // Otherwise, we are trying to abort an XHR which has not yet been sent, so there is no\n                // task\n                // to cancel. Do nothing.\n            });\n        }\n    });\n    Zone.__load_patch('geolocation', (global) => {\n        /// GEO_LOCATION\n        if (global['navigator'] && global['navigator'].geolocation) {\n            patchPrototype(global['navigator'].geolocation, ['getCurrentPosition', 'watchPosition']);\n        }\n    });\n    Zone.__load_patch('PromiseRejectionEvent', (global, Zone) => {\n        // handle unhandled promise rejection\n        function findPromiseRejectionHandler(evtName) {\n            return function (e) {\n                const eventTasks = findEventTasks(global, evtName);\n                eventTasks.forEach((eventTask) => {\n                    // windows has added unhandledrejection event listener\n                    // trigger the event listener\n                    const PromiseRejectionEvent = global['PromiseRejectionEvent'];\n                    if (PromiseRejectionEvent) {\n                        const evt = new PromiseRejectionEvent(evtName, {\n                            promise: e.promise,\n                            reason: e.rejection,\n                        });\n                        eventTask.invoke(evt);\n                    }\n                });\n            };\n        }\n        if (global['PromiseRejectionEvent']) {\n            Zone[zoneSymbol('unhandledPromiseRejectionHandler')] =\n                findPromiseRejectionHandler('unhandledrejection');\n            Zone[zoneSymbol('rejectionHandledHandler')] =\n                findPromiseRejectionHandler('rejectionhandled');\n        }\n    });\n    Zone.__load_patch('queueMicrotask', (global, Zone, api) => {\n        patchQueueMicrotask(global, api);\n    });\n}\n\nfunction patchPromise(Zone) {\n    Zone.__load_patch('ZoneAwarePromise', (global, Zone, api) => {\n        const ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n        const ObjectDefineProperty = Object.defineProperty;\n        function readableObjectToString(obj) {\n            if (obj && obj.toString === Object.prototype.toString) {\n                const className = obj.constructor && obj.constructor.name;\n                return (className ? className : '') + ': ' + JSON.stringify(obj);\n            }\n            return obj ? obj.toString() : Object.prototype.toString.call(obj);\n        }\n        const __symbol__ = api.symbol;\n        const _uncaughtPromiseErrors = [];\n        const isDisableWrappingUncaughtPromiseRejection = global[__symbol__('DISABLE_WRAPPING_UNCAUGHT_PROMISE_REJECTION')] !== false;\n        const symbolPromise = __symbol__('Promise');\n        const symbolThen = __symbol__('then');\n        const creationTrace = '__creationTrace__';\n        api.onUnhandledError = (e) => {\n            if (api.showUncaughtError()) {\n                const rejection = e && e.rejection;\n                if (rejection) {\n                    console.error('Unhandled Promise rejection:', rejection instanceof Error ? rejection.message : rejection, '; Zone:', e.zone.name, '; Task:', e.task && e.task.source, '; Value:', rejection, rejection instanceof Error ? rejection.stack : undefined);\n                }\n                else {\n                    console.error(e);\n                }\n            }\n        };\n        api.microtaskDrainDone = () => {\n            while (_uncaughtPromiseErrors.length) {\n                const uncaughtPromiseError = _uncaughtPromiseErrors.shift();\n                try {\n                    uncaughtPromiseError.zone.runGuarded(() => {\n                        if (uncaughtPromiseError.throwOriginal) {\n                            throw uncaughtPromiseError.rejection;\n                        }\n                        throw uncaughtPromiseError;\n                    });\n                }\n                catch (error) {\n                    handleUnhandledRejection(error);\n                }\n            }\n        };\n        const UNHANDLED_PROMISE_REJECTION_HANDLER_SYMBOL = __symbol__('unhandledPromiseRejectionHandler');\n        function handleUnhandledRejection(e) {\n            api.onUnhandledError(e);\n            try {\n                const handler = Zone[UNHANDLED_PROMISE_REJECTION_HANDLER_SYMBOL];\n                if (typeof handler === 'function') {\n                    handler.call(this, e);\n                }\n            }\n            catch (err) { }\n        }\n        function isThenable(value) {\n            return value && value.then;\n        }\n        function forwardResolution(value) {\n            return value;\n        }\n        function forwardRejection(rejection) {\n            return ZoneAwarePromise.reject(rejection);\n        }\n        const symbolState = __symbol__('state');\n        const symbolValue = __symbol__('value');\n        const symbolFinally = __symbol__('finally');\n        const symbolParentPromiseValue = __symbol__('parentPromiseValue');\n        const symbolParentPromiseState = __symbol__('parentPromiseState');\n        const source = 'Promise.then';\n        const UNRESOLVED = null;\n        const RESOLVED = true;\n        const REJECTED = false;\n        const REJECTED_NO_CATCH = 0;\n        function makeResolver(promise, state) {\n            return (v) => {\n                try {\n                    resolvePromise(promise, state, v);\n                }\n                catch (err) {\n                    resolvePromise(promise, false, err);\n                }\n                // Do not return value or you will break the Promise spec.\n            };\n        }\n        const once = function () {\n            let wasCalled = false;\n            return function wrapper(wrappedFunction) {\n                return function () {\n                    if (wasCalled) {\n                        return;\n                    }\n                    wasCalled = true;\n                    wrappedFunction.apply(null, arguments);\n                };\n            };\n        };\n        const TYPE_ERROR = 'Promise resolved with itself';\n        const CURRENT_TASK_TRACE_SYMBOL = __symbol__('currentTaskTrace');\n        // Promise Resolution\n        function resolvePromise(promise, state, value) {\n            const onceWrapper = once();\n            if (promise === value) {\n                throw new TypeError(TYPE_ERROR);\n            }\n            if (promise[symbolState] === UNRESOLVED) {\n                // should only get value.then once based on promise spec.\n                let then = null;\n                try {\n                    if (typeof value === 'object' || typeof value === 'function') {\n                        then = value && value.then;\n                    }\n                }\n                catch (err) {\n                    onceWrapper(() => {\n                        resolvePromise(promise, false, err);\n                    })();\n                    return promise;\n                }\n                // if (value instanceof ZoneAwarePromise) {\n                if (state !== REJECTED &&\n                    value instanceof ZoneAwarePromise &&\n                    value.hasOwnProperty(symbolState) &&\n                    value.hasOwnProperty(symbolValue) &&\n                    value[symbolState] !== UNRESOLVED) {\n                    clearRejectedNoCatch(value);\n                    resolvePromise(promise, value[symbolState], value[symbolValue]);\n                }\n                else if (state !== REJECTED && typeof then === 'function') {\n                    try {\n                        then.call(value, onceWrapper(makeResolver(promise, state)), onceWrapper(makeResolver(promise, false)));\n                    }\n                    catch (err) {\n                        onceWrapper(() => {\n                            resolvePromise(promise, false, err);\n                        })();\n                    }\n                }\n                else {\n                    promise[symbolState] = state;\n                    const queue = promise[symbolValue];\n                    promise[symbolValue] = value;\n                    if (promise[symbolFinally] === symbolFinally) {\n                        // the promise is generated by Promise.prototype.finally\n                        if (state === RESOLVED) {\n                            // the state is resolved, should ignore the value\n                            // and use parent promise value\n                            promise[symbolState] = promise[symbolParentPromiseState];\n                            promise[symbolValue] = promise[symbolParentPromiseValue];\n                        }\n                    }\n                    // record task information in value when error occurs, so we can\n                    // do some additional work such as render longStackTrace\n                    if (state === REJECTED && value instanceof Error) {\n                        // check if longStackTraceZone is here\n                        const trace = Zone.currentTask &&\n                            Zone.currentTask.data &&\n                            Zone.currentTask.data[creationTrace];\n                        if (trace) {\n                            // only keep the long stack trace into error when in longStackTraceZone\n                            ObjectDefineProperty(value, CURRENT_TASK_TRACE_SYMBOL, {\n                                configurable: true,\n                                enumerable: false,\n                                writable: true,\n                                value: trace,\n                            });\n                        }\n                    }\n                    for (let i = 0; i < queue.length;) {\n                        scheduleResolveOrReject(promise, queue[i++], queue[i++], queue[i++], queue[i++]);\n                    }\n                    if (queue.length == 0 && state == REJECTED) {\n                        promise[symbolState] = REJECTED_NO_CATCH;\n                        let uncaughtPromiseError = value;\n                        try {\n                            // Here we throws a new Error to print more readable error log\n                            // and if the value is not an error, zone.js builds an `Error`\n                            // Object here to attach the stack information.\n                            throw new Error('Uncaught (in promise): ' +\n                                readableObjectToString(value) +\n                                (value && value.stack ? '\\n' + value.stack : ''));\n                        }\n                        catch (err) {\n                            uncaughtPromiseError = err;\n                        }\n                        if (isDisableWrappingUncaughtPromiseRejection) {\n                            // If disable wrapping uncaught promise reject\n                            // use the value instead of wrapping it.\n                            uncaughtPromiseError.throwOriginal = true;\n                        }\n                        uncaughtPromiseError.rejection = value;\n                        uncaughtPromiseError.promise = promise;\n                        uncaughtPromiseError.zone = Zone.current;\n                        uncaughtPromiseError.task = Zone.currentTask;\n                        _uncaughtPromiseErrors.push(uncaughtPromiseError);\n                        api.scheduleMicroTask(); // to make sure that it is running\n                    }\n                }\n            }\n            // Resolving an already resolved promise is a noop.\n            return promise;\n        }\n        const REJECTION_HANDLED_HANDLER = __symbol__('rejectionHandledHandler');\n        function clearRejectedNoCatch(promise) {\n            if (promise[symbolState] === REJECTED_NO_CATCH) {\n                // if the promise is rejected no catch status\n                // and queue.length > 0, means there is a error handler\n                // here to handle the rejected promise, we should trigger\n                // windows.rejectionhandled eventHandler or nodejs rejectionHandled\n                // eventHandler\n                try {\n                    const handler = Zone[REJECTION_HANDLED_HANDLER];\n                    if (handler && typeof handler === 'function') {\n                        handler.call(this, { rejection: promise[symbolValue], promise: promise });\n                    }\n                }\n                catch (err) { }\n                promise[symbolState] = REJECTED;\n                for (let i = 0; i < _uncaughtPromiseErrors.length; i++) {\n                    if (promise === _uncaughtPromiseErrors[i].promise) {\n                        _uncaughtPromiseErrors.splice(i, 1);\n                    }\n                }\n            }\n        }\n        function scheduleResolveOrReject(promise, zone, chainPromise, onFulfilled, onRejected) {\n            clearRejectedNoCatch(promise);\n            const promiseState = promise[symbolState];\n            const delegate = promiseState\n                ? typeof onFulfilled === 'function'\n                    ? onFulfilled\n                    : forwardResolution\n                : typeof onRejected === 'function'\n                    ? onRejected\n                    : forwardRejection;\n            zone.scheduleMicroTask(source, () => {\n                try {\n                    const parentPromiseValue = promise[symbolValue];\n                    const isFinallyPromise = !!chainPromise && symbolFinally === chainPromise[symbolFinally];\n                    if (isFinallyPromise) {\n                        // if the promise is generated from finally call, keep parent promise's state and value\n                        chainPromise[symbolParentPromiseValue] = parentPromiseValue;\n                        chainPromise[symbolParentPromiseState] = promiseState;\n                    }\n                    // should not pass value to finally callback\n                    const value = zone.run(delegate, undefined, isFinallyPromise && delegate !== forwardRejection && delegate !== forwardResolution\n                        ? []\n                        : [parentPromiseValue]);\n                    resolvePromise(chainPromise, true, value);\n                }\n                catch (error) {\n                    // if error occurs, should always return this error\n                    resolvePromise(chainPromise, false, error);\n                }\n            }, chainPromise);\n        }\n        const ZONE_AWARE_PROMISE_TO_STRING = 'function ZoneAwarePromise() { [native code] }';\n        const noop = function () { };\n        const AggregateError = global.AggregateError;\n        class ZoneAwarePromise {\n            static toString() {\n                return ZONE_AWARE_PROMISE_TO_STRING;\n            }\n            static resolve(value) {\n                if (value instanceof ZoneAwarePromise) {\n                    return value;\n                }\n                return resolvePromise(new this(null), RESOLVED, value);\n            }\n            static reject(error) {\n                return resolvePromise(new this(null), REJECTED, error);\n            }\n            static withResolvers() {\n                const result = {};\n                result.promise = new ZoneAwarePromise((res, rej) => {\n                    result.resolve = res;\n                    result.reject = rej;\n                });\n                return result;\n            }\n            static any(values) {\n                if (!values || typeof values[Symbol.iterator] !== 'function') {\n                    return Promise.reject(new AggregateError([], 'All promises were rejected'));\n                }\n                const promises = [];\n                let count = 0;\n                try {\n                    for (let v of values) {\n                        count++;\n                        promises.push(ZoneAwarePromise.resolve(v));\n                    }\n                }\n                catch (err) {\n                    return Promise.reject(new AggregateError([], 'All promises were rejected'));\n                }\n                if (count === 0) {\n                    return Promise.reject(new AggregateError([], 'All promises were rejected'));\n                }\n                let finished = false;\n                const errors = [];\n                return new ZoneAwarePromise((resolve, reject) => {\n                    for (let i = 0; i < promises.length; i++) {\n                        promises[i].then((v) => {\n                            if (finished) {\n                                return;\n                            }\n                            finished = true;\n                            resolve(v);\n                        }, (err) => {\n                            errors.push(err);\n                            count--;\n                            if (count === 0) {\n                                finished = true;\n                                reject(new AggregateError(errors, 'All promises were rejected'));\n                            }\n                        });\n                    }\n                });\n            }\n            static race(values) {\n                let resolve;\n                let reject;\n                let promise = new this((res, rej) => {\n                    resolve = res;\n                    reject = rej;\n                });\n                function onResolve(value) {\n                    resolve(value);\n                }\n                function onReject(error) {\n                    reject(error);\n                }\n                for (let value of values) {\n                    if (!isThenable(value)) {\n                        value = this.resolve(value);\n                    }\n                    value.then(onResolve, onReject);\n                }\n                return promise;\n            }\n            static all(values) {\n                return ZoneAwarePromise.allWithCallback(values);\n            }\n            static allSettled(values) {\n                const P = this && this.prototype instanceof ZoneAwarePromise ? this : ZoneAwarePromise;\n                return P.allWithCallback(values, {\n                    thenCallback: (value) => ({ status: 'fulfilled', value }),\n                    errorCallback: (err) => ({ status: 'rejected', reason: err }),\n                });\n            }\n            static allWithCallback(values, callback) {\n                let resolve;\n                let reject;\n                let promise = new this((res, rej) => {\n                    resolve = res;\n                    reject = rej;\n                });\n                // Start at 2 to prevent prematurely resolving if .then is called immediately.\n                let unresolvedCount = 2;\n                let valueIndex = 0;\n                const resolvedValues = [];\n                for (let value of values) {\n                    if (!isThenable(value)) {\n                        value = this.resolve(value);\n                    }\n                    const curValueIndex = valueIndex;\n                    try {\n                        value.then((value) => {\n                            resolvedValues[curValueIndex] = callback ? callback.thenCallback(value) : value;\n                            unresolvedCount--;\n                            if (unresolvedCount === 0) {\n                                resolve(resolvedValues);\n                            }\n                        }, (err) => {\n                            if (!callback) {\n                                reject(err);\n                            }\n                            else {\n                                resolvedValues[curValueIndex] = callback.errorCallback(err);\n                                unresolvedCount--;\n                                if (unresolvedCount === 0) {\n                                    resolve(resolvedValues);\n                                }\n                            }\n                        });\n                    }\n                    catch (thenErr) {\n                        reject(thenErr);\n                    }\n                    unresolvedCount++;\n                    valueIndex++;\n                }\n                // Make the unresolvedCount zero-based again.\n                unresolvedCount -= 2;\n                if (unresolvedCount === 0) {\n                    resolve(resolvedValues);\n                }\n                return promise;\n            }\n            constructor(executor) {\n                const promise = this;\n                if (!(promise instanceof ZoneAwarePromise)) {\n                    throw new Error('Must be an instanceof Promise.');\n                }\n                promise[symbolState] = UNRESOLVED;\n                promise[symbolValue] = []; // queue;\n                try {\n                    const onceWrapper = once();\n                    executor &&\n                        executor(onceWrapper(makeResolver(promise, RESOLVED)), onceWrapper(makeResolver(promise, REJECTED)));\n                }\n                catch (error) {\n                    resolvePromise(promise, false, error);\n                }\n            }\n            get [Symbol.toStringTag]() {\n                return 'Promise';\n            }\n            get [Symbol.species]() {\n                return ZoneAwarePromise;\n            }\n            then(onFulfilled, onRejected) {\n                // We must read `Symbol.species` safely because `this` may be anything. For instance, `this`\n                // may be an object without a prototype (created through `Object.create(null)`); thus\n                // `this.constructor` will be undefined. One of the use cases is SystemJS creating\n                // prototype-less objects (modules) via `Object.create(null)`. The SystemJS creates an empty\n                // object and copies promise properties into that object (within the `getOrCreateLoad`\n                // function). The zone.js then checks if the resolved value has the `then` method and\n                // invokes it with the `value` context. Otherwise, this will throw an error: `TypeError:\n                // Cannot read properties of undefined (reading 'Symbol(Symbol.species)')`.\n                let C = this.constructor?.[Symbol.species];\n                if (!C || typeof C !== 'function') {\n                    C = this.constructor || ZoneAwarePromise;\n                }\n                const chainPromise = new C(noop);\n                const zone = Zone.current;\n                if (this[symbolState] == UNRESOLVED) {\n                    this[symbolValue].push(zone, chainPromise, onFulfilled, onRejected);\n                }\n                else {\n                    scheduleResolveOrReject(this, zone, chainPromise, onFulfilled, onRejected);\n                }\n                return chainPromise;\n            }\n            catch(onRejected) {\n                return this.then(null, onRejected);\n            }\n            finally(onFinally) {\n                // See comment on the call to `then` about why thee `Symbol.species` is safely accessed.\n                let C = this.constructor?.[Symbol.species];\n                if (!C || typeof C !== 'function') {\n                    C = ZoneAwarePromise;\n                }\n                const chainPromise = new C(noop);\n                chainPromise[symbolFinally] = symbolFinally;\n                const zone = Zone.current;\n                if (this[symbolState] == UNRESOLVED) {\n                    this[symbolValue].push(zone, chainPromise, onFinally, onFinally);\n                }\n                else {\n                    scheduleResolveOrReject(this, zone, chainPromise, onFinally, onFinally);\n                }\n                return chainPromise;\n            }\n        }\n        // Protect against aggressive optimizers dropping seemingly unused properties.\n        // E.g. Closure Compiler in advanced mode.\n        ZoneAwarePromise['resolve'] = ZoneAwarePromise.resolve;\n        ZoneAwarePromise['reject'] = ZoneAwarePromise.reject;\n        ZoneAwarePromise['race'] = ZoneAwarePromise.race;\n        ZoneAwarePromise['all'] = ZoneAwarePromise.all;\n        const NativePromise = (global[symbolPromise] = global['Promise']);\n        global['Promise'] = ZoneAwarePromise;\n        const symbolThenPatched = __symbol__('thenPatched');\n        function patchThen(Ctor) {\n            const proto = Ctor.prototype;\n            const prop = ObjectGetOwnPropertyDescriptor(proto, 'then');\n            if (prop && (prop.writable === false || !prop.configurable)) {\n                // check Ctor.prototype.then propertyDescriptor is writable or not\n                // in meteor env, writable is false, we should ignore such case\n                return;\n            }\n            const originalThen = proto.then;\n            // Keep a reference to the original method.\n            proto[symbolThen] = originalThen;\n            Ctor.prototype.then = function (onResolve, onReject) {\n                const wrapped = new ZoneAwarePromise((resolve, reject) => {\n                    originalThen.call(this, resolve, reject);\n                });\n                return wrapped.then(onResolve, onReject);\n            };\n            Ctor[symbolThenPatched] = true;\n        }\n        api.patchThen = patchThen;\n        function zoneify(fn) {\n            return function (self, args) {\n                let resultPromise = fn.apply(self, args);\n                if (resultPromise instanceof ZoneAwarePromise) {\n                    return resultPromise;\n                }\n                let ctor = resultPromise.constructor;\n                if (!ctor[symbolThenPatched]) {\n                    patchThen(ctor);\n                }\n                return resultPromise;\n            };\n        }\n        if (NativePromise) {\n            patchThen(NativePromise);\n            patchMethod(global, 'fetch', (delegate) => zoneify(delegate));\n        }\n        // This is not part of public API, but it is useful for tests, so we expose it.\n        Promise[Zone.__symbol__('uncaughtPromiseErrors')] = _uncaughtPromiseErrors;\n        return ZoneAwarePromise;\n    });\n}\n\nfunction patchToString(Zone) {\n    // override Function.prototype.toString to make zone.js patched function\n    // look like native function\n    Zone.__load_patch('toString', (global) => {\n        // patch Func.prototype.toString to let them look like native\n        const originalFunctionToString = Function.prototype.toString;\n        const ORIGINAL_DELEGATE_SYMBOL = zoneSymbol('OriginalDelegate');\n        const PROMISE_SYMBOL = zoneSymbol('Promise');\n        const ERROR_SYMBOL = zoneSymbol('Error');\n        const newFunctionToString = function toString() {\n            if (typeof this === 'function') {\n                const originalDelegate = this[ORIGINAL_DELEGATE_SYMBOL];\n                if (originalDelegate) {\n                    if (typeof originalDelegate === 'function') {\n                        return originalFunctionToString.call(originalDelegate);\n                    }\n                    else {\n                        return Object.prototype.toString.call(originalDelegate);\n                    }\n                }\n                if (this === Promise) {\n                    const nativePromise = global[PROMISE_SYMBOL];\n                    if (nativePromise) {\n                        return originalFunctionToString.call(nativePromise);\n                    }\n                }\n                if (this === Error) {\n                    const nativeError = global[ERROR_SYMBOL];\n                    if (nativeError) {\n                        return originalFunctionToString.call(nativeError);\n                    }\n                }\n            }\n            return originalFunctionToString.call(this);\n        };\n        newFunctionToString[ORIGINAL_DELEGATE_SYMBOL] = originalFunctionToString;\n        Function.prototype.toString = newFunctionToString;\n        // patch Object.prototype.toString to let them look like native\n        const originalObjectToString = Object.prototype.toString;\n        const PROMISE_OBJECT_TO_STRING = '[object Promise]';\n        Object.prototype.toString = function () {\n            if (typeof Promise === 'function' && this instanceof Promise) {\n                return PROMISE_OBJECT_TO_STRING;\n            }\n            return originalObjectToString.call(this);\n        };\n    });\n}\n\nfunction patchCallbacks(api, target, targetName, method, callbacks) {\n    const symbol = Zone.__symbol__(method);\n    if (target[symbol]) {\n        return;\n    }\n    const nativeDelegate = (target[symbol] = target[method]);\n    target[method] = function (name, opts, options) {\n        if (opts && opts.prototype) {\n            callbacks.forEach(function (callback) {\n                const source = `${targetName}.${method}::` + callback;\n                const prototype = opts.prototype;\n                // Note: the `patchCallbacks` is used for patching the `document.registerElement` and\n                // `customElements.define`. We explicitly wrap the patching code into try-catch since\n                // callbacks may be already patched by other web components frameworks (e.g. LWC), and they\n                // make those properties non-writable. This means that patching callback will throw an error\n                // `cannot assign to read-only property`. See this code as an example:\n                // https://github.com/salesforce/lwc/blob/master/packages/@lwc/engine-core/src/framework/base-bridge-element.ts#L180-L186\n                // We don't want to stop the application rendering if we couldn't patch some\n                // callback, e.g. `attributeChangedCallback`.\n                try {\n                    if (prototype.hasOwnProperty(callback)) {\n                        const descriptor = api.ObjectGetOwnPropertyDescriptor(prototype, callback);\n                        if (descriptor && descriptor.value) {\n                            descriptor.value = api.wrapWithCurrentZone(descriptor.value, source);\n                            api._redefineProperty(opts.prototype, callback, descriptor);\n                        }\n                        else if (prototype[callback]) {\n                            prototype[callback] = api.wrapWithCurrentZone(prototype[callback], source);\n                        }\n                    }\n                    else if (prototype[callback]) {\n                        prototype[callback] = api.wrapWithCurrentZone(prototype[callback], source);\n                    }\n                }\n                catch {\n                    // Note: we leave the catch block empty since there's no way to handle the error related\n                    // to non-writable property.\n                }\n            });\n        }\n        return nativeDelegate.call(target, name, opts, options);\n    };\n    api.attachOriginToPatched(target[method], nativeDelegate);\n}\n\nfunction patchUtil(Zone) {\n    Zone.__load_patch('util', (global, Zone, api) => {\n        // Collect native event names by looking at properties\n        // on the global namespace, e.g. 'onclick'.\n        const eventNames = getOnEventNames(global);\n        api.patchOnProperties = patchOnProperties;\n        api.patchMethod = patchMethod;\n        api.bindArguments = bindArguments;\n        api.patchMacroTask = patchMacroTask;\n        // In earlier version of zone.js (<0.9.0), we use env name `__zone_symbol__BLACK_LISTED_EVENTS`\n        // to define which events will not be patched by `Zone.js`. In newer version (>=0.9.0), we\n        // change the env name to `__zone_symbol__UNPATCHED_EVENTS` to keep the name consistent with\n        // angular repo. The  `__zone_symbol__BLACK_LISTED_EVENTS` is deprecated, but it is still be\n        // supported for backwards compatibility.\n        const SYMBOL_BLACK_LISTED_EVENTS = Zone.__symbol__('BLACK_LISTED_EVENTS');\n        const SYMBOL_UNPATCHED_EVENTS = Zone.__symbol__('UNPATCHED_EVENTS');\n        if (global[SYMBOL_UNPATCHED_EVENTS]) {\n            global[SYMBOL_BLACK_LISTED_EVENTS] = global[SYMBOL_UNPATCHED_EVENTS];\n        }\n        if (global[SYMBOL_BLACK_LISTED_EVENTS]) {\n            Zone[SYMBOL_BLACK_LISTED_EVENTS] = Zone[SYMBOL_UNPATCHED_EVENTS] =\n                global[SYMBOL_BLACK_LISTED_EVENTS];\n        }\n        api.patchEventPrototype = patchEventPrototype;\n        api.patchEventTarget = patchEventTarget;\n        api.isIEOrEdge = isIEOrEdge;\n        api.ObjectDefineProperty = ObjectDefineProperty;\n        api.ObjectGetOwnPropertyDescriptor = ObjectGetOwnPropertyDescriptor;\n        api.ObjectCreate = ObjectCreate;\n        api.ArraySlice = ArraySlice;\n        api.patchClass = patchClass;\n        api.wrapWithCurrentZone = wrapWithCurrentZone;\n        api.filterProperties = filterProperties;\n        api.attachOriginToPatched = attachOriginToPatched;\n        api._redefineProperty = Object.defineProperty;\n        api.patchCallbacks = patchCallbacks;\n        api.getGlobalObjects = () => ({\n            globalSources,\n            zoneSymbolEventNames,\n            eventNames,\n            isBrowser,\n            isMix,\n            isNode,\n            TRUE_STR,\n            FALSE_STR,\n            ZONE_SYMBOL_PREFIX,\n            ADD_EVENT_LISTENER_STR,\n            REMOVE_EVENT_LISTENER_STR,\n        });\n    });\n}\n\nfunction patchCommon(Zone) {\n    patchPromise(Zone);\n    patchToString(Zone);\n    patchUtil(Zone);\n}\n\nconst Zone$1 = loadZone();\npatchCommon(Zone$1);\npatchBrowser(Zone$1);\n","/*!\n * AmplifyJS 1.1.0 - Core, Store, Request\n * \n * Copyright 2011 appendTo LLC. (http://appendto.com/team)\n * Dual licensed under the MIT or GPL licenses.\n * http://appendto.com/open-source-licenses\n * \n * http://amplifyjs.com\n */\n/*!\n * Amplify Core 1.1.0\n * \n * Copyright 2011 appendTo LLC. (http://appendto.com/team)\n * Dual licensed under the MIT or GPL licenses.\n * http://appendto.com/open-source-licenses\n * \n * http://amplifyjs.com\n */\n(function( global, undefined ) {\n\nvar slice = [].slice,\n\tsubscriptions = {};\n\nvar amplify = global.amplify = {\n\tpublish: function( topic ) {\n\t\tvar args = slice.call( arguments, 1 ),\n\t\t\ttopicSubscriptions,\n\t\t\tsubscription,\n\t\t\tlength,\n\t\t\ti = 0,\n\t\t\tret;\n\n\t\tif ( !subscriptions[ topic ] ) {\n\t\t\treturn true;\n\t\t}\n\n\t\ttopicSubscriptions = subscriptions[ topic ].slice();\n\t\tfor ( length = topicSubscriptions.length; i < length; i++ ) {\n\t\t\tsubscription = topicSubscriptions[ i ];\n\t\t\tret = subscription.callback.apply( subscription.context, args );\n\t\t\tif ( ret === false ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\treturn ret !== false;\n\t},\n\n\tsubscribe: function( topic, context, callback, priority ) {\n\t\tif ( arguments.length === 3 && typeof callback === \"number\" ) {\n\t\t\tpriority = callback;\n\t\t\tcallback = context;\n\t\t\tcontext = null;\n\t\t}\n\t\tif ( arguments.length === 2 ) {\n\t\t\tcallback = context;\n\t\t\tcontext = null;\n\t\t}\n\t\tpriority = priority || 10;\n\n\t\tvar topicIndex = 0,\n\t\t\ttopics = topic.split( /\\s/ ),\n\t\t\ttopicLength = topics.length,\n\t\t\tadded;\n\t\tfor ( ; topicIndex < topicLength; topicIndex++ ) {\n\t\t\ttopic = topics[ topicIndex ];\n\t\t\tadded = false;\n\t\t\tif ( !subscriptions[ topic ] ) {\n\t\t\t\tsubscriptions[ topic ] = [];\n\t\t\t}\n\t\n\t\t\tvar i = subscriptions[ topic ].length - 1,\n\t\t\t\tsubscriptionInfo = {\n\t\t\t\t\tcallback: callback,\n\t\t\t\t\tcontext: context,\n\t\t\t\t\tpriority: priority\n\t\t\t\t};\n\t\n\t\t\tfor ( ; i >= 0; i-- ) {\n\t\t\t\tif ( subscriptions[ topic ][ i ].priority <= priority ) {\n\t\t\t\t\tsubscriptions[ topic ].splice( i + 1, 0, subscriptionInfo );\n\t\t\t\t\tadded = true;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif ( !added ) {\n\t\t\t\tsubscriptions[ topic ].unshift( subscriptionInfo );\n\t\t\t}\n\t\t}\n\n\t\treturn callback;\n\t},\n\n\tunsubscribe: function( topic, callback ) {\n\t\tif ( !subscriptions[ topic ] ) {\n\t\t\treturn;\n\t\t}\n\n\t\tvar length = subscriptions[ topic ].length,\n\t\t\ti = 0;\n\n\t\tfor ( ; i < length; i++ ) {\n\t\t\tif ( subscriptions[ topic ][ i ].callback === callback ) {\n\t\t\t\tsubscriptions[ topic ].splice( i, 1 );\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n};\n\n}( window ) );\n/*!\n * Amplify Store - Persistent Client-Side Storage 1.1.0\n * \n * Copyright 2011 appendTo LLC. (http://appendto.com/team)\n * Dual licensed under the MIT or GPL licenses.\n * http://appendto.com/open-source-licenses\n * \n * http://amplifyjs.com\n */\n(function( amplify, undefined ) {\n\nvar store = amplify.store = function( key, value, options, type ) {\n\tvar type = store.type;\n\tif ( options && options.type && options.type in store.types ) {\n\t\ttype = options.type;\n\t}\n\treturn store.types[ type ]( key, value, options || {} );\n};\n\nstore.types = {};\nstore.type = null;\nstore.addType = function( type, storage ) {\n\tif ( !store.type ) {\n\t\tstore.type = type;\n\t}\n\n\tstore.types[ type ] = storage;\n\tstore[ type ] = function( key, value, options ) {\n\t\toptions = options || {};\n\t\toptions.type = type;\n\t\treturn store( key, value, options );\n\t};\n}\nstore.error = function() {\n\treturn \"amplify.store quota exceeded\"; \n};\n\nvar rprefix = /^__amplify__/;\nfunction createFromStorageInterface( storageType, storage ) {\n\tstore.addType( storageType, function( key, value, options ) {\n\t\tvar storedValue, parsed, i, remove,\n\t\t\tret = value,\n\t\t\tnow = (new Date()).getTime();\n\n\t\tif ( !key ) {\n\t\t\tret = {};\n\t\t\tremove = [];\n\t\t\ti = 0;\n\t\t\ttry {\n\t\t\t\t// accessing the length property works around a localStorage bug\n\t\t\t\t// in Firefox 4.0 where the keys don't update cross-page\n\t\t\t\t// we assign to key just to avoid Closure Compiler from removing\n\t\t\t\t// the access as \"useless code\"\n\t\t\t\t// https://bugzilla.mozilla.org/show_bug.cgi?id=662511\n\t\t\t\tkey = storage.length;\n\n\t\t\t\twhile ( key = storage.key( i++ ) ) {\n\t\t\t\t\tif ( rprefix.test( key ) ) {\n\t\t\t\t\t\tparsed = JSON.parse( storage.getItem( key ) );\n\t\t\t\t\t\tif ( parsed.expires && parsed.expires <= now ) {\n\t\t\t\t\t\t\tremove.push( key );\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tret[ key.replace( rprefix, \"\" ) ] = parsed.data;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\twhile ( key = remove.pop() ) {\n\t\t\t\t\tstorage.removeItem( key );\n\t\t\t\t}\n\t\t\t} catch ( error ) {}\n\t\t\treturn ret;\n\t\t}\n\n\t\t// protect against name collisions with direct storage\n\t\tkey = \"__amplify__\" + key;\n\n\t\tif ( value === undefined ) {\n\t\t\tstoredValue = storage.getItem( key );\n\t\t\tparsed = storedValue ? JSON.parse( storedValue ) : { expires: -1 };\n\t\t\tif ( parsed.expires && parsed.expires <= now ) {\n\t\t\t\tstorage.removeItem( key );\n\t\t\t} else {\n\t\t\t\treturn parsed.data;\n\t\t\t}\n\t\t} else {\n\t\t\tif ( value === null ) {\n\t\t\t\tstorage.removeItem( key );\n\t\t\t} else {\n\t\t\t\tparsed = JSON.stringify({\n\t\t\t\t\tdata: value,\n\t\t\t\t\texpires: options.expires ? now + options.expires : null\n\t\t\t\t});\n\t\t\t\ttry {\n\t\t\t\t\tstorage.setItem( key, parsed );\n\t\t\t\t// quota exceeded\n\t\t\t\t} catch( error ) {\n\t\t\t\t\t// expire old data and try again\n\t\t\t\t\tstore[ storageType ]();\n\t\t\t\t\ttry {\n\t\t\t\t\t\tstorage.setItem( key, parsed );\n\t\t\t\t\t} catch( error ) {\n\t\t\t\t\t\tthrow store.error();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn ret;\n\t});\n}\n\n// localStorage + sessionStorage\n// IE 8+, Firefox 3.5+, Safari 4+, Chrome 4+, Opera 10.5+, iPhone 2+, Android 2+\nfor ( var webStorageType in { localStorage: 1, sessionStorage: 1 } ) {\n\t// try/catch for file protocol in Firefox\n\ttry {\n\t\tif ( window[ webStorageType ].getItem ) {\n\t\t\tcreateFromStorageInterface( webStorageType, window[ webStorageType ] );\n\t\t}\n\t} catch( e ) {}\n}\n\n// globalStorage\n// non-standard: Firefox 2+\n// https://developer.mozilla.org/en/dom/storage#globalStorage\nif ( window.globalStorage ) {\n\t// try/catch for file protocol in Firefox\n\ttry {\n\t\tcreateFromStorageInterface( \"globalStorage\",\n\t\t\twindow.globalStorage[ window.location.hostname ] );\n\t\t// Firefox 2.0 and 3.0 have sessionStorage and globalStorage\n\t\t// make sure we default to globalStorage\n\t\t// but don't default to globalStorage in 3.5+ which also has localStorage\n\t\tif ( store.type === \"sessionStorage\" ) {\n\t\t\tstore.type = \"globalStorage\";\n\t\t}\n\t} catch( e ) {}\n}\n\n// userData\n// non-standard: IE 5+\n// http://msdn.microsoft.com/en-us/library/ms531424(v=vs.85).aspx\n(function() {\n\t// IE 9 has quirks in userData that are a huge pain\n\t// rather than finding a way to detect these quirks\n\t// we just don't register userData if we have localStorage\n\tif ( store.types.localStorage ) {\n\t\treturn;\n\t}\n\n\t// append to html instead of body so we can do this from the head\n\tvar div = document.createElement( \"div\" ),\n\t\tattrKey = \"amplify\";\n\tdiv.style.display = \"none\";\n\tdocument.getElementsByTagName( \"head\" )[ 0 ].appendChild( div );\n\n\t// we can't feature detect userData support\n\t// so just try and see if it fails\n\t// surprisingly, even just adding the behavior isn't enough for a failure\n\t// so we need to load the data as well\n\ttry {\n\t\tdiv.addBehavior( \"#default#userdata\" );\n\t\tdiv.load( attrKey );\n\t} catch( e ) {\n\t\tdiv.parentNode.removeChild( div );\n\t\treturn;\n\t}\n\n\tstore.addType( \"userData\", function( key, value, options ) {\n\t\tdiv.load( attrKey );\n\t\tvar attr, parsed, prevValue, i, remove,\n\t\t\tret = value,\n\t\t\tnow = (new Date()).getTime();\n\n\t\tif ( !key ) {\n\t\t\tret = {};\n\t\t\tremove = [];\n\t\t\ti = 0;\n\t\t\twhile ( attr = div.XMLDocument.documentElement.attributes[ i++ ] ) {\n\t\t\t\tparsed = JSON.parse( attr.value );\n\t\t\t\tif ( parsed.expires && parsed.expires <= now ) {\n\t\t\t\t\tremove.push( attr.name );\n\t\t\t\t} else {\n\t\t\t\t\tret[ attr.name ] = parsed.data;\n\t\t\t\t}\n\t\t\t}\n\t\t\twhile ( key = remove.pop() ) {\n\t\t\t\tdiv.removeAttribute( key );\n\t\t\t}\n\t\t\tdiv.save( attrKey );\n\t\t\treturn ret;\n\t\t}\n\n\t\t// convert invalid characters to dashes\n\t\t// http://www.w3.org/TR/REC-xml/#NT-Name\n\t\t// simplified to assume the starting character is valid\n\t    // also removed colon as it is invalid in HTML attribute names\n        //Changed 4/25/2013 by Jordan to allow for bundling/minification\n\t\tkey = key.replace( /[^-._0-9A-Za-z\\xb7\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u037d\\u037f-\\u1fff\\u200c-\\u200d\\u203f\\u2040\\u2070-\\u218f]/g, \"-\" );\n\n\t\tif ( value === undefined ) {\n\t\t\tattr = div.getAttribute( key );\n\t\t\tparsed = attr ? JSON.parse( attr ) : { expires: -1 };\n\t\t\tif ( parsed.expires && parsed.expires <= now ) {\n\t\t\t\tdiv.removeAttribute( key );\n\t\t\t} else {\n\t\t\t\treturn parsed.data;\n\t\t\t}\n\t\t} else {\n\t\t\tif ( value === null ) {\n\t\t\t\tdiv.removeAttribute( key );\n\t\t\t} else {\n\t\t\t\t// we need to get the previous value in case we need to rollback\n\t\t\t\tprevValue = div.getAttribute( key );\n\t\t\t\tparsed = JSON.stringify({\n\t\t\t\t\tdata: value,\n\t\t\t\t\texpires: (options.expires ? (now + options.expires) : null)\n\t\t\t\t});\n\t\t\t\tdiv.setAttribute( key, parsed );\n\t\t\t}\n\t\t}\n\n\t\ttry {\n\t\t\tdiv.save( attrKey );\n\t\t// quota exceeded\n\t\t} catch ( error ) {\n\t\t\t// roll the value back to the previous value\n\t\t\tif ( prevValue === null ) {\n\t\t\t\tdiv.removeAttribute( key );\n\t\t\t} else {\n\t\t\t\tdiv.setAttribute( key, prevValue );\n\t\t\t}\n\n\t\t\t// expire old data and try again\n\t\t\tstore.userData();\n\t\t\ttry {\n\t\t\t\tdiv.setAttribute( key, parsed );\n\t\t\t\tdiv.save( attrKey );\n\t\t\t} catch ( error ) {\n\t\t\t\t// roll the value back to the previous value\n\t\t\t\tif ( prevValue === null ) {\n\t\t\t\t\tdiv.removeAttribute( key );\n\t\t\t\t} else {\n\t\t\t\t\tdiv.setAttribute( key, prevValue );\n\t\t\t\t}\n\t\t\t\tthrow store.error();\n\t\t\t}\n\t\t}\n\t\treturn ret;\n\t});\n}() );\n\n// in-memory storage\n// fallback for all browsers to enable the API even if we can't persist data\n(function() {\n\tvar memory = {},\n\t\ttimeout = {};\n\n\tfunction copy( obj ) {\n\t\treturn obj === undefined ? undefined : JSON.parse( JSON.stringify( obj ) );\n\t}\n\n\tstore.addType( \"memory\", function( key, value, options ) {\n\t\tif ( !key ) {\n\t\t\treturn copy( memory );\n\t\t}\n\n\t\tif ( value === undefined ) {\n\t\t\treturn copy( memory[ key ] );\n\t\t}\n\n\t\tif ( timeout[ key ] ) {\n\t\t\tclearTimeout( timeout[ key ] );\n\t\t\tdelete timeout[ key ];\n\t\t}\n\n\t\tif ( value === null ) {\n\t\t\tdelete memory[ key ];\n\t\t\treturn null;\n\t\t}\n\n\t\tmemory[ key ] = value;\n\t\tif ( options.expires ) {\n\t\t\ttimeout[ key ] = setTimeout(function() {\n\t\t\t\tdelete memory[ key ];\n\t\t\t\tdelete timeout[ key ];\n\t\t\t}, options.expires );\n\t\t}\n\n\t\treturn value;\n\t});\n}() );\n\n}( window.amplify = window.amplify || {} ) );\n/*!\n * Amplify Request 1.1.0\n * \n * Copyright 2011 appendTo LLC. (http://appendto.com/team)\n * Dual licensed under the MIT or GPL licenses.\n * http://appendto.com/open-source-licenses\n * \n * http://amplifyjs.com\n */\n(function( amplify, undefined ) {\n\nfunction noop() {}\nfunction isFunction( obj ) {\n\treturn ({}).toString.call( obj ) === \"[object Function]\";\n}\n\nfunction async( fn ) {\n\tvar isAsync = false;\n\tsetTimeout(function() {\n\t\tisAsync = true;\n\t}, 1 );\n\treturn function() {\n\t\tvar that = this,\n\t\t\targs = arguments;\n\t\tif ( isAsync ) {\n\t\t\tfn.apply( that, args );\n\t\t} else {\n\t\t\tsetTimeout(function() {\n\t\t\t\tfn.apply( that, args );\n\t\t\t}, 1 );\n\t\t}\n\t};\n}\n\namplify.request = function( resourceId, data, callback ) {\n\t// default to an empty hash just so we can handle a missing resourceId\n\t// in one place\n\tvar settings = resourceId || {};\n\n\tif ( typeof settings === \"string\" ) {\n\t\tif ( isFunction( data ) ) {\n\t\t\tcallback = data;\n\t\t\tdata = {};\n\t\t}\n\t\tsettings = {\n\t\t\tresourceId: resourceId,\n\t\t\tdata: data || {},\n\t\t\tsuccess: callback\n\t\t};\n\t}\n\n\tvar request = { abort: noop },\n\t\tresource = amplify.request.resources[ settings.resourceId ],\n\t\tsuccess = settings.success || noop,\n\t\terror = settings.error || noop;\n\tsettings.success = async( function( data, status ) {\n\t\tstatus = status || \"success\";\n\t\tamplify.publish( \"request.success\", settings, data, status );\n\t\tamplify.publish( \"request.complete\", settings, data, status );\n\t\tsuccess( data, status );\n\t});\n\tsettings.error = async( function( data, status ) {\n\t\tstatus = status || \"error\";\n\t\tamplify.publish( \"request.error\", settings, data, status );\n\t\tamplify.publish( \"request.complete\", settings, data, status );\n\t\terror( data, status );\n\t});\n\n\tif ( !resource ) {\n\t\tif ( !settings.resourceId ) {\n\t\t\tthrow \"amplify.request: no resourceId provided\";\n\t\t}\n\t\tthrow \"amplify.request: unknown resourceId: \" + settings.resourceId;\n\t}\n\n\tif ( !amplify.publish( \"request.before\", settings ) ) {\n\t\tsettings.error( null, \"abort\" );\n\t\treturn;\n\t}\n\n\tamplify.request.resources[ settings.resourceId ]( settings, request );\n\treturn request;\n};\n\namplify.request.types = {};\namplify.request.resources = {};\namplify.request.define = function( resourceId, type, settings ) {\n\tif ( typeof type === \"string\" ) {\n\t\tif ( !( type in amplify.request.types ) ) {\n\t\t\tthrow \"amplify.request.define: unknown type: \" + type;\n\t\t}\n\n\t\tsettings.resourceId = resourceId;\n\t\tamplify.request.resources[ resourceId ] =\n\t\t\tamplify.request.types[ type ]( settings );\n\t} else {\n\t\t// no pre-processor or settings for one-off types (don't invoke)\n\t\tamplify.request.resources[ resourceId ] = type;\n\t}\n};\n\n}( amplify ) );\n\n\n\n\n\n(function( amplify, $, undefined ) {\n\nvar xhrProps = [ \"status\", \"statusText\", \"responseText\", \"responseXML\", \"readyState\" ],\n    rurlData = /\\{([^\\}]+)\\}/g;\n\namplify.request.types.ajax = function( defnSettings ) {\n\tdefnSettings = $.extend({\n\t\ttype: \"GET\"\n\t}, defnSettings );\n\n\treturn function( settings, request ) {\n\t\tvar xhr,\n\t\t\turl = defnSettings.url,\n\t\t\tabort = request.abort,\n\t\t\tajaxSettings = $.extend( true, {}, defnSettings, { data: settings.data } ),\n\t\t\taborted = false,\n\t\t\tampXHR = {\n\t\t\t\treadyState: 0,\n\t\t\t\tsetRequestHeader: function( name, value ) {\n\t\t\t\t\treturn xhr.setRequestHeader( name, value );\n\t\t\t\t},\n\t\t\t\tgetAllResponseHeaders: function() {\n\t\t\t\t\treturn xhr.getAllResponseHeaders();\n\t\t\t\t},\n\t\t\t\tgetResponseHeader: function( key ) {\n\t\t\t\t\treturn xhr.getResponseHeader( key );\n\t\t\t\t},\n\t\t\t\toverrideMimeType: function( type ) {\n\t\t\t\t\treturn xhr.overrideMideType( type );\n\t\t\t\t},\n\t\t\t\tabort: function() {\n\t\t\t\t\taborted = true;\n\t\t\t\t\ttry {\n\t\t\t\t\t\txhr.abort();\n\t\t\t\t\t// IE 7 throws an error when trying to abort\n\t\t\t\t\t} catch( e ) {}\n\t\t\t\t\thandleResponse( null, \"abort\" );\n\t\t\t\t},\n\t\t\t\tsuccess: function( data, status ) {\n\t\t\t\t\tsettings.success( data, status );\n\t\t\t\t},\n\t\t\t\terror: function( data, status ) {\n\t\t\t\t\tsettings.error( data, status );\n\t\t\t\t}\n\t\t\t};\n\n\t\tamplify.publish( \"request.ajax.preprocess\",\n\t\t\tdefnSettings, settings, ajaxSettings, ampXHR );\n\n\t\t$.extend( ajaxSettings, {\n\t\t\tsuccess: function( data, status ) {\n\t\t\t\thandleResponse( data, status );\n\t\t\t},\n\t\t\terror: function( _xhr, status ) {\n\t\t\t\thandleResponse( null, status );\n\t\t\t},\n\t\t\tbeforeSend: function( _xhr, _ajaxSettings ) {\n\t\t\t\txhr = _xhr;\n\t\t\t\tajaxSettings = _ajaxSettings;\n\t\t\t\tvar ret = defnSettings.beforeSend ?\n\t\t\t\t\tdefnSettings.beforeSend.call( this, ampXHR, ajaxSettings ) : true;\n\t\t\t\treturn ret && amplify.publish( \"request.before.ajax\",\n\t\t\t\t\tdefnSettings, settings, ajaxSettings, ampXHR );\n\t\t\t}\n\t\t});\n\t\t$.ajax( ajaxSettings );\n\n\t\tfunction handleResponse( data, status ) {\n\t\t\t$.each( xhrProps, function( i, key ) {\n\t\t\t\ttry {\n\t\t\t\t\tampXHR[ key ] = xhr[ key ];\n\t\t\t\t} catch( e ) {}\n\t\t\t});\n\t\t\t// Playbook returns \"HTTP/1.1 200 OK\"\n\t\t\t// TODO: something also returns \"OK\", what?\n\t\t\tif ( /OK$/.test( ampXHR.statusText ) ) {\n\t\t\t\tampXHR.statusText = \"success\";\n\t\t\t}\n\t\t\tif ( data === undefined ) {\n\t\t\t\t// TODO: add support for ajax errors with data\n\t\t\t\tdata = null;\n\t\t\t}\n\t\t\tif ( aborted ) {\n\t\t\t\tstatus = \"abort\";\n\t\t\t}\n\t\t\tif ( /timeout|error|abort/.test( status ) ) {\n\t\t\t\tampXHR.error( data, status );\n\t\t\t} else {\n\t\t\t\tampXHR.success( data, status );\n\t\t\t}\n\t\t\t// avoid handling a response multiple times\n\t\t\t// this can happen if a request is aborted\n\t\t\t// TODO: figure out if this breaks polling or multi-part responses\n\t\t\thandleResponse = $.noop;\n\t\t}\n\n\t\trequest.abort = function() {\n\t\t\tampXHR.abort();\n\t\t\tabort.call( this );\n\t\t};\n\t};\n};\n\n\n\namplify.subscribe( \"request.ajax.preprocess\", function( defnSettings, settings, ajaxSettings ) {\n\tvar mappedKeys = [],\n\t\tdata = ajaxSettings.data;\n\n\tif ( typeof data === \"string\" ) {\n\t\treturn;\n\t}\n\n\tdata = $.extend( true, {}, defnSettings.data, data );\n\n\tajaxSettings.url = ajaxSettings.url.replace( rurlData, function ( m, key ) {\n\t\tif ( key in data ) {\n\t\t    mappedKeys.push( key );\n\t\t    return data[ key ];\n\t\t}\n\t});\n\n\t// We delete the keys later so duplicates are still replaced\n\t$.each( mappedKeys, function ( i, key ) {\n\t\tdelete data[ key ];\n\t});\n\n\tajaxSettings.data = data;\n});\n\n\n\namplify.subscribe( \"request.ajax.preprocess\", function( defnSettings, settings, ajaxSettings ) {\n\tvar data = ajaxSettings.data,\n\t\tdataMap = defnSettings.dataMap;\n\n\tif ( !dataMap || typeof data === \"string\" ) {\n\t\treturn;\n\t}\n\n\tif ( $.isFunction( dataMap ) ) {\n\t\tajaxSettings.data = dataMap( data );\n\t} else {\n\t\t$.each( defnSettings.dataMap, function( orig, replace ) {\n\t\t\tif ( orig in data ) {\n\t\t\t\tdata[ replace ] = data[ orig ];\n\t\t\t\tdelete data[ orig ];\n\t\t\t}\n\t\t});\n\t\tajaxSettings.data = data;\n\t}\n});\n\n\n\nvar cache = amplify.request.cache = {\n\t_key: function( resourceId, url, data ) {\n\t\tdata = url + data;\n\t\tvar length = data.length,\n\t\t\ti = 0,\n\t\t\tchecksum = chunk();\n\n\t\twhile ( i < length ) {\n\t\t\tchecksum ^= chunk();\n\t\t}\n\n\t\tfunction chunk() {\n\t\t\treturn data.charCodeAt( i++ ) << 24 |\n\t\t\t\tdata.charCodeAt( i++ ) << 16 |\n\t\t\t\tdata.charCodeAt( i++ ) << 8 |\n\t\t\t\tdata.charCodeAt( i++ ) << 0;\n\t\t}\n\n\t\treturn \"request-\" + resourceId + \"-\" + checksum;\n\t},\n\n\t_default: (function() {\n\t\tvar memoryStore = {};\n\t\treturn function( resource, settings, ajaxSettings, ampXHR ) {\n\t\t\t// data is already converted to a string by the time we get here\n\t\t\tvar cacheKey = cache._key( settings.resourceId,\n\t\t\t\t\tajaxSettings.url, ajaxSettings.data ),\n\t\t\t\tduration = resource.cache;\n\n\t\t\tif ( cacheKey in memoryStore ) {\n\t\t\t\tampXHR.success( memoryStore[ cacheKey ] );\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tvar success = ampXHR.success;\n\t\t\tampXHR.success = function( data ) {\n\t\t\t\tmemoryStore[ cacheKey ] = data;\n\t\t\t\tif ( typeof duration === \"number\" ) {\n\t\t\t\t\tsetTimeout(function() {\n\t\t\t\t\t\tdelete memoryStore[ cacheKey ];\n\t\t\t\t\t}, duration );\n\t\t\t\t}\n\t\t\t\tsuccess.apply( this, arguments );\n\t\t\t};\n\t\t};\n\t}())\n};\n\nif ( amplify.store ) {\n\t$.each( amplify.store.types, function( type ) {\n\t\tcache[ type ] = function( resource, settings, ajaxSettings, ampXHR ) {\n\t\t\tvar cacheKey = cache._key( settings.resourceId,\n\t\t\t\t\tajaxSettings.url, ajaxSettings.data ),\n\t\t\t\tcached = amplify.store[ type ]( cacheKey );\n\n\t\t\tif ( cached ) {\n\t\t\t\tajaxSettings.success( cached );\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tvar success = ampXHR.success;\n\t\t\tampXHR.success = function( data ) {\t\n\t\t\t\tamplify.store[ type ]( cacheKey, data, { expires: resource.cache.expires } );\n\t\t\t\tsuccess.apply( this, arguments );\n\t\t\t};\n\t\t};\n\t});\n\tcache.persist = cache[ amplify.store.type ];\n}\n\namplify.subscribe( \"request.before.ajax\", function( resource ) {\n\tvar cacheType = resource.cache;\n\tif ( cacheType ) {\n\t\t// normalize between objects and strings/booleans/numbers\n\t\tcacheType = cacheType.type || cacheType;\n\t\treturn cache[ cacheType in cache ? cacheType : \"_default\" ]\n\t\t\t.apply( this, arguments );\n\t}\n});\n\n\n\namplify.request.decoders = {\n\t// http://labs.omniti.com/labs/jsend\n\tjsend: function( data, status, ampXHR, success, error ) {\n\t\tif ( data.status === \"success\" ) {\n\t\t\tsuccess( data.data );\n\t\t} else if ( data.status === \"fail\" ) {\n\t\t\terror( data.data, \"fail\" );\n\t\t} else if ( data.status === \"error\" ) {\n\t\t\tdelete data.status;\n\t\t\terror( data, \"error\" );\n\t\t}\n\t}\n};\n\namplify.subscribe( \"request.before.ajax\", function( resource, settings, ajaxSettings, ampXHR ) {\n\tvar _success = ampXHR.success,\n\t\t_error = ampXHR.error,\n\t\tdecoder = $.isFunction( resource.decoder )\n\t\t\t? resource.decoder\n\t\t\t: resource.decoder in amplify.request.decoders\n\t\t\t\t? amplify.request.decoders[ resource.decoder ]\n\t\t\t\t: amplify.request.decoders._default;\n\n\tif ( !decoder ) {\n\t\treturn;\n\t}\n\n\tfunction success( data, status ) {\n\t\t_success( data, status );\n\t}\n\tfunction error( data, status ) {\n\t\t_error( data, status );\n\t}\n\tampXHR.success = function( data, status ) {\n\t\tdecoder( data, status, ampXHR, success, error );\n\t};\n\tampXHR.error = function( data, status ) {\n\t\tdecoder( data, status, ampXHR, success, error );\n\t};\n});\n\n}( amplify, jQuery ) );\n","/*!\n * ASP.NET SignalR JavaScript Library v2.2.0\n * http://signalr.net/\n *\n * Copyright (C) Microsoft Corporation. All rights reserved.\n *\n */\n(function(n,t,i){function w(t,i){var u,f;if(n.isArray(t)){for(u=t.length-1;u>=0;u--)f=t[u],n.type(f)===\"string\"&&r.transports[f]||(i.log(\"Invalid transport: \"+f+\", removing it from the transports list.\"),t.splice(u,1));t.length===0&&(i.log(\"No transports remain within the specified transport array.\"),t=null)}else if(r.transports[t]||t===\"auto\"){if(t===\"auto\"&&r._.ieVersion<=8)return[\"longPolling\"]}else i.log(\"Invalid transport: \"+t.toString()+\".\"),t=null;return t}function b(n){return n===\"http:\"?80:n===\"https:\"?443:void 0}function a(n,t){return t.match(/:\\d+$/)?t:t+\":\"+b(n)}function k(t,i){var u=this,r=[];u.tryBuffer=function(i){return t.state===n.signalR.connectionState.connecting?(r.push(i),!0):!1};u.drain=function(){if(t.state===n.signalR.connectionState.connected)while(r.length>0)i(r.shift())};u.clear=function(){r=[]}}var f={nojQuery:\"jQuery was not found. Please ensure jQuery is referenced before the SignalR client JavaScript file.\",noTransportOnInit:\"No transport could be initialized successfully. Try specifying a different transport or none at all for auto initialization.\",errorOnNegotiate:\"Error during negotiation request.\",stoppedWhileLoading:\"The connection was stopped during page load.\",stoppedWhileNegotiating:\"The connection was stopped during the negotiate request.\",errorParsingNegotiateResponse:\"Error parsing negotiate response.\",errorDuringStartRequest:\"Error during start request. Stopping the connection.\",stoppedDuringStartRequest:\"The connection was stopped during the start request.\",errorParsingStartResponse:\"Error parsing start response: '{0}'. Stopping the connection.\",invalidStartResponse:\"Invalid start response: '{0}'. Stopping the connection.\",protocolIncompatible:\"You are using a version of the client that isn't compatible with the server. Client version {0}, server version {1}.\",sendFailed:\"Send failed.\",parseFailed:\"Failed at parsing response: {0}\",longPollFailed:\"Long polling request failed.\",eventSourceFailedToConnect:\"EventSource failed to connect.\",eventSourceError:\"Error raised by EventSource\",webSocketClosed:\"WebSocket closed.\",pingServerFailedInvalidResponse:\"Invalid ping response when pinging server: '{0}'.\",pingServerFailed:\"Failed to ping server.\",pingServerFailedStatusCode:\"Failed to ping server.  Server responded with status code {0}, stopping the connection.\",pingServerFailedParse:\"Failed to parse ping server response, stopping the connection.\",noConnectionTransport:\"Connection is in an invalid state, there is no transport active.\",webSocketsInvalidState:\"The Web Socket transport is in an invalid state, transitioning into reconnecting.\",reconnectTimeout:\"Couldn't reconnect within the configured timeout of {0} ms, disconnecting.\",reconnectWindowTimeout:\"The client has been inactive since {0} and it has exceeded the inactivity timeout of {1} ms. Stopping the connection.\"};if(typeof n!=\"function\")throw new Error(f.nojQuery);var r,h,s=t.document.readyState===\"complete\",e=n(t),c=\"__Negotiate Aborted__\",u={onStart:\"onStart\",onStarting:\"onStarting\",onReceived:\"onReceived\",onError:\"onError\",onConnectionSlow:\"onConnectionSlow\",onReconnecting:\"onReconnecting\",onReconnect:\"onReconnect\",onStateChanged:\"onStateChanged\",onDisconnect:\"onDisconnect\"},v=function(n,i){if(i!==!1){var r;typeof t.console!=\"undefined\"&&(r=\"[\"+(new Date).toTimeString()+\"] SignalR: \"+n,t.console.debug?t.console.debug(r):t.console.log&&t.console.log(r))}},o=function(t,i,r){return i===t.state?(t.state=r,n(t).triggerHandler(u.onStateChanged,[{oldState:i,newState:r}]),!0):!1},y=function(n){return n.state===r.connectionState.disconnected},l=function(n){return n._.keepAliveData.activated&&n.transport.supportsKeepAlive(n)},p=function(i){var f,e;i._.configuredStopReconnectingTimeout||(e=function(t){var i=r._.format(r.resources.reconnectTimeout,t.disconnectTimeout);t.log(i);n(t).triggerHandler(u.onError,[r._.error(i,\"TimeoutException\")]);t.stop(!1,!1)},i.reconnecting(function(){var n=this;n.state===r.connectionState.reconnecting&&(f=t.setTimeout(function(){e(n)},n.disconnectTimeout))}),i.stateChanged(function(n){n.oldState===r.connectionState.reconnecting&&t.clearTimeout(f)}),i._.configuredStopReconnectingTimeout=!0)};r=function(n,t,i){return new r.fn.init(n,t,i)};r._={defaultContentType:\"application/x-www-form-urlencoded; charset=UTF-8\",ieVersion:function(){var i,n;return t.navigator.appName===\"Microsoft Internet Explorer\"&&(n=/MSIE ([0-9]+\\.[0-9]+)/.exec(t.navigator.userAgent),n&&(i=t.parseFloat(n[1]))),i}(),error:function(n,t,i){var r=new Error(n);return r.source=t,typeof i!=\"undefined\"&&(r.context=i),r},transportError:function(n,t,r,u){var f=this.error(n,r,u);return f.transport=t?t.name:i,f},format:function(){for(var t=arguments[0],n=0;n<arguments.length-1;n++)t=t.replace(\"{\"+n+\"}\",arguments[n+1]);return t},firefoxMajorVersion:function(n){var t=n.match(/Firefox\\/(\\d+)/);return!t||!t.length||t.length<2?0:parseInt(t[1],10)},configurePingInterval:function(i){var f=i._.config,e=function(t){n(i).triggerHandler(u.onError,[t])};f&&!i._.pingIntervalId&&f.pingInterval&&(i._.pingIntervalId=t.setInterval(function(){r.transports._logic.pingServer(i).fail(e)},f.pingInterval))}};r.events=u;r.resources=f;r.ajaxDefaults={processData:!0,timeout:null,async:!0,global:!1,cache:!1};r.changeState=o;r.isDisconnecting=y;r.connectionState={connecting:0,connected:1,reconnecting:2,disconnected:4};r.hub={start:function(){throw new Error(\"SignalR: Error loading hubs. Ensure your hubs reference is correct, e.g. <script src='/signalr/js'><\\/script>.\");}};e.load(function(){s=!0});r.fn=r.prototype={init:function(t,i,r){var f=n(this);this.url=t;this.qs=i;this.lastError=null;this._={keepAliveData:{},connectingMessageBuffer:new k(this,function(n){f.triggerHandler(u.onReceived,[n])}),lastMessageAt:(new Date).getTime(),lastActiveAt:(new Date).getTime(),beatInterval:5e3,beatHandle:null,totalTransportConnectTimeout:0};typeof r==\"boolean\"&&(this.logging=r)},_parseResponse:function(n){var t=this;return n?typeof n==\"string\"?t.json.parse(n):n:n},_originalJson:t.JSON,json:t.JSON,isCrossDomain:function(i,r){var u;return(i=n.trim(i),r=r||t.location,i.indexOf(\"http\")!==0)?!1:(u=t.document.createElement(\"a\"),u.href=i,u.protocol+a(u.protocol,u.host)!==r.protocol+a(r.protocol,r.host))},ajaxDataType:\"text\",contentType:\"application/json; charset=UTF-8\",logging:!1,state:r.connectionState.disconnected,clientProtocol:\"1.5\",reconnectDelay:2e3,transportConnectTimeout:0,disconnectTimeout:3e4,reconnectWindow:3e4,keepAliveWarnAt:2/3,start:function(i,h){var a=this,v={pingInterval:3e5,waitForPageLoad:!0,transport:\"auto\",jsonp:!1},d,y=a._deferral||n.Deferred(),b=t.document.createElement(\"a\"),k,g;if(a.lastError=null,a._deferral=y,!a.json)throw new Error(\"SignalR: No JSON parser found. Please ensure json2.js is referenced before the SignalR.js file if you need to support clients without native JSON parsing support, e.g. IE<8.\");if(n.type(i)===\"function\"?h=i:n.type(i)===\"object\"&&(n.extend(v,i),n.type(v.callback)===\"function\"&&(h=v.callback)),v.transport=w(v.transport,a),!v.transport)throw new Error(\"SignalR: Invalid transport(s) specified, aborting start.\");return(a._.config=v,!s&&v.waitForPageLoad===!0)?(a._.deferredStartHandler=function(){a.start(i,h)},e.bind(\"load\",a._.deferredStartHandler),y.promise()):a.state===r.connectionState.connecting?y.promise():o(a,r.connectionState.disconnected,r.connectionState.connecting)===!1?(y.resolve(a),y.promise()):(p(a),b.href=a.url,b.protocol&&b.protocol!==\":\"?(a.protocol=b.protocol,a.host=b.host):(a.protocol=t.document.location.protocol,a.host=b.host||t.document.location.host),a.baseUrl=a.protocol+\"//\"+a.host,a.wsProtocol=a.protocol===\"https:\"?\"wss://\":\"ws://\",v.transport===\"auto\"&&v.jsonp===!0&&(v.transport=\"longPolling\"),a.url.indexOf(\"//\")===0&&(a.url=t.location.protocol+a.url,a.log(\"Protocol relative URL detected, normalizing it to '\"+a.url+\"'.\")),this.isCrossDomain(a.url)&&(a.log(\"Auto detected cross domain url.\"),v.transport===\"auto\"&&(v.transport=[\"webSockets\",\"serverSentEvents\",\"longPolling\"]),typeof v.withCredentials==\"undefined\"&&(v.withCredentials=!0),v.jsonp||(v.jsonp=!n.support.cors,v.jsonp&&a.log(\"Using jsonp because this browser doesn't support CORS.\")),a.contentType=r._.defaultContentType),a.withCredentials=v.withCredentials,a.ajaxDataType=v.jsonp?\"jsonp\":\"text\",n(a).bind(u.onStart,function(){n.type(h)===\"function\"&&h.call(a);y.resolve(a)}),a._.initHandler=r.transports._logic.initHandler(a),d=function(i,s){var c=r._.error(f.noTransportOnInit);if(s=s||0,s>=i.length){s===0?a.log(\"No transports supported by the server were selected.\"):s===1?a.log(\"No fallback transports were selected.\"):a.log(\"Fallback transports exhausted.\");n(a).triggerHandler(u.onError,[c]);y.reject(c);a.stop();return}if(a.state!==r.connectionState.disconnected){var p=i[s],h=r.transports[p],v=function(){d(i,s+1)};a.transport=h;try{a._.initHandler.start(h,function(){var i=r._.firefoxMajorVersion(t.navigator.userAgent)>=11,f=!!a.withCredentials&&i;a.log(\"The start request succeeded. Transitioning to the connected state.\");l(a)&&r.transports._logic.monitorKeepAlive(a);r.transports._logic.startHeartbeat(a);r._.configurePingInterval(a);o(a,r.connectionState.connecting,r.connectionState.connected)||a.log(\"WARNING! The connection was not in the connecting state.\");a._.connectingMessageBuffer.drain();n(a).triggerHandler(u.onStart);e.bind(\"unload\",function(){a.log(\"Window unloading, stopping the connection.\");a.stop(f)});i&&e.bind(\"beforeunload\",function(){t.setTimeout(function(){a.stop(f)},0)})},v)}catch(w){a.log(h.name+\" transport threw '\"+w.message+\"' when attempting to start.\");v()}}},k=a.url+\"/negotiate\",g=function(t,i){var e=r._.error(f.errorOnNegotiate,t,i._.negotiateRequest);n(i).triggerHandler(u.onError,e);y.reject(e);i.stop()},n(a).triggerHandler(u.onStarting),k=r.transports._logic.prepareQueryString(a,k),a.log(\"Negotiating with '\"+k+\"'.\"),a._.negotiateRequest=r.transports._logic.ajax(a,{url:k,error:function(n,t){t!==c?g(n,a):y.reject(r._.error(f.stoppedWhileNegotiating,null,a._.negotiateRequest))},success:function(t){var i,e,h,o=[],s=[];try{i=a._parseResponse(t)}catch(c){g(r._.error(f.errorParsingNegotiateResponse,c),a);return}if(e=a._.keepAliveData,a.appRelativeUrl=i.Url,a.id=i.ConnectionId,a.token=i.ConnectionToken,a.webSocketServerUrl=i.WebSocketServerUrl,a._.pollTimeout=i.ConnectionTimeout*1e3+1e4,a.disconnectTimeout=i.DisconnectTimeout*1e3,a._.totalTransportConnectTimeout=a.transportConnectTimeout+i.TransportConnectTimeout*1e3,i.KeepAliveTimeout?(e.activated=!0,e.timeout=i.KeepAliveTimeout*1e3,e.timeoutWarning=e.timeout*a.keepAliveWarnAt,a._.beatInterval=(e.timeout-e.timeoutWarning)/3):e.activated=!1,a.reconnectWindow=a.disconnectTimeout+(e.timeout||0),!i.ProtocolVersion||i.ProtocolVersion!==a.clientProtocol){h=r._.error(r._.format(f.protocolIncompatible,a.clientProtocol,i.ProtocolVersion));n(a).triggerHandler(u.onError,[h]);y.reject(h);return}n.each(r.transports,function(n){if(n.indexOf(\"_\")===0||n===\"webSockets\"&&!i.TryWebSockets)return!0;s.push(n)});n.isArray(v.transport)?n.each(v.transport,function(t,i){n.inArray(i,s)>=0&&o.push(i)}):v.transport===\"auto\"?o=s:n.inArray(v.transport,s)>=0&&o.push(v.transport);d(o)}}),y.promise())},starting:function(t){var i=this;return n(i).bind(u.onStarting,function(){t.call(i)}),i},send:function(n){var t=this;if(t.state===r.connectionState.disconnected)throw new Error(\"SignalR: Connection must be started before data can be sent. Call .start() before .send()\");if(t.state===r.connectionState.connecting)throw new Error(\"SignalR: Connection has not been fully initialized. Use .start().done() or .start().fail() to run logic after the connection has started.\");return t.transport.send(t,n),t},received:function(t){var i=this;return n(i).bind(u.onReceived,function(n,r){t.call(i,r)}),i},stateChanged:function(t){var i=this;return n(i).bind(u.onStateChanged,function(n,r){t.call(i,r)}),i},error:function(t){var i=this;return n(i).bind(u.onError,function(n,r,u){i.lastError=r;t.call(i,r,u)}),i},disconnected:function(t){var i=this;return n(i).bind(u.onDisconnect,function(){t.call(i)}),i},connectionSlow:function(t){var i=this;return n(i).bind(u.onConnectionSlow,function(){t.call(i)}),i},reconnecting:function(t){var i=this;return n(i).bind(u.onReconnecting,function(){t.call(i)}),i},reconnected:function(t){var i=this;return n(i).bind(u.onReconnect,function(){t.call(i)}),i},stop:function(i,h){var a=this,v=a._deferral;if(a._.deferredStartHandler&&e.unbind(\"load\",a._.deferredStartHandler),delete a._.config,delete a._.deferredStartHandler,!s&&(!a._.config||a._.config.waitForPageLoad===!0)){a.log(\"Stopping connection prior to negotiate.\");v&&v.reject(r._.error(f.stoppedWhileLoading));return}if(a.state!==r.connectionState.disconnected)return a.log(\"Stopping connection.\"),o(a,a.state,r.connectionState.disconnected),t.clearTimeout(a._.beatHandle),t.clearInterval(a._.pingIntervalId),a.transport&&(a.transport.stop(a),h!==!1&&a.transport.abort(a,i),l(a)&&r.transports._logic.stopMonitoringKeepAlive(a),a.transport=null),a._.negotiateRequest&&(a._.negotiateRequest.abort(c),delete a._.negotiateRequest),a._.initHandler&&a._.initHandler.stop(),n(a).triggerHandler(u.onDisconnect),delete a._deferral,delete a.messageId,delete a.groupsToken,delete a.id,delete a._.pingIntervalId,delete a._.lastMessageAt,delete a._.lastActiveAt,a._.connectingMessageBuffer.clear(),a},log:function(n){v(n,this.logging)}};r.fn.init.prototype=r.fn;r.noConflict=function(){return n.connection===r&&(n.connection=h),r};n.connection&&(h=n.connection);n.connection=n.signalR=r})(window.jQuery,window),function(n,t,i){function s(n){n._.keepAliveData.monitoring&&l(n);u.markActive(n)&&(n._.beatHandle=t.setTimeout(function(){s(n)},n._.beatInterval))}function l(t){var i=t._.keepAliveData,u;t.state===r.connectionState.connected&&(u=(new Date).getTime()-t._.lastMessageAt,u>=i.timeout?(t.log(\"Keep alive timed out.  Notifying transport that connection has been lost.\"),t.transport.lostConnection(t)):u>=i.timeoutWarning?i.userNotified||(t.log(\"Keep alive has been missed, connection may be dead/slow.\"),n(t).triggerHandler(f.onConnectionSlow),i.userNotified=!0):i.userNotified=!1)}function e(n,t){var i=n.url+t;return n.transport&&(i+=\"?transport=\"+n.transport.name),u.prepareQueryString(n,i)}function h(n){this.connection=n;this.startRequested=!1;this.startCompleted=!1;this.connectionStopped=!1}var r=n.signalR,f=n.signalR.events,c=n.signalR.changeState,o=\"__Start Aborted__\",u;r.transports={};h.prototype={start:function(n,r,u){var f=this,e=f.connection,o=!1;if(f.startRequested||f.connectionStopped){e.log(\"WARNING! \"+n.name+\" transport cannot be started. Initialization ongoing or completed.\");return}e.log(n.name+\" transport starting.\");f.transportTimeoutHandle=t.setTimeout(function(){o||(o=!0,e.log(n.name+\" transport timed out when trying to connect.\"),f.transportFailed(n,i,u))},e._.totalTransportConnectTimeout);n.start(e,function(){o||f.initReceived(n,r)},function(t){return o||(o=!0,f.transportFailed(n,t,u)),!f.startCompleted||f.connectionStopped})},stop:function(){this.connectionStopped=!0;t.clearTimeout(this.transportTimeoutHandle);r.transports._logic.tryAbortStartRequest(this.connection)},initReceived:function(n,i){var u=this,f=u.connection;if(u.startRequested){f.log(\"WARNING! The client received multiple init messages.\");return}u.connectionStopped||(u.startRequested=!0,t.clearTimeout(u.transportTimeoutHandle),f.log(n.name+\" transport connected. Initiating start request.\"),r.transports._logic.ajaxStart(f,function(){u.startCompleted=!0;i()}))},transportFailed:function(i,u,e){var o=this.connection,h=o._deferral,s;this.connectionStopped||(t.clearTimeout(this.transportTimeoutHandle),this.startRequested?this.startCompleted||(s=r._.error(r.resources.errorDuringStartRequest,u),o.log(i.name+\" transport failed during the start request. Stopping the connection.\"),n(o).triggerHandler(f.onError,[s]),h&&h.reject(s),o.stop()):(i.stop(o),o.log(i.name+\" transport failed to connect. Attempting to fall back.\"),e()))}};u=r.transports._logic={ajax:function(t,i){return n.ajax(n.extend(!0,{},n.signalR.ajaxDefaults,{type:\"GET\",data:{},xhrFields:{withCredentials:t.withCredentials},contentType:t.contentType,dataType:t.ajaxDataType},i))},pingServer:function(t){var e,f,i=n.Deferred();return t.transport?(e=t.url+\"/ping\",e=u.addQs(e,t.qs),f=u.ajax(t,{url:e,success:function(n){var u;try{u=t._parseResponse(n)}catch(e){i.reject(r._.transportError(r.resources.pingServerFailedParse,t.transport,e,f));t.stop();return}u.Response===\"pong\"?i.resolve():i.reject(r._.transportError(r._.format(r.resources.pingServerFailedInvalidResponse,n),t.transport,null,f))},error:function(n){n.status===401||n.status===403?(i.reject(r._.transportError(r._.format(r.resources.pingServerFailedStatusCode,n.status),t.transport,n,f)),t.stop()):i.reject(r._.transportError(r.resources.pingServerFailed,t.transport,n,f))}})):i.reject(r._.transportError(r.resources.noConnectionTransport,t.transport)),i.promise()},prepareQueryString:function(n,i){var r;return r=u.addQs(i,\"clientProtocol=\"+n.clientProtocol),r=u.addQs(r,n.qs),n.token&&(r+=\"&connectionToken=\"+t.encodeURIComponent(n.token)),n.data&&(r+=\"&connectionData=\"+t.encodeURIComponent(n.data)),r},addQs:function(t,i){var r=t.indexOf(\"?\")!==-1?\"&\":\"?\",u;if(!i)return t;if(typeof i==\"object\")return t+r+n.param(i);if(typeof i==\"string\")return u=i.charAt(0),(u===\"?\"||u===\"&\")&&(r=\"\"),t+r+i;throw new Error(\"Query string property must be either a string or object.\");},getUrl:function(n,i,r,f,e){var h=i===\"webSockets\"?\"\":n.baseUrl,o=h+n.appRelativeUrl,s=\"transport=\"+i;return!e&&n.groupsToken&&(s+=\"&groupsToken=\"+t.encodeURIComponent(n.groupsToken)),r?(o+=f?\"/poll\":\"/reconnect\",!e&&n.messageId&&(s+=\"&messageId=\"+t.encodeURIComponent(n.messageId))):o+=\"/connect\",o+=\"?\"+s,o=u.prepareQueryString(n,o),e||(o+=\"&tid=\"+Math.floor(Math.random()*11)),o},maximizePersistentResponse:function(n){return{MessageId:n.C,Messages:n.M,Initialized:typeof n.S!=\"undefined\"?!0:!1,ShouldReconnect:typeof n.T!=\"undefined\"?!0:!1,LongPollDelay:n.L,GroupsToken:n.G}},updateGroups:function(n,t){t&&(n.groupsToken=t)},stringifySend:function(n,t){return typeof t==\"string\"||typeof t==\"undefined\"||t===null?t:n.json.stringify(t)},ajaxSend:function(t,i){var h=u.stringifySend(t,i),c=e(t,\"/send\"),o,s=function(t,u){n(u).triggerHandler(f.onError,[r._.transportError(r.resources.sendFailed,u.transport,t,o),i])};return o=u.ajax(t,{url:c,type:t.ajaxDataType===\"jsonp\"?\"GET\":\"POST\",contentType:r._.defaultContentType,data:{data:h},success:function(n){var i;if(n){try{i=t._parseResponse(n)}catch(r){s(r,t);t.stop();return}u.triggerReceived(t,i)}},error:function(n,i){i!==\"abort\"&&i!==\"parsererror\"&&s(n,t)}})},ajaxAbort:function(n,t){if(typeof n.transport!=\"undefined\"){t=typeof t==\"undefined\"?!0:t;var i=e(n,\"/abort\");u.ajax(n,{url:i,async:t,timeout:1e3,type:\"POST\"});n.log(\"Fired ajax abort async = \"+t+\".\")}},ajaxStart:function(t,i){var h=function(n){var i=t._deferral;i&&i.reject(n)},s=function(i){t.log(\"The start request failed. Stopping the connection.\");n(t).triggerHandler(f.onError,[i]);h(i);t.stop()};t._.startRequest=u.ajax(t,{url:e(t,\"/start\"),success:function(n,u,f){var e;try{e=t._parseResponse(n)}catch(o){s(r._.error(r._.format(r.resources.errorParsingStartResponse,n),o,f));return}e.Response===\"started\"?i():s(r._.error(r._.format(r.resources.invalidStartResponse,n),null,f))},error:function(n,i,u){i!==o?s(r._.error(r.resources.errorDuringStartRequest,u,n)):(t.log(\"The start request aborted because connection.stop() was called.\"),h(r._.error(r.resources.stoppedDuringStartRequest,null,n)))}})},tryAbortStartRequest:function(n){n._.startRequest&&(n._.startRequest.abort(o),delete n._.startRequest)},tryInitialize:function(n,t){n.Initialized&&t()},triggerReceived:function(t,i){t._.connectingMessageBuffer.tryBuffer(i)||n(t).triggerHandler(f.onReceived,[i])},processMessages:function(t,i,r){var f;u.markLastMessage(t);i&&(f=u.maximizePersistentResponse(i),u.updateGroups(t,f.GroupsToken),f.MessageId&&(t.messageId=f.MessageId),f.Messages&&(n.each(f.Messages,function(n,i){u.triggerReceived(t,i)}),u.tryInitialize(f,r)))},monitorKeepAlive:function(t){var i=t._.keepAliveData;i.monitoring?t.log(\"Tried to monitor keep alive but it's already being monitored.\"):(i.monitoring=!0,u.markLastMessage(t),t._.keepAliveData.reconnectKeepAliveUpdate=function(){u.markLastMessage(t)},n(t).bind(f.onReconnect,t._.keepAliveData.reconnectKeepAliveUpdate),t.log(\"Now monitoring keep alive with a warning timeout of \"+i.timeoutWarning+\", keep alive timeout of \"+i.timeout+\" and disconnecting timeout of \"+t.disconnectTimeout))},stopMonitoringKeepAlive:function(t){var i=t._.keepAliveData;i.monitoring&&(i.monitoring=!1,n(t).unbind(f.onReconnect,t._.keepAliveData.reconnectKeepAliveUpdate),t._.keepAliveData={},t.log(\"Stopping the monitoring of the keep alive.\"))},startHeartbeat:function(n){n._.lastActiveAt=(new Date).getTime();s(n)},markLastMessage:function(n){n._.lastMessageAt=(new Date).getTime()},markActive:function(n){return u.verifyLastActive(n)?(n._.lastActiveAt=(new Date).getTime(),!0):!1},isConnectedOrReconnecting:function(n){return n.state===r.connectionState.connected||n.state===r.connectionState.reconnecting},ensureReconnectingState:function(t){return c(t,r.connectionState.connected,r.connectionState.reconnecting)===!0&&n(t).triggerHandler(f.onReconnecting),t.state===r.connectionState.reconnecting},clearReconnectTimeout:function(n){n&&n._.reconnectTimeout&&(t.clearTimeout(n._.reconnectTimeout),delete n._.reconnectTimeout)},verifyLastActive:function(t){if((new Date).getTime()-t._.lastActiveAt>=t.reconnectWindow){var i=r._.format(r.resources.reconnectWindowTimeout,new Date(t._.lastActiveAt),t.reconnectWindow);return t.log(i),n(t).triggerHandler(f.onError,[r._.error(i,\"TimeoutException\")]),t.stop(!1,!1),!1}return!0},reconnect:function(n,i){var f=r.transports[i];if(u.isConnectedOrReconnecting(n)&&!n._.reconnectTimeout){if(!u.verifyLastActive(n))return;n._.reconnectTimeout=t.setTimeout(function(){u.verifyLastActive(n)&&(f.stop(n),u.ensureReconnectingState(n)&&(n.log(i+\" reconnecting.\"),f.start(n)))},n.reconnectDelay)}},handleParseFailure:function(t,i,u,e,o){var s=r._.transportError(r._.format(r.resources.parseFailed,i),t.transport,u,o);e&&e(s)?t.log(\"Failed to parse server response while attempting to connect.\"):(n(t).triggerHandler(f.onError,[s]),t.stop())},initHandler:function(n){return new h(n)},foreverFrame:{count:0,connections:{}}}}(window.jQuery,window),function(n,t){var r=n.signalR,u=n.signalR.events,f=n.signalR.changeState,i=r.transports._logic;r.transports.webSockets={name:\"webSockets\",supportsKeepAlive:function(){return!0},send:function(t,f){var e=i.stringifySend(t,f);try{t.socket.send(e)}catch(o){n(t).triggerHandler(u.onError,[r._.transportError(r.resources.webSocketsInvalidState,t.transport,o,t.socket),f])}},start:function(e,o,s){var h,c=!1,l=this,a=!o,v=n(e);if(!t.WebSocket){s();return}e.socket||(h=e.webSocketServerUrl?e.webSocketServerUrl:e.wsProtocol+e.host,h+=i.getUrl(e,this.name,a),e.log(\"Connecting to websocket endpoint '\"+h+\"'.\"),e.socket=new t.WebSocket(h),e.socket.onopen=function(){c=!0;e.log(\"Websocket opened.\");i.clearReconnectTimeout(e);f(e,r.connectionState.reconnecting,r.connectionState.connected)===!0&&v.triggerHandler(u.onReconnect)},e.socket.onclose=function(t){var i;this===e.socket&&(c&&typeof t.wasClean!=\"undefined\"&&t.wasClean===!1?(i=r._.transportError(r.resources.webSocketClosed,e.transport,t),e.log(\"Unclean disconnect from websocket: \"+(t.reason||\"[no reason given].\"))):e.log(\"Websocket closed.\"),s&&s(i)||(i&&n(e).triggerHandler(u.onError,[i]),l.reconnect(e)))},e.socket.onmessage=function(t){var r;try{r=e._parseResponse(t.data)}catch(u){i.handleParseFailure(e,t.data,u,s,t);return}r&&(n.isEmptyObject(r)||r.M?i.processMessages(e,r,o):i.triggerReceived(e,r))})},reconnect:function(n){i.reconnect(n,this.name)},lostConnection:function(n){this.reconnect(n)},stop:function(n){i.clearReconnectTimeout(n);n.socket&&(n.log(\"Closing the Websocket.\"),n.socket.close(),n.socket=null)},abort:function(n,t){i.ajaxAbort(n,t)}}}(window.jQuery,window),function(n,t){var i=n.signalR,u=n.signalR.events,e=n.signalR.changeState,r=i.transports._logic,f=function(n){t.clearTimeout(n._.reconnectAttemptTimeoutHandle);delete n._.reconnectAttemptTimeoutHandle};i.transports.serverSentEvents={name:\"serverSentEvents\",supportsKeepAlive:function(){return!0},timeOut:3e3,start:function(o,s,h){var c=this,l=!1,a=n(o),v=!s,y;if(o.eventSource&&(o.log(\"The connection already has an event source. Stopping it.\"),o.stop()),!t.EventSource){h&&(o.log(\"This browser doesn't support SSE.\"),h());return}y=r.getUrl(o,this.name,v);try{o.log(\"Attempting to connect to SSE endpoint '\"+y+\"'.\");o.eventSource=new t.EventSource(y,{withCredentials:o.withCredentials})}catch(p){o.log(\"EventSource failed trying to connect with error \"+p.Message+\".\");h?h():(a.triggerHandler(u.onError,[i._.transportError(i.resources.eventSourceFailedToConnect,o.transport,p)]),v&&c.reconnect(o));return}v&&(o._.reconnectAttemptTimeoutHandle=t.setTimeout(function(){l===!1&&o.eventSource.readyState!==t.EventSource.OPEN&&c.reconnect(o)},c.timeOut));o.eventSource.addEventListener(\"open\",function(){o.log(\"EventSource connected.\");f(o);r.clearReconnectTimeout(o);l===!1&&(l=!0,e(o,i.connectionState.reconnecting,i.connectionState.connected)===!0&&a.triggerHandler(u.onReconnect))},!1);o.eventSource.addEventListener(\"message\",function(n){var t;if(n.data!==\"initialized\"){try{t=o._parseResponse(n.data)}catch(i){r.handleParseFailure(o,n.data,i,h,n);return}r.processMessages(o,t,s)}},!1);o.eventSource.addEventListener(\"error\",function(n){var r=i._.transportError(i.resources.eventSourceError,o.transport,n);this===o.eventSource&&(h&&h(r)||(o.log(\"EventSource readyState: \"+o.eventSource.readyState+\".\"),n.eventPhase===t.EventSource.CLOSED?(o.log(\"EventSource reconnecting due to the server connection ending.\"),c.reconnect(o)):(o.log(\"EventSource error.\"),a.triggerHandler(u.onError,[r]))))},!1)},reconnect:function(n){r.reconnect(n,this.name)},lostConnection:function(n){this.reconnect(n)},send:function(n,t){r.ajaxSend(n,t)},stop:function(n){f(n);r.clearReconnectTimeout(n);n&&n.eventSource&&(n.log(\"EventSource calling close().\"),n.eventSource.close(),n.eventSource=null,delete n.eventSource)},abort:function(n,t){r.ajaxAbort(n,t)}}}(window.jQuery,window),function(n,t){var r=n.signalR,e=n.signalR.events,o=n.signalR.changeState,i=r.transports._logic,u=function(){var n=t.document.createElement(\"iframe\");return n.setAttribute(\"style\",\"position:absolute;top:0;left:0;width:0;height:0;visibility:hidden;\"),n},f=function(){var i=null,f=1e3,n=0;return{prevent:function(){r._.ieVersion<=8&&(n===0&&(i=t.setInterval(function(){var n=u();t.document.body.appendChild(n);t.document.body.removeChild(n);n=null},f)),n++)},cancel:function(){n===1&&t.clearInterval(i);n>0&&n--}}}();r.transports.foreverFrame={name:\"foreverFrame\",supportsKeepAlive:function(){return!0},iframeClearThreshold:50,start:function(n,r,e){var l=this,s=i.foreverFrame.count+=1,h,o=u(),c=function(){n.log(\"Forever frame iframe finished loading and is no longer receiving messages.\");e&&e()||l.reconnect(n)};if(t.EventSource){e&&(n.log(\"Forever Frame is not supported by SignalR on browsers with SSE support.\"),e());return}o.setAttribute(\"data-signalr-connection-id\",n.id);f.prevent();h=i.getUrl(n,this.name);h+=\"&frameId=\"+s;t.document.documentElement.appendChild(o);n.log(\"Binding to iframe's load event.\");o.addEventListener?o.addEventListener(\"load\",c,!1):o.attachEvent&&o.attachEvent(\"onload\",c);o.src=h;i.foreverFrame.connections[s]=n;n.frame=o;n.frameId=s;r&&(n.onSuccess=function(){n.log(\"Iframe transport started.\");r()})},reconnect:function(n){var r=this;i.isConnectedOrReconnecting(n)&&i.verifyLastActive(n)&&t.setTimeout(function(){if(i.verifyLastActive(n)&&n.frame&&i.ensureReconnectingState(n)){var u=n.frame,t=i.getUrl(n,r.name,!0)+\"&frameId=\"+n.frameId;n.log(\"Updating iframe src to '\"+t+\"'.\");u.src=t}},n.reconnectDelay)},lostConnection:function(n){this.reconnect(n)},send:function(n,t){i.ajaxSend(n,t)},receive:function(t,u){var f,e,o;if(t.json!==t._originalJson&&(u=t._originalJson.stringify(u)),o=t._parseResponse(u),i.processMessages(t,o,t.onSuccess),t.state===n.signalR.connectionState.connected&&(t.frameMessageCount=(t.frameMessageCount||0)+1,t.frameMessageCount>r.transports.foreverFrame.iframeClearThreshold&&(t.frameMessageCount=0,f=t.frame.contentWindow||t.frame.contentDocument,f&&f.document&&f.document.body)))for(e=f.document.body;e.firstChild;)e.removeChild(e.firstChild)},stop:function(n){var r=null;if(f.cancel(),n.frame){if(n.frame.stop)n.frame.stop();else try{r=n.frame.contentWindow||n.frame.contentDocument;r.document&&r.document.execCommand&&r.document.execCommand(\"Stop\")}catch(u){n.log(\"Error occured when stopping foreverFrame transport. Message = \"+u.message+\".\")}n.frame.parentNode===t.document.body&&t.document.body.removeChild(n.frame);delete i.foreverFrame.connections[n.frameId];n.frame=null;n.frameId=null;delete n.frame;delete n.frameId;delete n.onSuccess;delete n.frameMessageCount;n.log(\"Stopping forever frame.\")}},abort:function(n,t){i.ajaxAbort(n,t)},getConnection:function(n){return i.foreverFrame.connections[n]},started:function(t){o(t,r.connectionState.reconnecting,r.connectionState.connected)===!0&&n(t).triggerHandler(e.onReconnect)}}}(window.jQuery,window),function(n,t){var r=n.signalR,u=n.signalR.events,e=n.signalR.changeState,f=n.signalR.isDisconnecting,i=r.transports._logic;r.transports.longPolling={name:\"longPolling\",supportsKeepAlive:function(){return!1},reconnectDelay:3e3,start:function(o,s,h){var a=this,v=function(){v=n.noop;o.log(\"LongPolling connected.\");s()},y=function(n){return h(n)?(o.log(\"LongPolling failed to connect.\"),!0):!1},c=o._,l=0,p=function(i){t.clearTimeout(c.reconnectTimeoutId);c.reconnectTimeoutId=null;e(i,r.connectionState.reconnecting,r.connectionState.connected)===!0&&(i.log(\"Raising the reconnect event\"),n(i).triggerHandler(u.onReconnect))},w=36e5;o.pollXhr&&(o.log(\"Polling xhr requests already exists, aborting.\"),o.stop());o.messageId=null;c.reconnectTimeoutId=null;c.pollTimeoutId=t.setTimeout(function(){(function e(s,h){var g=s.messageId,nt=g===null,k=!nt,tt=!h,d=i.getUrl(s,a.name,k,tt,!0),b={};(s.messageId&&(b.messageId=s.messageId),s.groupsToken&&(b.groupsToken=s.groupsToken),f(s)!==!0)&&(o.log(\"Opening long polling request to '\"+d+\"'.\"),s.pollXhr=i.ajax(o,{xhrFields:{onprogress:function(){i.markLastMessage(o)}},url:d,type:\"POST\",contentType:r._.defaultContentType,data:b,timeout:o._.pollTimeout,success:function(r){var h,w=0,u,a;o.log(\"Long poll complete.\");l=0;try{h=o._parseResponse(r)}catch(b){i.handleParseFailure(s,r,b,y,s.pollXhr);return}(c.reconnectTimeoutId!==null&&p(s),h&&(u=i.maximizePersistentResponse(h)),i.processMessages(s,h,v),u&&n.type(u.LongPollDelay)===\"number\"&&(w=u.LongPollDelay),f(s)!==!0)&&(a=u&&u.ShouldReconnect,!a||i.ensureReconnectingState(s))&&(w>0?c.pollTimeoutId=t.setTimeout(function(){e(s,a)},w):e(s,a))},error:function(f,h){var v=r._.transportError(r.resources.longPollFailed,o.transport,f,s.pollXhr);if(t.clearTimeout(c.reconnectTimeoutId),c.reconnectTimeoutId=null,h===\"abort\"){o.log(\"Aborted xhr request.\");return}if(!y(v)){if(l++,o.state!==r.connectionState.reconnecting&&(o.log(\"An error occurred using longPolling. Status = \"+h+\".  Response = \"+f.responseText+\".\"),n(s).triggerHandler(u.onError,[v])),(o.state===r.connectionState.connected||o.state===r.connectionState.reconnecting)&&!i.verifyLastActive(o))return;if(!i.ensureReconnectingState(s))return;c.pollTimeoutId=t.setTimeout(function(){e(s,!0)},a.reconnectDelay)}}}),k&&h===!0&&(c.reconnectTimeoutId=t.setTimeout(function(){p(s)},Math.min(1e3*(Math.pow(2,l)-1),w))))})(o)},250)},lostConnection:function(n){n.pollXhr&&n.pollXhr.abort(\"lostConnection\")},send:function(n,t){i.ajaxSend(n,t)},stop:function(n){t.clearTimeout(n._.pollTimeoutId);t.clearTimeout(n._.reconnectTimeoutId);delete n._.pollTimeoutId;delete n._.reconnectTimeoutId;n.pollXhr&&(n.pollXhr.abort(),n.pollXhr=null,delete n.pollXhr)},abort:function(n,t){i.ajaxAbort(n,t)}}}(window.jQuery,window),function(n){function r(n){return n+e}function s(n,t,i){for(var f=n.length,u=[],r=0;r<f;r+=1)n.hasOwnProperty(r)&&(u[r]=t.call(i,n[r],r,n));return u}function h(t){return n.isFunction(t)?null:n.type(t)===\"undefined\"?null:t}function u(n){for(var t in n)if(n.hasOwnProperty(t))return!0;return!1}function f(n,t){var i=n._.invocationCallbacks,r,f;u(i)&&n.log(\"Clearing hub invocation callbacks with error: \"+t+\".\");n._.invocationCallbackId=0;delete n._.invocationCallbacks;n._.invocationCallbacks={};for(f in i)r=i[f],r.method.call(r.scope,{E:t})}function i(n,t){return new i.fn.init(n,t)}function t(i,r){var u={qs:null,logging:!1,useDefaultPath:!0};return n.extend(u,r),(!i||u.useDefaultPath)&&(i=(i||\"\")+\"/signalr\"),new t.fn.init(i,u)}var e=\".hubProxy\",o=n.signalR;i.fn=i.prototype={init:function(n,t){this.state={};this.connection=n;this.hubName=t;this._={callbackMap:{}}},constructor:i,hasSubscriptions:function(){return u(this._.callbackMap)},on:function(t,i){var u=this,f=u._.callbackMap;return t=t.toLowerCase(),f[t]||(f[t]={}),f[t][i]=function(n,t){i.apply(u,t)},n(u).bind(r(t),f[t][i]),u},off:function(t,i){var e=this,o=e._.callbackMap,f;return t=t.toLowerCase(),f=o[t],f&&(f[i]?(n(e).unbind(r(t),f[i]),delete f[i],u(f)||delete o[t]):i||(n(e).unbind(r(t)),delete o[t])),e},invoke:function(t){var i=this,r=i.connection,e=n.makeArray(arguments).slice(1),c=s(e,h),f={H:i.hubName,M:t,A:c,I:r._.invocationCallbackId},u=n.Deferred(),l=function(f){var e=i._maximizeHubResponse(f),h,s;n.extend(i.state,e.State);e.Progress?u.notifyWith?u.notifyWith(i,[e.Progress.Data]):r._.progressjQueryVersionLogged||(r.log(\"A hub method invocation progress update was received but the version of jQuery in use (\"+n.prototype.jquery+\") does not support progress updates. Upgrade to jQuery 1.7+ to receive progress notifications.\"),r._.progressjQueryVersionLogged=!0):e.Error?(e.StackTrace&&r.log(e.Error+\"\\n\"+e.StackTrace+\".\"),h=e.IsHubException?\"HubException\":\"Exception\",s=o._.error(e.Error,h),s.data=e.ErrorData,r.log(i.hubName+\".\"+t+\" failed to execute. Error: \"+s.message),u.rejectWith(i,[s])):(r.log(\"Invoked \"+i.hubName+\".\"+t),u.resolveWith(i,[e.Result]))};return r._.invocationCallbacks[r._.invocationCallbackId.toString()]={scope:i,method:l},r._.invocationCallbackId+=1,n.isEmptyObject(i.state)||(f.S=i.state),r.log(\"Invoking \"+i.hubName+\".\"+t),r.send(f),u.promise()},_maximizeHubResponse:function(n){return{State:n.S,Result:n.R,Progress:n.P?{Id:n.P.I,Data:n.P.D}:null,Id:n.I,IsHubException:n.H,Error:n.E,StackTrace:n.T,ErrorData:n.D}}};i.fn.init.prototype=i.fn;t.fn=t.prototype=n.connection();t.fn.init=function(t,i){var e={qs:null,logging:!1,useDefaultPath:!0},u=this;n.extend(e,i);n.signalR.fn.init.call(u,t,e.qs,e.logging);u.proxies={};u._.invocationCallbackId=0;u._.invocationCallbacks={};u.received(function(t){var f,o,e,i,s,h;t&&(typeof t.P!=\"undefined\"?(e=t.P.I.toString(),i=u._.invocationCallbacks[e],i&&i.method.call(i.scope,t)):typeof t.I!=\"undefined\"?(e=t.I.toString(),i=u._.invocationCallbacks[e],i&&(u._.invocationCallbacks[e]=null,delete u._.invocationCallbacks[e],i.method.call(i.scope,t))):(f=this._maximizeClientHubInvocation(t),u.log(\"Triggering client hub event '\"+f.Method+\"' on hub '\"+f.Hub+\"'.\"),s=f.Hub.toLowerCase(),h=f.Method.toLowerCase(),o=this.proxies[s],n.extend(o.state,f.State),n(o).triggerHandler(r(h),[f.Args])))});u.error(function(n,t){var i,r;t&&(i=t.I,r=u._.invocationCallbacks[i],r&&(u._.invocationCallbacks[i]=null,delete u._.invocationCallbacks[i],r.method.call(r.scope,{E:n})))});u.reconnecting(function(){u.transport&&u.transport.name===\"webSockets\"&&f(u,\"Connection started reconnecting before invocation result was received.\")});u.disconnected(function(){f(u,\"Connection was disconnected before invocation result was received.\")})};t.fn._maximizeClientHubInvocation=function(n){return{Hub:n.H,Method:n.M,Args:n.A,State:n.S}};t.fn._registerSubscribedHubs=function(){var t=this;t._subscribedToHubs||(t._subscribedToHubs=!0,t.starting(function(){var i=[];n.each(t.proxies,function(n){this.hasSubscriptions()&&(i.push({name:n}),t.log(\"Client subscribed to hub '\"+n+\"'.\"))});i.length===0&&t.log(\"No hubs have been subscribed to.  The client will not receive data from hubs.  To fix, declare at least one client side function prior to connection start for each hub you wish to subscribe to.\");t.data=t.json.stringify(i)}))};t.fn.createHubProxy=function(n){n=n.toLowerCase();var t=this.proxies[n];return t||(t=i(this,n),this.proxies[n]=t),this._registerSubscribedHubs(),t};t.fn.init.prototype=t.fn;n.hubConnection=t}(window.jQuery,window),function(n){n.signalR.version=\"2.2.0\"}(window.jQuery)","// Knockout JavaScript library v2.2.1\n// (c) Steven Sanderson - http://knockoutjs.com/\n// License: MIT (http://www.opensource.org/licenses/mit-license.php)\n\n(function(){\nvar DEBUG=true;\n(function(window,document,navigator,jQuery,undefined){\n!function(factory) {\n    factory(window['ko'] = {});\n}(function(koExports){\n// Internally, all KO objects are attached to koExports (even the non-exported ones whose names will be minified by the closure compiler).\n// In the future, the following \"ko\" variable may be made distinct from \"koExports\" so that private objects are not externally reachable.\nvar ko = typeof koExports !== 'undefined' ? koExports : {};\n// Google Closure Compiler helpers (used only to make the minified file smaller)\nko.exportSymbol = function(koPath, object) {\n\tvar tokens = koPath.split(\".\");\n\n\t// In the future, \"ko\" may become distinct from \"koExports\" (so that non-exported objects are not reachable)\n\t// At that point, \"target\" would be set to: (typeof koExports !== \"undefined\" ? koExports : ko)\n\tvar target = ko;\n\n\tfor (var i = 0; i < tokens.length - 1; i++)\n\t\ttarget = target[tokens[i]];\n\ttarget[tokens[tokens.length - 1]] = object;\n};\nko.exportProperty = function(owner, publicName, object) {\n  owner[publicName] = object;\n};\nko.version = \"2.2.1\";\n\nko.exportSymbol('version', ko.version);\nko.utils = new (function () {\n    var stringTrimRegex = /^(\\s|\\u00A0)+|(\\s|\\u00A0)+$/g;\n\n    // Represent the known event types in a compact way, then at runtime transform it into a hash with event name as key (for fast lookup)\n    var knownEvents = {}, knownEventTypesByEventName = {};\n    var keyEventTypeName = /Firefox\\/2/i.test(navigator.userAgent) ? 'KeyboardEvent' : 'UIEvents';\n    knownEvents[keyEventTypeName] = ['keyup', 'keydown', 'keypress'];\n    knownEvents['MouseEvents'] = ['click', 'dblclick', 'mousedown', 'mouseup', 'mousemove', 'mouseover', 'mouseout', 'mouseenter', 'mouseleave'];\n    for (var eventType in knownEvents) {\n        var knownEventsForType = knownEvents[eventType];\n        if (knownEventsForType.length) {\n            for (var i = 0, j = knownEventsForType.length; i < j; i++)\n                knownEventTypesByEventName[knownEventsForType[i]] = eventType;\n        }\n    }\n    var eventsThatMustBeRegisteredUsingAttachEvent = { 'propertychange': true }; // Workaround for an IE9 issue - https://github.com/SteveSanderson/knockout/issues/406\n\n    // Detect IE versions for bug workarounds (uses IE conditionals, not UA string, for robustness)\n    // Note that, since IE 10 does not support conditional comments, the following logic only detects IE < 10.\n    // Currently this is by design, since IE 10+ behaves correctly when treated as a standard browser.\n    // If there is a future need to detect specific versions of IE10+, we will amend this.\n    var ieVersion = (function() {\n        var version = 3, div = document.createElement('div'), iElems = div.getElementsByTagName('i');\n\n        // Keep constructing conditional HTML blocks until we hit one that resolves to an empty fragment\n        while (\n            div.innerHTML = '<!--[if gt IE ' + (++version) + ']><i></i><![endif]-->',\n            iElems[0]\n        );\n        return version > 4 ? version : undefined;\n    }());\n    var isIe6 = ieVersion === 6,\n        isIe7 = ieVersion === 7;\n\n    function isClickOnCheckableElement(element, eventType) {\n        if ((ko.utils.tagNameLower(element) !== \"input\") || !element.type) return false;\n        if (eventType.toLowerCase() != \"click\") return false;\n        var inputType = element.type;\n        return (inputType == \"checkbox\") || (inputType == \"radio\");\n    }\n\n    return {\n        fieldsIncludedWithJsonPost: ['authenticity_token', /^__RequestVerificationToken(_.*)?$/],\n\n        arrayForEach: function (array, action) {\n            for (var i = 0, j = array.length; i < j; i++)\n                action(array[i]);\n        },\n\n        arrayIndexOf: function (array, item) {\n            if (typeof Array.prototype.indexOf == \"function\")\n                return Array.prototype.indexOf.call(array, item);\n            for (var i = 0, j = array.length; i < j; i++)\n                if (array[i] === item)\n                    return i;\n            return -1;\n        },\n\n        arrayFirst: function (array, predicate, predicateOwner) {\n            for (var i = 0, j = array.length; i < j; i++)\n                if (predicate.call(predicateOwner, array[i]))\n                    return array[i];\n            return null;\n        },\n\n        arrayRemoveItem: function (array, itemToRemove) {\n            var index = ko.utils.arrayIndexOf(array, itemToRemove);\n            if (index >= 0)\n                array.splice(index, 1);\n        },\n\n        arrayGetDistinctValues: function (array) {\n            array = array || [];\n            var result = [];\n            for (var i = 0, j = array.length; i < j; i++) {\n                if (ko.utils.arrayIndexOf(result, array[i]) < 0)\n                    result.push(array[i]);\n            }\n            return result;\n        },\n\n        arrayMap: function (array, mapping) {\n            array = array || [];\n            var result = [];\n            for (var i = 0, j = array.length; i < j; i++)\n                result.push(mapping(array[i]));\n            return result;\n        },\n\n        arrayFilter: function (array, predicate) {\n            array = array || [];\n            var result = [];\n            for (var i = 0, j = array.length; i < j; i++)\n                if (predicate(array[i]))\n                    result.push(array[i]);\n            return result;\n        },\n\n        arrayPushAll: function (array, valuesToPush) {\n            if (valuesToPush instanceof Array)\n                array.push.apply(array, valuesToPush);\n            else\n                for (var i = 0, j = valuesToPush.length; i < j; i++)\n                    array.push(valuesToPush[i]);\n            return array;\n        },\n\n        extend: function (target, source) {\n            if (source) {\n                for(var prop in source) {\n                    if(source.hasOwnProperty(prop)) {\n                        target[prop] = source[prop];\n                    }\n                }\n            }\n            return target;\n        },\n\n        emptyDomNode: function (domNode) {\n            while (domNode.firstChild) {\n                ko.removeNode(domNode.firstChild);\n            }\n        },\n\n        moveCleanedNodesToContainerElement: function(nodes) {\n            // Ensure it's a real array, as we're about to reparent the nodes and\n            // we don't want the underlying collection to change while we're doing that.\n            var nodesArray = ko.utils.makeArray(nodes);\n\n            var container = document.createElement('div');\n            for (var i = 0, j = nodesArray.length; i < j; i++) {\n                container.appendChild(ko.cleanNode(nodesArray[i]));\n            }\n            return container;\n        },\n\n        cloneNodes: function (nodesArray, shouldCleanNodes) {\n            for (var i = 0, j = nodesArray.length, newNodesArray = []; i < j; i++) {\n                var clonedNode = nodesArray[i].cloneNode(true);\n                newNodesArray.push(shouldCleanNodes ? ko.cleanNode(clonedNode) : clonedNode);\n            }\n            return newNodesArray;\n        },\n\n        setDomNodeChildren: function (domNode, childNodes) {\n            ko.utils.emptyDomNode(domNode);\n            if (childNodes) {\n                for (var i = 0, j = childNodes.length; i < j; i++)\n                    domNode.appendChild(childNodes[i]);\n            }\n        },\n\n        replaceDomNodes: function (nodeToReplaceOrNodeArray, newNodesArray) {\n            var nodesToReplaceArray = nodeToReplaceOrNodeArray.nodeType ? [nodeToReplaceOrNodeArray] : nodeToReplaceOrNodeArray;\n            if (nodesToReplaceArray.length > 0) {\n                var insertionPoint = nodesToReplaceArray[0];\n                var parent = insertionPoint.parentNode;\n                for (var i = 0, j = newNodesArray.length; i < j; i++)\n                    parent.insertBefore(newNodesArray[i], insertionPoint);\n                for (var i = 0, j = nodesToReplaceArray.length; i < j; i++) {\n                    ko.removeNode(nodesToReplaceArray[i]);\n                }\n            }\n        },\n\n        setOptionNodeSelectionState: function (optionNode, isSelected) {\n            // IE6 sometimes throws \"unknown error\" if you try to write to .selected directly, whereas Firefox struggles with setAttribute. Pick one based on browser.\n            if (ieVersion < 7)\n                optionNode.setAttribute(\"selected\", isSelected);\n            else\n                optionNode.selected = isSelected;\n        },\n\n        stringTrim: function (string) {\n            return (string || \"\").replace(stringTrimRegex, \"\");\n        },\n\n        stringTokenize: function (string, delimiter) {\n            var result = [];\n            var tokens = (string || \"\").split(delimiter);\n            for (var i = 0, j = tokens.length; i < j; i++) {\n                var trimmed = ko.utils.stringTrim(tokens[i]);\n                if (trimmed !== \"\")\n                    result.push(trimmed);\n            }\n            return result;\n        },\n\n        stringStartsWith: function (string, startsWith) {\n            string = string || \"\";\n            if (startsWith.length > string.length)\n                return false;\n            return string.substring(0, startsWith.length) === startsWith;\n        },\n\n        domNodeIsContainedBy: function (node, containedByNode) {\n            if (containedByNode.compareDocumentPosition)\n                return (containedByNode.compareDocumentPosition(node) & 16) == 16;\n            while (node != null) {\n                if (node == containedByNode)\n                    return true;\n                node = node.parentNode;\n            }\n            return false;\n        },\n\n        domNodeIsAttachedToDocument: function (node) {\n            return ko.utils.domNodeIsContainedBy(node, node.ownerDocument);\n        },\n\n        tagNameLower: function(element) {\n            // For HTML elements, tagName will always be upper case; for XHTML elements, it'll be lower case.\n            // Possible future optimization: If we know it's an element from an XHTML document (not HTML),\n            // we don't need to do the .toLowerCase() as it will always be lower case anyway.\n            return element && element.tagName && element.tagName.toLowerCase();\n        },\n\n        registerEventHandler: function (element, eventType, handler) {\n            var mustUseAttachEvent = ieVersion && eventsThatMustBeRegisteredUsingAttachEvent[eventType];\n            if (!mustUseAttachEvent && typeof jQuery != \"undefined\") {\n                if (isClickOnCheckableElement(element, eventType)) {\n                    // For click events on checkboxes, jQuery interferes with the event handling in an awkward way:\n                    // it toggles the element checked state *after* the click event handlers run, whereas native\n                    // click events toggle the checked state *before* the event handler.\n                    // Fix this by intecepting the handler and applying the correct checkedness before it runs.\n                    var originalHandler = handler;\n                    handler = function(event, eventData) {\n                        var jQuerySuppliedCheckedState = this.checked;\n                        if (eventData)\n                            this.checked = eventData.checkedStateBeforeEvent !== true;\n                        originalHandler.call(this, event);\n                        this.checked = jQuerySuppliedCheckedState; // Restore the state jQuery applied\n                    };\n                }\n                jQuery(element)['bind'](eventType, handler);\n            } else if (!mustUseAttachEvent && typeof element.addEventListener == \"function\")\n                element.addEventListener(eventType, handler, false);\n            else if (typeof element.attachEvent != \"undefined\")\n                element.attachEvent(\"on\" + eventType, function (event) {\n                    handler.call(element, event);\n                });\n            else\n                throw new Error(\"Browser doesn't support addEventListener or attachEvent\");\n        },\n\n        triggerEvent: function (element, eventType) {\n            if (!(element && element.nodeType))\n                throw new Error(\"element must be a DOM node when calling triggerEvent\");\n\n            if (typeof jQuery != \"undefined\") {\n                var eventData = [];\n                if (isClickOnCheckableElement(element, eventType)) {\n                    // Work around the jQuery \"click events on checkboxes\" issue described above by storing the original checked state before triggering the handler\n                    eventData.push({ checkedStateBeforeEvent: element.checked });\n                }\n                jQuery(element)['trigger'](eventType, eventData);\n            } else if (typeof document.createEvent == \"function\") {\n                if (typeof element.dispatchEvent == \"function\") {\n                    var eventCategory = knownEventTypesByEventName[eventType] || \"HTMLEvents\";\n                    var event = document.createEvent(eventCategory);\n                    event.initEvent(eventType, true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, element);\n                    element.dispatchEvent(event);\n                }\n                else\n                    throw new Error(\"The supplied element doesn't support dispatchEvent\");\n            } else if (typeof element.fireEvent != \"undefined\") {\n                // Unlike other browsers, IE doesn't change the checked state of checkboxes/radiobuttons when you trigger their \"click\" event\n                // so to make it consistent, we'll do it manually here\n                if (isClickOnCheckableElement(element, eventType))\n                    element.checked = element.checked !== true;\n                element.fireEvent(\"on\" + eventType);\n            }\n            else\n                throw new Error(\"Browser doesn't support triggering events\");\n        },\n\n        unwrapObservable: function (value) {\n            return ko.isObservable(value) ? value() : value;\n        },\n\n        peekObservable: function (value) {\n            return ko.isObservable(value) ? value.peek() : value;\n        },\n\n        toggleDomNodeCssClass: function (node, classNames, shouldHaveClass) {\n            if (classNames) {\n                var cssClassNameRegex = /[\\w-]+/g,\n                    currentClassNames = node.className.match(cssClassNameRegex) || [];\n                ko.utils.arrayForEach(classNames.match(cssClassNameRegex), function(className) {\n                    var indexOfClass = ko.utils.arrayIndexOf(currentClassNames, className);\n                    if (indexOfClass >= 0) {\n                        if (!shouldHaveClass)\n                            currentClassNames.splice(indexOfClass, 1);\n                    } else {\n                        if (shouldHaveClass)\n                            currentClassNames.push(className);\n                    }\n                });\n                node.className = currentClassNames.join(\" \");\n            }\n        },\n\n        setTextContent: function(element, textContent) {\n            var value = ko.utils.unwrapObservable(textContent);\n            if ((value === null) || (value === undefined))\n                value = \"\";\n\n            if (element.nodeType === 3) {\n                element.data = value;\n            } else {\n                // We need there to be exactly one child: a text node.\n                // If there are no children, more than one, or if it's not a text node,\n                // we'll clear everything and create a single text node.\n                var innerTextNode = ko.virtualElements.firstChild(element);\n                if (!innerTextNode || innerTextNode.nodeType != 3 || ko.virtualElements.nextSibling(innerTextNode)) {\n                    ko.virtualElements.setDomNodeChildren(element, [document.createTextNode(value)]);\n                } else {\n                    innerTextNode.data = value;\n                }\n\n                ko.utils.forceRefresh(element);\n            }\n        },\n\n        setElementName: function(element, name) {\n            element.name = name;\n\n            // Workaround IE 6/7 issue\n            // - https://github.com/SteveSanderson/knockout/issues/197\n            // - http://www.matts411.com/post/setting_the_name_attribute_in_ie_dom/\n            if (ieVersion <= 7) {\n                try {\n                    element.mergeAttributes(document.createElement(\"<input name='\" + element.name + \"'/>\"), false);\n                }\n                catch(e) {} // For IE9 with doc mode \"IE9 Standards\" and browser mode \"IE9 Compatibility View\"\n            }\n        },\n\n        forceRefresh: function(node) {\n            // Workaround for an IE9 rendering bug - https://github.com/SteveSanderson/knockout/issues/209\n            if (ieVersion >= 9) {\n                // For text nodes and comment nodes (most likely virtual elements), we will have to refresh the container\n                var elem = node.nodeType == 1 ? node : node.parentNode;\n                if (elem.style)\n                    elem.style.zoom = elem.style.zoom;\n            }\n        },\n\n        ensureSelectElementIsRenderedCorrectly: function(selectElement) {\n            // Workaround for IE9 rendering bug - it doesn't reliably display all the text in dynamically-added select boxes unless you force it to re-render by updating the width.\n            // (See https://github.com/SteveSanderson/knockout/issues/312, http://stackoverflow.com/questions/5908494/select-only-shows-first-char-of-selected-option)\n            if (ieVersion >= 9) {\n                var originalWidth = selectElement.style.width;\n                selectElement.style.width = 0;\n                selectElement.style.width = originalWidth;\n            }\n        },\n\n        range: function (min, max) {\n            min = ko.utils.unwrapObservable(min);\n            max = ko.utils.unwrapObservable(max);\n            var result = [];\n            for (var i = min; i <= max; i++)\n                result.push(i);\n            return result;\n        },\n\n        makeArray: function(arrayLikeObject) {\n            var result = [];\n            for (var i = 0, j = arrayLikeObject.length; i < j; i++) {\n                result.push(arrayLikeObject[i]);\n            };\n            return result;\n        },\n\n        isIe6 : isIe6,\n        isIe7 : isIe7,\n        ieVersion : ieVersion,\n\n        getFormFields: function(form, fieldName) {\n            var fields = ko.utils.makeArray(form.getElementsByTagName(\"input\")).concat(ko.utils.makeArray(form.getElementsByTagName(\"textarea\")));\n            var isMatchingField = (typeof fieldName == 'string')\n                ? function(field) { return field.name === fieldName }\n                : function(field) { return fieldName.test(field.name) }; // Treat fieldName as regex or object containing predicate\n            var matches = [];\n            for (var i = fields.length - 1; i >= 0; i--) {\n                if (isMatchingField(fields[i]))\n                    matches.push(fields[i]);\n            };\n            return matches;\n        },\n\n        parseJson: function (jsonString) {\n            if (typeof jsonString == \"string\") {\n                jsonString = ko.utils.stringTrim(jsonString);\n                if (jsonString) {\n                    if (window.JSON && window.JSON.parse) // Use native parsing where available\n                        return window.JSON.parse(jsonString);\n                    return (new Function(\"return \" + jsonString))(); // Fallback on less safe parsing for older browsers\n                }\n            }\n            return null;\n        },\n\n        stringifyJson: function (data, replacer, space) {   // replacer and space are optional\n            if ((typeof JSON == \"undefined\") || (typeof JSON.stringify == \"undefined\"))\n                throw new Error(\"Cannot find JSON.stringify(). Some browsers (e.g., IE < 8) don't support it natively, but you can overcome this by adding a script reference to json2.js, downloadable from http://www.json.org/json2.js\");\n            return JSON.stringify(ko.utils.unwrapObservable(data), replacer, space);\n        },\n\n        postJson: function (urlOrForm, data, options) {\n            options = options || {};\n            var params = options['params'] || {};\n            var includeFields = options['includeFields'] || this.fieldsIncludedWithJsonPost;\n            var url = urlOrForm;\n\n            // If we were given a form, use its 'action' URL and pick out any requested field values\n            if((typeof urlOrForm == 'object') && (ko.utils.tagNameLower(urlOrForm) === \"form\")) {\n                var originalForm = urlOrForm;\n                url = originalForm.action;\n                for (var i = includeFields.length - 1; i >= 0; i--) {\n                    var fields = ko.utils.getFormFields(originalForm, includeFields[i]);\n                    for (var j = fields.length - 1; j >= 0; j--)\n                        params[fields[j].name] = fields[j].value;\n                }\n            }\n\n            data = ko.utils.unwrapObservable(data);\n            var form = document.createElement(\"form\");\n            form.style.display = \"none\";\n            form.action = url;\n            form.method = \"post\";\n            for (var key in data) {\n                var input = document.createElement(\"input\");\n                input.name = key;\n                input.value = ko.utils.stringifyJson(ko.utils.unwrapObservable(data[key]));\n                form.appendChild(input);\n            }\n            for (var key in params) {\n                var input = document.createElement(\"input\");\n                input.name = key;\n                input.value = params[key];\n                form.appendChild(input);\n            }\n            document.body.appendChild(form);\n            options['submitter'] ? options['submitter'](form) : form.submit();\n            setTimeout(function () { form.parentNode.removeChild(form); }, 0);\n        }\n    }\n})();\n\nko.exportSymbol('utils', ko.utils);\nko.exportSymbol('utils.arrayForEach', ko.utils.arrayForEach);\nko.exportSymbol('utils.arrayFirst', ko.utils.arrayFirst);\nko.exportSymbol('utils.arrayFilter', ko.utils.arrayFilter);\nko.exportSymbol('utils.arrayGetDistinctValues', ko.utils.arrayGetDistinctValues);\nko.exportSymbol('utils.arrayIndexOf', ko.utils.arrayIndexOf);\nko.exportSymbol('utils.arrayMap', ko.utils.arrayMap);\nko.exportSymbol('utils.arrayPushAll', ko.utils.arrayPushAll);\nko.exportSymbol('utils.arrayRemoveItem', ko.utils.arrayRemoveItem);\nko.exportSymbol('utils.extend', ko.utils.extend);\nko.exportSymbol('utils.fieldsIncludedWithJsonPost', ko.utils.fieldsIncludedWithJsonPost);\nko.exportSymbol('utils.getFormFields', ko.utils.getFormFields);\nko.exportSymbol('utils.peekObservable', ko.utils.peekObservable);\nko.exportSymbol('utils.postJson', ko.utils.postJson);\nko.exportSymbol('utils.parseJson', ko.utils.parseJson);\nko.exportSymbol('utils.registerEventHandler', ko.utils.registerEventHandler);\nko.exportSymbol('utils.stringifyJson', ko.utils.stringifyJson);\nko.exportSymbol('utils.range', ko.utils.range);\nko.exportSymbol('utils.toggleDomNodeCssClass', ko.utils.toggleDomNodeCssClass);\nko.exportSymbol('utils.triggerEvent', ko.utils.triggerEvent);\nko.exportSymbol('utils.unwrapObservable', ko.utils.unwrapObservable);\n\nif (!Function.prototype['bind']) {\n    // Function.prototype.bind is a standard part of ECMAScript 5th Edition (December 2009, http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf)\n    // In case the browser doesn't implement it natively, provide a JavaScript implementation. This implementation is based on the one in prototype.js\n    Function.prototype['bind'] = function (object) {\n        var originalFunction = this, args = Array.prototype.slice.call(arguments), object = args.shift();\n        return function () {\n            return originalFunction.apply(object, args.concat(Array.prototype.slice.call(arguments)));\n        };\n    };\n}\n\nko.utils.domData = new (function () {\n    var uniqueId = 0;\n    var dataStoreKeyExpandoPropertyName = \"__ko__\" + (new Date).getTime();\n    var dataStore = {};\n    return {\n        get: function (node, key) {\n            var allDataForNode = ko.utils.domData.getAll(node, false);\n            return allDataForNode === undefined ? undefined : allDataForNode[key];\n        },\n        set: function (node, key, value) {\n            if (value === undefined) {\n                // Make sure we don't actually create a new domData key if we are actually deleting a value\n                if (ko.utils.domData.getAll(node, false) === undefined)\n                    return;\n            }\n            var allDataForNode = ko.utils.domData.getAll(node, true);\n            allDataForNode[key] = value;\n        },\n        getAll: function (node, createIfNotFound) {\n            var dataStoreKey = node[dataStoreKeyExpandoPropertyName];\n            var hasExistingDataStore = dataStoreKey && (dataStoreKey !== \"null\") && dataStore[dataStoreKey];\n            if (!hasExistingDataStore) {\n                if (!createIfNotFound)\n                    return undefined;\n                dataStoreKey = node[dataStoreKeyExpandoPropertyName] = \"ko\" + uniqueId++;\n                dataStore[dataStoreKey] = {};\n            }\n            return dataStore[dataStoreKey];\n        },\n        clear: function (node) {\n            var dataStoreKey = node[dataStoreKeyExpandoPropertyName];\n            if (dataStoreKey) {\n                delete dataStore[dataStoreKey];\n                node[dataStoreKeyExpandoPropertyName] = null;\n                return true; // Exposing \"did clean\" flag purely so specs can infer whether things have been cleaned up as intended\n            }\n            return false;\n        }\n    }\n})();\n\nko.exportSymbol('utils.domData', ko.utils.domData);\nko.exportSymbol('utils.domData.clear', ko.utils.domData.clear); // Exporting only so specs can clear up after themselves fully\n\nko.utils.domNodeDisposal = new (function () {\n    var domDataKey = \"__ko_domNodeDisposal__\" + (new Date).getTime();\n    var cleanableNodeTypes = { 1: true, 8: true, 9: true };       // Element, Comment, Document\n    var cleanableNodeTypesWithDescendants = { 1: true, 9: true }; // Element, Document\n\n    function getDisposeCallbacksCollection(node, createIfNotFound) {\n        var allDisposeCallbacks = ko.utils.domData.get(node, domDataKey);\n        if ((allDisposeCallbacks === undefined) && createIfNotFound) {\n            allDisposeCallbacks = [];\n            ko.utils.domData.set(node, domDataKey, allDisposeCallbacks);\n        }\n        return allDisposeCallbacks;\n    }\n    function destroyCallbacksCollection(node) {\n        ko.utils.domData.set(node, domDataKey, undefined);\n    }\n\n    function cleanSingleNode(node) {\n        // Run all the dispose callbacks\n        var callbacks = getDisposeCallbacksCollection(node, false);\n        if (callbacks) {\n            callbacks = callbacks.slice(0); // Clone, as the array may be modified during iteration (typically, callbacks will remove themselves)\n            for (var i = 0; i < callbacks.length; i++)\n                callbacks[i](node);\n        }\n\n        // Also erase the DOM data\n        ko.utils.domData.clear(node);\n\n        // Special support for jQuery here because it's so commonly used.\n        // Many jQuery plugins (including jquery.tmpl) store data using jQuery's equivalent of domData\n        // so notify it to tear down any resources associated with the node & descendants here.\n        if ((typeof jQuery == \"function\") && (typeof jQuery['cleanData'] == \"function\"))\n            jQuery['cleanData']([node]);\n\n        // Also clear any immediate-child comment nodes, as these wouldn't have been found by\n        // node.getElementsByTagName(\"*\") in cleanNode() (comment nodes aren't elements)\n        if (cleanableNodeTypesWithDescendants[node.nodeType])\n            cleanImmediateCommentTypeChildren(node);\n    }\n\n    function cleanImmediateCommentTypeChildren(nodeWithChildren) {\n        var child, nextChild = nodeWithChildren.firstChild;\n        while (child = nextChild) {\n            nextChild = child.nextSibling;\n            if (child.nodeType === 8)\n                cleanSingleNode(child);\n        }\n    }\n\n    return {\n        addDisposeCallback : function(node, callback) {\n            if (typeof callback != \"function\")\n                throw new Error(\"Callback must be a function\");\n            getDisposeCallbacksCollection(node, true).push(callback);\n        },\n\n        removeDisposeCallback : function(node, callback) {\n            var callbacksCollection = getDisposeCallbacksCollection(node, false);\n            if (callbacksCollection) {\n                ko.utils.arrayRemoveItem(callbacksCollection, callback);\n                if (callbacksCollection.length == 0)\n                    destroyCallbacksCollection(node);\n            }\n        },\n\n        cleanNode : function(node) {\n            // First clean this node, where applicable\n            if (cleanableNodeTypes[node.nodeType]) {\n                cleanSingleNode(node);\n\n                // ... then its descendants, where applicable\n                if (cleanableNodeTypesWithDescendants[node.nodeType]) {\n                    // Clone the descendants list in case it changes during iteration\n                    var descendants = [];\n                    ko.utils.arrayPushAll(descendants, node.getElementsByTagName(\"*\"));\n                    for (var i = 0, j = descendants.length; i < j; i++)\n                        cleanSingleNode(descendants[i]);\n                }\n            }\n            return node;\n        },\n\n        removeNode : function(node) {\n            ko.cleanNode(node);\n            if (node.parentNode)\n                node.parentNode.removeChild(node);\n        }\n    }\n})();\nko.cleanNode = ko.utils.domNodeDisposal.cleanNode; // Shorthand name for convenience\nko.removeNode = ko.utils.domNodeDisposal.removeNode; // Shorthand name for convenience\nko.exportSymbol('cleanNode', ko.cleanNode);\nko.exportSymbol('removeNode', ko.removeNode);\nko.exportSymbol('utils.domNodeDisposal', ko.utils.domNodeDisposal);\nko.exportSymbol('utils.domNodeDisposal.addDisposeCallback', ko.utils.domNodeDisposal.addDisposeCallback);\nko.exportSymbol('utils.domNodeDisposal.removeDisposeCallback', ko.utils.domNodeDisposal.removeDisposeCallback);\n(function () {\n    var leadingCommentRegex = /^(\\s*)<!--(.*?)-->/;\n\n    function simpleHtmlParse(html) {\n        // Based on jQuery's \"clean\" function, but only accounting for table-related elements.\n        // If you have referenced jQuery, this won't be used anyway - KO will use jQuery's \"clean\" function directly\n\n        // Note that there's still an issue in IE < 9 whereby it will discard comment nodes that are the first child of\n        // a descendant node. For example: \"<div><!-- mycomment -->abc</div>\" will get parsed as \"<div>abc</div>\"\n        // This won't affect anyone who has referenced jQuery, and there's always the workaround of inserting a dummy node\n        // (possibly a text node) in front of the comment. So, KO does not attempt to workaround this IE issue automatically at present.\n\n        // Trim whitespace, otherwise indexOf won't work as expected\n        var tags = ko.utils.stringTrim(html).toLowerCase(), div = document.createElement(\"div\");\n\n        // Finds the first match from the left column, and returns the corresponding \"wrap\" data from the right column\n        var wrap = tags.match(/^<(thead|tbody|tfoot)/)              && [1, \"<table>\", \"</table>\"] ||\n                   !tags.indexOf(\"<tr\")                             && [2, \"<table><tbody>\", \"</tbody></table>\"] ||\n                   (!tags.indexOf(\"<td\") || !tags.indexOf(\"<th\"))   && [3, \"<table><tbody><tr>\", \"</tr></tbody></table>\"] ||\n                   /* anything else */                                 [0, \"\", \"\"];\n\n        // Go to html and back, then peel off extra wrappers\n        // Note that we always prefix with some dummy text, because otherwise, IE<9 will strip out leading comment nodes in descendants. Total madness.\n        var markup = \"ignored<div>\" + wrap[1] + html + wrap[2] + \"</div>\";\n        if (typeof window['innerShiv'] == \"function\") {\n            div.appendChild(window['innerShiv'](markup));\n        } else {\n            div.innerHTML = markup;\n        }\n\n        // Move to the right depth\n        while (wrap[0]--)\n            div = div.lastChild;\n\n        return ko.utils.makeArray(div.lastChild.childNodes);\n    }\n\n    function jQueryHtmlParse(html) {\n        // jQuery's \"parseHTML\" function was introduced in jQuery 1.8.0 and is a documented public API.\n        if (jQuery['parseHTML']) {\n            return jQuery['parseHTML'](html);\n        } else {\n            // For jQuery < 1.8.0, we fall back on the undocumented internal \"clean\" function.\n            var elems = jQuery['clean']([html]);\n\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.\n            // Unfortunately, it never clears the dummy parent nodes from the document fragment, so it leaks memory over time.\n            // Fix this by finding the top-most dummy parent element, and detaching it from its owner fragment.\n            if (elems && elems[0]) {\n                // Find the top-most parent element that's a direct child of a document fragment\n                var elem = elems[0];\n                while (elem.parentNode && elem.parentNode.nodeType !== 11 /* i.e., DocumentFragment */)\n                    elem = elem.parentNode;\n                // ... then detach it\n                if (elem.parentNode)\n                    elem.parentNode.removeChild(elem);\n            }\n\n            return elems;\n        }\n    }\n\n    ko.utils.parseHtmlFragment = function(html) {\n        return typeof jQuery != 'undefined' ? jQueryHtmlParse(html)   // As below, benefit from jQuery's optimisations where possible\n                                            : simpleHtmlParse(html);  // ... otherwise, this simple logic will do in most common cases.\n    };\n\n    ko.utils.setHtml = function(node, html) {\n        ko.utils.emptyDomNode(node);\n\n        // There's no legitimate reason to display a stringified observable without unwrapping it, so we'll unwrap it\n        html = ko.utils.unwrapObservable(html);\n\n        if ((html !== null) && (html !== undefined)) {\n            if (typeof html != 'string')\n                html = html.toString();\n\n            // jQuery contains a lot of sophisticated code to parse arbitrary HTML fragments,\n            // for example <tr> elements which are not normally allowed to exist on their own.\n            // If you've referenced jQuery we'll use that rather than duplicating its code.\n            if (typeof jQuery != 'undefined') {\n                jQuery(node)['html'](html);\n            } else {\n                // ... otherwise, use KO's own parsing logic.\n                var parsedNodes = ko.utils.parseHtmlFragment(html);\n                for (var i = 0; i < parsedNodes.length; i++)\n                    node.appendChild(parsedNodes[i]);\n            }\n        }\n    };\n})();\n\nko.exportSymbol('utils.parseHtmlFragment', ko.utils.parseHtmlFragment);\nko.exportSymbol('utils.setHtml', ko.utils.setHtml);\n\nko.memoization = (function () {\n    var memos = {};\n\n    function randomMax8HexChars() {\n        return (((1 + Math.random()) * 0x100000000) | 0).toString(16).substring(1);\n    }\n    function generateRandomId() {\n        return randomMax8HexChars() + randomMax8HexChars();\n    }\n    function findMemoNodes(rootNode, appendToArray) {\n        if (!rootNode)\n            return;\n        if (rootNode.nodeType == 8) {\n            var memoId = ko.memoization.parseMemoText(rootNode.nodeValue);\n            if (memoId != null)\n                appendToArray.push({ domNode: rootNode, memoId: memoId });\n        } else if (rootNode.nodeType == 1) {\n            for (var i = 0, childNodes = rootNode.childNodes, j = childNodes.length; i < j; i++)\n                findMemoNodes(childNodes[i], appendToArray);\n        }\n    }\n\n    return {\n        memoize: function (callback) {\n            if (typeof callback != \"function\")\n                throw new Error(\"You can only pass a function to ko.memoization.memoize()\");\n            var memoId = generateRandomId();\n            memos[memoId] = callback;\n            return \"<!--[ko_memo:\" + memoId + \"]-->\";\n        },\n\n        unmemoize: function (memoId, callbackParams) {\n            var callback = memos[memoId];\n            if (callback === undefined)\n                throw new Error(\"Couldn't find any memo with ID \" + memoId + \". Perhaps it's already been unmemoized.\");\n            try {\n                callback.apply(null, callbackParams || []);\n                return true;\n            }\n            finally { delete memos[memoId]; }\n        },\n\n        unmemoizeDomNodeAndDescendants: function (domNode, extraCallbackParamsArray) {\n            var memos = [];\n            findMemoNodes(domNode, memos);\n            for (var i = 0, j = memos.length; i < j; i++) {\n                var node = memos[i].domNode;\n                var combinedParams = [node];\n                if (extraCallbackParamsArray)\n                    ko.utils.arrayPushAll(combinedParams, extraCallbackParamsArray);\n                ko.memoization.unmemoize(memos[i].memoId, combinedParams);\n                node.nodeValue = \"\"; // Neuter this node so we don't try to unmemoize it again\n                if (node.parentNode)\n                    node.parentNode.removeChild(node); // If possible, erase it totally (not always possible - someone else might just hold a reference to it then call unmemoizeDomNodeAndDescendants again)\n            }\n        },\n\n        parseMemoText: function (memoText) {\n            var match = memoText.match(/^\\[ko_memo\\:(.*?)\\]$/);\n            return match ? match[1] : null;\n        }\n    };\n})();\n\nko.exportSymbol('memoization', ko.memoization);\nko.exportSymbol('memoization.memoize', ko.memoization.memoize);\nko.exportSymbol('memoization.unmemoize', ko.memoization.unmemoize);\nko.exportSymbol('memoization.parseMemoText', ko.memoization.parseMemoText);\nko.exportSymbol('memoization.unmemoizeDomNodeAndDescendants', ko.memoization.unmemoizeDomNodeAndDescendants);\nko.extenders = {\n    'throttle': function(target, timeout) {\n        // Throttling means two things:\n\n        // (1) For dependent observables, we throttle *evaluations* so that, no matter how fast its dependencies\n        //     notify updates, the target doesn't re-evaluate (and hence doesn't notify) faster than a certain rate\n        target['throttleEvaluation'] = timeout;\n\n        // (2) For writable targets (observables, or writable dependent observables), we throttle *writes*\n        //     so the target cannot change value synchronously or faster than a certain rate\n        var writeTimeoutInstance = null;\n        return ko.dependentObservable({\n            'read': target,\n            'write': function(value) {\n                clearTimeout(writeTimeoutInstance);\n                writeTimeoutInstance = setTimeout(function() {\n                    target(value);\n                }, timeout);\n            }\n        });\n    },\n\n    'notify': function(target, notifyWhen) {\n        target[\"equalityComparer\"] = notifyWhen == \"always\"\n            ? function() { return false } // Treat all values as not equal\n            : ko.observable[\"fn\"][\"equalityComparer\"];\n        return target;\n    }\n};\n\nfunction applyExtenders(requestedExtenders) {\n    var target = this;\n    if (requestedExtenders) {\n        for (var key in requestedExtenders) {\n            var extenderHandler = ko.extenders[key];\n            if (typeof extenderHandler == 'function') {\n                target = extenderHandler(target, requestedExtenders[key]);\n            }\n        }\n    }\n    return target;\n}\n\nko.exportSymbol('extenders', ko.extenders);\n\nko.subscription = function (target, callback, disposeCallback) {\n    this.target = target;\n    this.callback = callback;\n    this.disposeCallback = disposeCallback;\n    ko.exportProperty(this, 'dispose', this.dispose);\n};\nko.subscription.prototype.dispose = function () {\n    this.isDisposed = true;\n    this.disposeCallback();\n};\n\nko.subscribable = function () {\n    this._subscriptions = {};\n\n    ko.utils.extend(this, ko.subscribable['fn']);\n    ko.exportProperty(this, 'subscribe', this.subscribe);\n    ko.exportProperty(this, 'extend', this.extend);\n    ko.exportProperty(this, 'getSubscriptionsCount', this.getSubscriptionsCount);\n}\n\nvar defaultEvent = \"change\";\n\nko.subscribable['fn'] = {\n    subscribe: function (callback, callbackTarget, event) {\n        event = event || defaultEvent;\n        var boundCallback = callbackTarget ? callback.bind(callbackTarget) : callback;\n\n        var subscription = new ko.subscription(this, boundCallback, function () {\n            ko.utils.arrayRemoveItem(this._subscriptions[event], subscription);\n        }.bind(this));\n\n        if (!this._subscriptions[event])\n            this._subscriptions[event] = [];\n        this._subscriptions[event].push(subscription);\n        return subscription;\n    },\n\n    \"notifySubscribers\": function (valueToNotify, event) {\n        event = event || defaultEvent;\n        if (this._subscriptions[event]) {\n            ko.dependencyDetection.ignore(function() {\n                ko.utils.arrayForEach(this._subscriptions[event].slice(0), function (subscription) {\n                    // In case a subscription was disposed during the arrayForEach cycle, check\n                    // for isDisposed on each subscription before invoking its callback\n                    if (subscription && (subscription.isDisposed !== true))\n                        subscription.callback(valueToNotify);\n                });\n            }, this);\n        }\n    },\n\n    getSubscriptionsCount: function () {\n        var total = 0;\n        for (var eventName in this._subscriptions) {\n            if (this._subscriptions.hasOwnProperty(eventName))\n                total += this._subscriptions[eventName].length;\n        }\n        return total;\n    },\n\n    extend: applyExtenders\n};\n\n\nko.isSubscribable = function (instance) {\n    return typeof instance.subscribe == \"function\" && typeof instance[\"notifySubscribers\"] == \"function\";\n};\n\nko.exportSymbol('subscribable', ko.subscribable);\nko.exportSymbol('isSubscribable', ko.isSubscribable);\n\nko.dependencyDetection = (function () {\n    var _frames = [];\n\n    return {\n        begin: function (callback) {\n            _frames.push({ callback: callback, distinctDependencies:[] });\n        },\n\n        end: function () {\n            _frames.pop();\n        },\n\n        registerDependency: function (subscribable) {\n            if (!ko.isSubscribable(subscribable))\n                throw new Error(\"Only subscribable things can act as dependencies\");\n            if (_frames.length > 0) {\n                var topFrame = _frames[_frames.length - 1];\n                if (!topFrame || ko.utils.arrayIndexOf(topFrame.distinctDependencies, subscribable) >= 0)\n                    return;\n                topFrame.distinctDependencies.push(subscribable);\n                topFrame.callback(subscribable);\n            }\n        },\n\n        ignore: function(callback, callbackTarget, callbackArgs) {\n            try {\n                _frames.push(null);\n                return callback.apply(callbackTarget, callbackArgs || []);\n            } finally {\n                _frames.pop();\n            }\n        }\n    };\n})();\nvar primitiveTypes = { 'undefined':true, 'boolean':true, 'number':true, 'string':true };\n\nko.observable = function (initialValue) {\n    var _latestValue = initialValue;\n\n    function observable() {\n        if (arguments.length > 0) {\n            // Write\n\n            // Ignore writes if the value hasn't changed\n            if ((!observable['equalityComparer']) || !observable['equalityComparer'](_latestValue, arguments[0])) {\n                observable.valueWillMutate();\n                _latestValue = arguments[0];\n                if (DEBUG) observable._latestValue = _latestValue;\n                observable.valueHasMutated();\n            }\n            return this; // Permits chained assignments\n        }\n        else {\n            // Read\n            ko.dependencyDetection.registerDependency(observable); // The caller only needs to be notified of changes if they did a \"read\" operation\n            return _latestValue;\n        }\n    }\n    if (DEBUG) observable._latestValue = _latestValue;\n    ko.subscribable.call(observable);\n    observable.peek = function() { return _latestValue };\n    observable.valueHasMutated = function () { observable[\"notifySubscribers\"](_latestValue); }\n    observable.valueWillMutate = function () { observable[\"notifySubscribers\"](_latestValue, \"beforeChange\"); }\n    ko.utils.extend(observable, ko.observable['fn']);\n\n    ko.exportProperty(observable, 'peek', observable.peek);\n    ko.exportProperty(observable, \"valueHasMutated\", observable.valueHasMutated);\n    ko.exportProperty(observable, \"valueWillMutate\", observable.valueWillMutate);\n\n    return observable;\n}\n\nko.observable['fn'] = {\n    \"equalityComparer\": function valuesArePrimitiveAndEqual(a, b) {\n        var oldValueIsPrimitive = (a === null) || (typeof(a) in primitiveTypes);\n        return oldValueIsPrimitive ? (a === b) : false;\n    }\n};\n\nvar protoProperty = ko.observable.protoProperty = \"__ko_proto__\";\nko.observable['fn'][protoProperty] = ko.observable;\n\nko.hasPrototype = function(instance, prototype) {\n    if ((instance === null) || (instance === undefined) || (instance[protoProperty] === undefined)) return false;\n    if (instance[protoProperty] === prototype) return true;\n    return ko.hasPrototype(instance[protoProperty], prototype); // Walk the prototype chain\n};\n\nko.isObservable = function (instance) {\n    return ko.hasPrototype(instance, ko.observable);\n}\nko.isWriteableObservable = function (instance) {\n    // Observable\n    if ((typeof instance == \"function\") && instance[protoProperty] === ko.observable)\n        return true;\n    // Writeable dependent observable\n    if ((typeof instance == \"function\") && (instance[protoProperty] === ko.dependentObservable) && (instance.hasWriteFunction))\n        return true;\n    // Anything else\n    return false;\n}\n\n\nko.exportSymbol('observable', ko.observable);\nko.exportSymbol('isObservable', ko.isObservable);\nko.exportSymbol('isWriteableObservable', ko.isWriteableObservable);\nko.observableArray = function (initialValues) {\n    if (arguments.length == 0) {\n        // Zero-parameter constructor initializes to empty array\n        initialValues = [];\n    }\n    if ((initialValues !== null) && (initialValues !== undefined) && !('length' in initialValues))\n        throw new Error(\"The argument passed when initializing an observable array must be an array, or null, or undefined.\");\n\n    var result = ko.observable(initialValues);\n    ko.utils.extend(result, ko.observableArray['fn']);\n    return result;\n}\n\nko.observableArray['fn'] = {\n    'remove': function (valueOrPredicate) {\n        var underlyingArray = this.peek();\n        var removedValues = [];\n        var predicate = typeof valueOrPredicate == \"function\" ? valueOrPredicate : function (value) { return value === valueOrPredicate; };\n        for (var i = 0; i < underlyingArray.length; i++) {\n            var value = underlyingArray[i];\n            if (predicate(value)) {\n                if (removedValues.length === 0) {\n                    this.valueWillMutate();\n                }\n                removedValues.push(value);\n                underlyingArray.splice(i, 1);\n                i--;\n            }\n        }\n        if (removedValues.length) {\n            this.valueHasMutated();\n        }\n        return removedValues;\n    },\n\n    'removeAll': function (arrayOfValues) {\n        // If you passed zero args, we remove everything\n        if (arrayOfValues === undefined) {\n            var underlyingArray = this.peek();\n            var allValues = underlyingArray.slice(0);\n            this.valueWillMutate();\n            underlyingArray.splice(0, underlyingArray.length);\n            this.valueHasMutated();\n            return allValues;\n        }\n        // If you passed an arg, we interpret it as an array of entries to remove\n        if (!arrayOfValues)\n            return [];\n        return this['remove'](function (value) {\n            return ko.utils.arrayIndexOf(arrayOfValues, value) >= 0;\n        });\n    },\n\n    'destroy': function (valueOrPredicate) {\n        var underlyingArray = this.peek();\n        var predicate = typeof valueOrPredicate == \"function\" ? valueOrPredicate : function (value) { return value === valueOrPredicate; };\n        this.valueWillMutate();\n        for (var i = underlyingArray.length - 1; i >= 0; i--) {\n            var value = underlyingArray[i];\n            if (predicate(value))\n                underlyingArray[i][\"_destroy\"] = true;\n        }\n        this.valueHasMutated();\n    },\n\n    'destroyAll': function (arrayOfValues) {\n        // If you passed zero args, we destroy everything\n        if (arrayOfValues === undefined)\n            return this['destroy'](function() { return true });\n\n        // If you passed an arg, we interpret it as an array of entries to destroy\n        if (!arrayOfValues)\n            return [];\n        return this['destroy'](function (value) {\n            return ko.utils.arrayIndexOf(arrayOfValues, value) >= 0;\n        });\n    },\n\n    'indexOf': function (item) {\n        var underlyingArray = this();\n        return ko.utils.arrayIndexOf(underlyingArray, item);\n    },\n\n    'replace': function(oldItem, newItem) {\n        var index = this['indexOf'](oldItem);\n        if (index >= 0) {\n            this.valueWillMutate();\n            this.peek()[index] = newItem;\n            this.valueHasMutated();\n        }\n    }\n}\n\n// Populate ko.observableArray.fn with read/write functions from native arrays\n// Important: Do not add any additional functions here that may reasonably be used to *read* data from the array\n// because we'll eval them without causing subscriptions, so ko.computed output could end up getting stale\nko.utils.arrayForEach([\"pop\", \"push\", \"reverse\", \"shift\", \"sort\", \"splice\", \"unshift\"], function (methodName) {\n    ko.observableArray['fn'][methodName] = function () {\n        // Use \"peek\" to avoid creating a subscription in any computed that we're executing in the context of\n        // (for consistency with mutating regular observables)\n        var underlyingArray = this.peek();\n        this.valueWillMutate();\n        var methodCallResult = underlyingArray[methodName].apply(underlyingArray, arguments);\n        this.valueHasMutated();\n        return methodCallResult;\n    };\n});\n\n// Populate ko.observableArray.fn with read-only functions from native arrays\nko.utils.arrayForEach([\"slice\"], function (methodName) {\n    ko.observableArray['fn'][methodName] = function () {\n        var underlyingArray = this();\n        return underlyingArray[methodName].apply(underlyingArray, arguments);\n    };\n});\n\nko.exportSymbol('observableArray', ko.observableArray);\nko.dependentObservable = function (evaluatorFunctionOrOptions, evaluatorFunctionTarget, options) {\n    var _latestValue,\n        _hasBeenEvaluated = false,\n        _isBeingEvaluated = false,\n        readFunction = evaluatorFunctionOrOptions;\n\n    if (readFunction && typeof readFunction == \"object\") {\n        // Single-parameter syntax - everything is on this \"options\" param\n        options = readFunction;\n        readFunction = options[\"read\"];\n    } else {\n        // Multi-parameter syntax - construct the options according to the params passed\n        options = options || {};\n        if (!readFunction)\n            readFunction = options[\"read\"];\n    }\n    if (typeof readFunction != \"function\")\n        throw new Error(\"Pass a function that returns the value of the ko.computed\");\n\n    function addSubscriptionToDependency(subscribable) {\n        _subscriptionsToDependencies.push(subscribable.subscribe(evaluatePossiblyAsync));\n    }\n\n    function disposeAllSubscriptionsToDependencies() {\n        ko.utils.arrayForEach(_subscriptionsToDependencies, function (subscription) {\n            subscription.dispose();\n        });\n        _subscriptionsToDependencies = [];\n    }\n\n    function evaluatePossiblyAsync() {\n        var throttleEvaluationTimeout = dependentObservable['throttleEvaluation'];\n        if (throttleEvaluationTimeout && throttleEvaluationTimeout >= 0) {\n            clearTimeout(evaluationTimeoutInstance);\n            evaluationTimeoutInstance = setTimeout(evaluateImmediate, throttleEvaluationTimeout);\n        } else\n            evaluateImmediate();\n    }\n\n    function evaluateImmediate() {\n        if (_isBeingEvaluated) {\n            // If the evaluation of a ko.computed causes side effects, it's possible that it will trigger its own re-evaluation.\n            // This is not desirable (it's hard for a developer to realise a chain of dependencies might cause this, and they almost\n            // certainly didn't intend infinite re-evaluations). So, for predictability, we simply prevent ko.computeds from causing\n            // their own re-evaluation. Further discussion at https://github.com/SteveSanderson/knockout/pull/387\n            return;\n        }\n\n        // Don't dispose on first evaluation, because the \"disposeWhen\" callback might\n        // e.g., dispose when the associated DOM element isn't in the doc, and it's not\n        // going to be in the doc until *after* the first evaluation\n        if (_hasBeenEvaluated && disposeWhen()) {\n            dispose();\n            return;\n        }\n\n        _isBeingEvaluated = true;\n        try {\n            // Initially, we assume that none of the subscriptions are still being used (i.e., all are candidates for disposal).\n            // Then, during evaluation, we cross off any that are in fact still being used.\n            var disposalCandidates = ko.utils.arrayMap(_subscriptionsToDependencies, function(item) {return item.target;});\n\n            ko.dependencyDetection.begin(function(subscribable) {\n                var inOld;\n                if ((inOld = ko.utils.arrayIndexOf(disposalCandidates, subscribable)) >= 0)\n                    disposalCandidates[inOld] = undefined; // Don't want to dispose this subscription, as it's still being used\n                else\n                    addSubscriptionToDependency(subscribable); // Brand new subscription - add it\n            });\n\n            var newValue = readFunction.call(evaluatorFunctionTarget);\n\n            // For each subscription no longer being used, remove it from the active subscriptions list and dispose it\n            for (var i = disposalCandidates.length - 1; i >= 0; i--) {\n                if (disposalCandidates[i])\n                    _subscriptionsToDependencies.splice(i, 1)[0].dispose();\n            }\n            _hasBeenEvaluated = true;\n\n            dependentObservable[\"notifySubscribers\"](_latestValue, \"beforeChange\");\n            _latestValue = newValue;\n            if (DEBUG) dependentObservable._latestValue = _latestValue;\n        } finally {\n            ko.dependencyDetection.end();\n        }\n\n        dependentObservable[\"notifySubscribers\"](_latestValue);\n        _isBeingEvaluated = false;\n        if (!_subscriptionsToDependencies.length)\n            dispose();\n    }\n\n    function dependentObservable() {\n        if (arguments.length > 0) {\n            if (typeof writeFunction === \"function\") {\n                // Writing a value\n                writeFunction.apply(evaluatorFunctionTarget, arguments);\n            } else {\n                throw new Error(\"Cannot write a value to a ko.computed unless you specify a 'write' option. If you wish to read the current value, don't pass any parameters.\");\n            }\n            return this; // Permits chained assignments\n        } else {\n            // Reading the value\n            if (!_hasBeenEvaluated)\n                evaluateImmediate();\n            ko.dependencyDetection.registerDependency(dependentObservable);\n            return _latestValue;\n        }\n    }\n\n    function peek() {\n        if (!_hasBeenEvaluated)\n            evaluateImmediate();\n        return _latestValue;\n    }\n\n    function isActive() {\n        return !_hasBeenEvaluated || _subscriptionsToDependencies.length > 0;\n    }\n\n    // By here, \"options\" is always non-null\n    var writeFunction = options[\"write\"],\n        disposeWhenNodeIsRemoved = options[\"disposeWhenNodeIsRemoved\"] || options.disposeWhenNodeIsRemoved || null,\n        disposeWhen = options[\"disposeWhen\"] || options.disposeWhen || function() { return false; },\n        dispose = disposeAllSubscriptionsToDependencies,\n        _subscriptionsToDependencies = [],\n        evaluationTimeoutInstance = null;\n\n    if (!evaluatorFunctionTarget)\n        evaluatorFunctionTarget = options[\"owner\"];\n\n    dependentObservable.peek = peek;\n    dependentObservable.getDependenciesCount = function () { return _subscriptionsToDependencies.length; };\n    dependentObservable.hasWriteFunction = typeof options[\"write\"] === \"function\";\n    dependentObservable.dispose = function () { dispose(); };\n    dependentObservable.isActive = isActive;\n\n    ko.subscribable.call(dependentObservable);\n    ko.utils.extend(dependentObservable, ko.dependentObservable['fn']);\n\n    ko.exportProperty(dependentObservable, 'peek', dependentObservable.peek);\n    ko.exportProperty(dependentObservable, 'dispose', dependentObservable.dispose);\n    ko.exportProperty(dependentObservable, 'isActive', dependentObservable.isActive);\n    ko.exportProperty(dependentObservable, 'getDependenciesCount', dependentObservable.getDependenciesCount);\n\n    // Evaluate, unless deferEvaluation is true\n    if (options['deferEvaluation'] !== true)\n        evaluateImmediate();\n\n    // Build \"disposeWhenNodeIsRemoved\" and \"disposeWhenNodeIsRemovedCallback\" option values.\n    // But skip if isActive is false (there will never be any dependencies to dispose).\n    // (Note: \"disposeWhenNodeIsRemoved\" option both proactively disposes as soon as the node is removed using ko.removeNode(),\n    // plus adds a \"disposeWhen\" callback that, on each evaluation, disposes if the node was removed by some other means.)\n    if (disposeWhenNodeIsRemoved && isActive()) {\n        dispose = function() {\n            ko.utils.domNodeDisposal.removeDisposeCallback(disposeWhenNodeIsRemoved, arguments.callee);\n            disposeAllSubscriptionsToDependencies();\n        };\n        ko.utils.domNodeDisposal.addDisposeCallback(disposeWhenNodeIsRemoved, dispose);\n        var existingDisposeWhenFunction = disposeWhen;\n        disposeWhen = function () {\n            return !ko.utils.domNodeIsAttachedToDocument(disposeWhenNodeIsRemoved) || existingDisposeWhenFunction();\n        }\n    }\n\n    return dependentObservable;\n};\n\nko.isComputed = function(instance) {\n    return ko.hasPrototype(instance, ko.dependentObservable);\n};\n\nvar protoProp = ko.observable.protoProperty; // == \"__ko_proto__\"\nko.dependentObservable[protoProp] = ko.observable;\n\nko.dependentObservable['fn'] = {};\nko.dependentObservable['fn'][protoProp] = ko.dependentObservable;\n\nko.exportSymbol('dependentObservable', ko.dependentObservable);\nko.exportSymbol('computed', ko.dependentObservable); // Make \"ko.computed\" an alias for \"ko.dependentObservable\"\nko.exportSymbol('isComputed', ko.isComputed);\n\n(function() {\n    var maxNestedObservableDepth = 10; // Escape the (unlikely) pathalogical case where an observable's current value is itself (or similar reference cycle)\n\n    ko.toJS = function(rootObject) {\n        if (arguments.length == 0)\n            throw new Error(\"When calling ko.toJS, pass the object you want to convert.\");\n\n        // We just unwrap everything at every level in the object graph\n        return mapJsObjectGraph(rootObject, function(valueToMap) {\n            // Loop because an observable's value might in turn be another observable wrapper\n            for (var i = 0; ko.isObservable(valueToMap) && (i < maxNestedObservableDepth); i++)\n                valueToMap = valueToMap();\n            return valueToMap;\n        });\n    };\n\n    ko.toJSON = function(rootObject, replacer, space) {     // replacer and space are optional\n        var plainJavaScriptObject = ko.toJS(rootObject);\n        return ko.utils.stringifyJson(plainJavaScriptObject, replacer, space);\n    };\n\n    function mapJsObjectGraph(rootObject, mapInputCallback, visitedObjects) {\n        visitedObjects = visitedObjects || new objectLookup();\n\n        rootObject = mapInputCallback(rootObject);\n        var canHaveProperties = (typeof rootObject == \"object\") && (rootObject !== null) && (rootObject !== undefined) && (!(rootObject instanceof Date));\n        if (!canHaveProperties)\n            return rootObject;\n\n        var outputProperties = rootObject instanceof Array ? [] : {};\n        visitedObjects.save(rootObject, outputProperties);\n\n        visitPropertiesOrArrayEntries(rootObject, function(indexer) {\n            var propertyValue = mapInputCallback(rootObject[indexer]);\n\n            switch (typeof propertyValue) {\n                case \"boolean\":\n                case \"number\":\n                case \"string\":\n                case \"function\":\n                    outputProperties[indexer] = propertyValue;\n                    break;\n                case \"object\":\n                case \"undefined\":\n                    var previouslyMappedValue = visitedObjects.get(propertyValue);\n                    outputProperties[indexer] = (previouslyMappedValue !== undefined)\n                        ? previouslyMappedValue\n                        : mapJsObjectGraph(propertyValue, mapInputCallback, visitedObjects);\n                    break;\n            }\n        });\n\n        return outputProperties;\n    }\n\n    function visitPropertiesOrArrayEntries(rootObject, visitorCallback) {\n        if (rootObject instanceof Array) {\n            for (var i = 0; i < rootObject.length; i++)\n                visitorCallback(i);\n\n            // For arrays, also respect toJSON property for custom mappings (fixes #278)\n            if (typeof rootObject['toJSON'] == 'function')\n                visitorCallback('toJSON');\n        } else {\n            for (var propertyName in rootObject)\n                visitorCallback(propertyName);\n        }\n    };\n\n    function objectLookup() {\n        var keys = [];\n        var values = [];\n        this.save = function(key, value) {\n            var existingIndex = ko.utils.arrayIndexOf(keys, key);\n            if (existingIndex >= 0)\n                values[existingIndex] = value;\n            else {\n                keys.push(key);\n                values.push(value);\n            }\n        };\n        this.get = function(key) {\n            var existingIndex = ko.utils.arrayIndexOf(keys, key);\n            return (existingIndex >= 0) ? values[existingIndex] : undefined;\n        };\n    };\n})();\n\nko.exportSymbol('toJS', ko.toJS);\nko.exportSymbol('toJSON', ko.toJSON);\n(function () {\n    var hasDomDataExpandoProperty = '__ko__hasDomDataOptionValue__';\n\n    // Normally, SELECT elements and their OPTIONs can only take value of type 'string' (because the values\n    // are stored on DOM attributes). ko.selectExtensions provides a way for SELECTs/OPTIONs to have values\n    // that are arbitrary objects. This is very convenient when implementing things like cascading dropdowns.\n    ko.selectExtensions = {\n        readValue : function(element) {\n            switch (ko.utils.tagNameLower(element)) {\n                case 'option':\n                    if (element[hasDomDataExpandoProperty] === true)\n                        return ko.utils.domData.get(element, ko.bindingHandlers.options.optionValueDomDataKey);\n                    return ko.utils.ieVersion <= 7\n                        ? (element.getAttributeNode('value').specified ? element.value : element.text)\n                        : element.value;\n                case 'select':\n                    return element.selectedIndex >= 0 ? ko.selectExtensions.readValue(element.options[element.selectedIndex]) : undefined;\n                default:\n                    return element.value;\n            }\n        },\n\n        writeValue: function(element, value) {\n            switch (ko.utils.tagNameLower(element)) {\n                case 'option':\n                    switch(typeof value) {\n                        case \"string\":\n                            ko.utils.domData.set(element, ko.bindingHandlers.options.optionValueDomDataKey, undefined);\n                            if (hasDomDataExpandoProperty in element) { // IE <= 8 throws errors if you delete non-existent properties from a DOM node\n                                delete element[hasDomDataExpandoProperty];\n                            }\n                            element.value = value;\n                            break;\n                        default:\n                            // Store arbitrary object using DomData\n                            ko.utils.domData.set(element, ko.bindingHandlers.options.optionValueDomDataKey, value);\n                            element[hasDomDataExpandoProperty] = true;\n\n                            // Special treatment of numbers is just for backward compatibility. KO 1.2.1 wrote numerical values to element.value.\n                            element.value = typeof value === \"number\" ? value : \"\";\n                            break;\n                    }\n                    break;\n                case 'select':\n                    for (var i = element.options.length - 1; i >= 0; i--) {\n                        if (ko.selectExtensions.readValue(element.options[i]) == value) {\n                            element.selectedIndex = i;\n                            break;\n                        }\n                    }\n                    break;\n                default:\n                    if ((value === null) || (value === undefined))\n                        value = \"\";\n                    element.value = value;\n                    break;\n            }\n        }\n    };\n})();\n\nko.exportSymbol('selectExtensions', ko.selectExtensions);\nko.exportSymbol('selectExtensions.readValue', ko.selectExtensions.readValue);\nko.exportSymbol('selectExtensions.writeValue', ko.selectExtensions.writeValue);\nko.expressionRewriting = (function () {\n    var restoreCapturedTokensRegex = /\\@ko_token_(\\d+)\\@/g;\n    var javaScriptReservedWords = [\"true\", \"false\"];\n\n    // Matches something that can be assigned to--either an isolated identifier or something ending with a property accessor\n    // This is designed to be simple and avoid false negatives, but could produce false positives (e.g., a+b.c).\n    var javaScriptAssignmentTarget = /^(?:[$_a-z][$\\w]*|(.+)(\\.\\s*[$_a-z][$\\w]*|\\[.+\\]))$/i;\n\n    function restoreTokens(string, tokens) {\n        var prevValue = null;\n        while (string != prevValue) { // Keep restoring tokens until it no longer makes a difference (they may be nested)\n            prevValue = string;\n            string = string.replace(restoreCapturedTokensRegex, function (match, tokenIndex) {\n                return tokens[tokenIndex];\n            });\n        }\n        return string;\n    }\n\n    function getWriteableValue(expression) {\n        if (ko.utils.arrayIndexOf(javaScriptReservedWords, ko.utils.stringTrim(expression).toLowerCase()) >= 0)\n            return false;\n        var match = expression.match(javaScriptAssignmentTarget);\n        return match === null ? false : match[1] ? ('Object(' + match[1] + ')' + match[2]) : expression;\n    }\n\n    function ensureQuoted(key) {\n        var trimmedKey = ko.utils.stringTrim(key);\n        switch (trimmedKey.length && trimmedKey.charAt(0)) {\n            case \"'\":\n            case '\"':\n                return key;\n            default:\n                return \"'\" + trimmedKey + \"'\";\n        }\n    }\n\n    return {\n        bindingRewriteValidators: [],\n\n        parseObjectLiteral: function(objectLiteralString) {\n            // A full tokeniser+lexer would add too much weight to this library, so here's a simple parser\n            // that is sufficient just to split an object literal string into a set of top-level key-value pairs\n\n            var str = ko.utils.stringTrim(objectLiteralString);\n            if (str.length < 3)\n                return [];\n            if (str.charAt(0) === \"{\")// Ignore any braces surrounding the whole object literal\n                str = str.substring(1, str.length - 1);\n\n            // Pull out any string literals and regex literals\n            var tokens = [];\n            var tokenStart = null, tokenEndChar;\n            for (var position = 0; position < str.length; position++) {\n                var c = str.charAt(position);\n                if (tokenStart === null) {\n                    switch (c) {\n                        case '\"':\n                        case \"'\":\n                        case \"/\":\n                            tokenStart = position;\n                            tokenEndChar = c;\n                            break;\n                    }\n                } else if ((c == tokenEndChar) && (str.charAt(position - 1) !== \"\\\\\")) {\n                    var token = str.substring(tokenStart, position + 1);\n                    tokens.push(token);\n                    var replacement = \"@ko_token_\" + (tokens.length - 1) + \"@\";\n                    str = str.substring(0, tokenStart) + replacement + str.substring(position + 1);\n                    position -= (token.length - replacement.length);\n                    tokenStart = null;\n                }\n            }\n\n            // Next pull out balanced paren, brace, and bracket blocks\n            tokenStart = null;\n            tokenEndChar = null;\n            var tokenDepth = 0, tokenStartChar = null;\n            for (var position = 0; position < str.length; position++) {\n                var c = str.charAt(position);\n                if (tokenStart === null) {\n                    switch (c) {\n                        case \"{\": tokenStart = position; tokenStartChar = c;\n                                  tokenEndChar = \"}\";\n                                  break;\n                        case \"(\": tokenStart = position; tokenStartChar = c;\n                                  tokenEndChar = \")\";\n                                  break;\n                        case \"[\": tokenStart = position; tokenStartChar = c;\n                                  tokenEndChar = \"]\";\n                                  break;\n                    }\n                }\n\n                if (c === tokenStartChar)\n                    tokenDepth++;\n                else if (c === tokenEndChar) {\n                    tokenDepth--;\n                    if (tokenDepth === 0) {\n                        var token = str.substring(tokenStart, position + 1);\n                        tokens.push(token);\n                        var replacement = \"@ko_token_\" + (tokens.length - 1) + \"@\";\n                        str = str.substring(0, tokenStart) + replacement + str.substring(position + 1);\n                        position -= (token.length - replacement.length);\n                        tokenStart = null;\n                    }\n                }\n            }\n\n            // Now we can safely split on commas to get the key/value pairs\n            var result = [];\n            var keyValuePairs = str.split(\",\");\n            for (var i = 0, j = keyValuePairs.length; i < j; i++) {\n                var pair = keyValuePairs[i];\n                var colonPos = pair.indexOf(\":\");\n                if ((colonPos > 0) && (colonPos < pair.length - 1)) {\n                    var key = pair.substring(0, colonPos);\n                    var value = pair.substring(colonPos + 1);\n                    result.push({ 'key': restoreTokens(key, tokens), 'value': restoreTokens(value, tokens) });\n                } else {\n                    result.push({ 'unknown': restoreTokens(pair, tokens) });\n                }\n            }\n            return result;\n        },\n\n        preProcessBindings: function (objectLiteralStringOrKeyValueArray) {\n            var keyValueArray = typeof objectLiteralStringOrKeyValueArray === \"string\"\n                ? ko.expressionRewriting.parseObjectLiteral(objectLiteralStringOrKeyValueArray)\n                : objectLiteralStringOrKeyValueArray;\n            var resultStrings = [], propertyAccessorResultStrings = [];\n\n            var keyValueEntry;\n            for (var i = 0; keyValueEntry = keyValueArray[i]; i++) {\n                if (resultStrings.length > 0)\n                    resultStrings.push(\",\");\n\n                if (keyValueEntry['key']) {\n                    var quotedKey = ensureQuoted(keyValueEntry['key']), val = keyValueEntry['value'];\n                    resultStrings.push(quotedKey);\n                    resultStrings.push(\":\");\n                    resultStrings.push(val);\n\n                    if (val = getWriteableValue(ko.utils.stringTrim(val))) {\n                        if (propertyAccessorResultStrings.length > 0)\n                            propertyAccessorResultStrings.push(\", \");\n                        propertyAccessorResultStrings.push(quotedKey + \" : function(__ko_value) { \" + val + \" = __ko_value; }\");\n                    }\n                } else if (keyValueEntry['unknown']) {\n                    resultStrings.push(keyValueEntry['unknown']);\n                }\n            }\n\n            var combinedResult = resultStrings.join(\"\");\n            if (propertyAccessorResultStrings.length > 0) {\n                var allPropertyAccessors = propertyAccessorResultStrings.join(\"\");\n                combinedResult = combinedResult + \", '_ko_property_writers' : { \" + allPropertyAccessors + \" } \";\n            }\n\n            return combinedResult;\n        },\n\n        keyValueArrayContainsKey: function(keyValueArray, key) {\n            for (var i = 0; i < keyValueArray.length; i++)\n                if (ko.utils.stringTrim(keyValueArray[i]['key']) == key)\n                    return true;\n            return false;\n        },\n\n        // Internal, private KO utility for updating model properties from within bindings\n        // property:            If the property being updated is (or might be) an observable, pass it here\n        //                      If it turns out to be a writable observable, it will be written to directly\n        // allBindingsAccessor: All bindings in the current execution context.\n        //                      This will be searched for a '_ko_property_writers' property in case you're writing to a non-observable\n        // key:                 The key identifying the property to be written. Example: for { hasFocus: myValue }, write to 'myValue' by specifying the key 'hasFocus'\n        // value:               The value to be written\n        // checkIfDifferent:    If true, and if the property being written is a writable observable, the value will only be written if\n        //                      it is !== existing value on that writable observable\n        writeValueToProperty: function(property, allBindingsAccessor, key, value, checkIfDifferent) {\n            if (!property || !ko.isWriteableObservable(property)) {\n                var propWriters = allBindingsAccessor()['_ko_property_writers'];\n                if (propWriters && propWriters[key])\n                    propWriters[key](value);\n            } else if (!checkIfDifferent || property.peek() !== value) {\n                property(value);\n            }\n        }\n    };\n})();\n\nko.exportSymbol('expressionRewriting', ko.expressionRewriting);\nko.exportSymbol('expressionRewriting.bindingRewriteValidators', ko.expressionRewriting.bindingRewriteValidators);\nko.exportSymbol('expressionRewriting.parseObjectLiteral', ko.expressionRewriting.parseObjectLiteral);\nko.exportSymbol('expressionRewriting.preProcessBindings', ko.expressionRewriting.preProcessBindings);\n\n// For backward compatibility, define the following aliases. (Previously, these function names were misleading because\n// they referred to JSON specifically, even though they actually work with arbitrary JavaScript object literal expressions.)\nko.exportSymbol('jsonExpressionRewriting', ko.expressionRewriting);\nko.exportSymbol('jsonExpressionRewriting.insertPropertyAccessorsIntoJson', ko.expressionRewriting.preProcessBindings);(function() {\n    // \"Virtual elements\" is an abstraction on top of the usual DOM API which understands the notion that comment nodes\n    // may be used to represent hierarchy (in addition to the DOM's natural hierarchy).\n    // If you call the DOM-manipulating functions on ko.virtualElements, you will be able to read and write the state\n    // of that virtual hierarchy\n    //\n    // The point of all this is to support containerless templates (e.g., <!-- ko foreach:someCollection -->blah<!-- /ko -->)\n    // without having to scatter special cases all over the binding and templating code.\n\n    // IE 9 cannot reliably read the \"nodeValue\" property of a comment node (see https://github.com/SteveSanderson/knockout/issues/186)\n    // but it does give them a nonstandard alternative property called \"text\" that it can read reliably. Other browsers don't have that property.\n    // So, use node.text where available, and node.nodeValue elsewhere\n    var commentNodesHaveTextProperty = document.createComment(\"test\").text === \"<!--test-->\";\n\n    var startCommentRegex = commentNodesHaveTextProperty ? /^<!--\\s*ko(?:\\s+(.+\\s*\\:[\\s\\S]*))?\\s*-->$/ : /^\\s*ko(?:\\s+(.+\\s*\\:[\\s\\S]*))?\\s*$/;\n    var endCommentRegex =   commentNodesHaveTextProperty ? /^<!--\\s*\\/ko\\s*-->$/ : /^\\s*\\/ko\\s*$/;\n    var htmlTagsWithOptionallyClosingChildren = { 'ul': true, 'ol': true };\n\n    function isStartComment(node) {\n        return (node.nodeType == 8) && (commentNodesHaveTextProperty ? node.text : node.nodeValue).match(startCommentRegex);\n    }\n\n    function isEndComment(node) {\n        return (node.nodeType == 8) && (commentNodesHaveTextProperty ? node.text : node.nodeValue).match(endCommentRegex);\n    }\n\n    function getVirtualChildren(startComment, allowUnbalanced) {\n        var currentNode = startComment;\n        var depth = 1;\n        var children = [];\n        while (currentNode = currentNode.nextSibling) {\n            if (isEndComment(currentNode)) {\n                depth--;\n                if (depth === 0)\n                    return children;\n            }\n\n            children.push(currentNode);\n\n            if (isStartComment(currentNode))\n                depth++;\n        }\n        if (!allowUnbalanced)\n            throw new Error(\"Cannot find closing comment tag to match: \" + startComment.nodeValue);\n        return null;\n    }\n\n    function getMatchingEndComment(startComment, allowUnbalanced) {\n        var allVirtualChildren = getVirtualChildren(startComment, allowUnbalanced);\n        if (allVirtualChildren) {\n            if (allVirtualChildren.length > 0)\n                return allVirtualChildren[allVirtualChildren.length - 1].nextSibling;\n            return startComment.nextSibling;\n        } else\n            return null; // Must have no matching end comment, and allowUnbalanced is true\n    }\n\n    function getUnbalancedChildTags(node) {\n        // e.g., from <div>OK</div><!-- ko blah --><span>Another</span>, returns: <!-- ko blah --><span>Another</span>\n        //       from <div>OK</div><!-- /ko --><!-- /ko -->,             returns: <!-- /ko --><!-- /ko -->\n        var childNode = node.firstChild, captureRemaining = null;\n        if (childNode) {\n            do {\n                if (captureRemaining)                   // We already hit an unbalanced node and are now just scooping up all subsequent nodes\n                    captureRemaining.push(childNode);\n                else if (isStartComment(childNode)) {\n                    var matchingEndComment = getMatchingEndComment(childNode, /* allowUnbalanced: */ true);\n                    if (matchingEndComment)             // It's a balanced tag, so skip immediately to the end of this virtual set\n                        childNode = matchingEndComment;\n                    else\n                        captureRemaining = [childNode]; // It's unbalanced, so start capturing from this point\n                } else if (isEndComment(childNode)) {\n                    captureRemaining = [childNode];     // It's unbalanced (if it wasn't, we'd have skipped over it already), so start capturing\n                }\n            } while (childNode = childNode.nextSibling);\n        }\n        return captureRemaining;\n    }\n\n    ko.virtualElements = {\n        allowedBindings: {},\n\n        childNodes: function(node) {\n            return isStartComment(node) ? getVirtualChildren(node) : node.childNodes;\n        },\n\n        emptyNode: function(node) {\n            if (!isStartComment(node))\n                ko.utils.emptyDomNode(node);\n            else {\n                var virtualChildren = ko.virtualElements.childNodes(node);\n                for (var i = 0, j = virtualChildren.length; i < j; i++)\n                    ko.removeNode(virtualChildren[i]);\n            }\n        },\n\n        setDomNodeChildren: function(node, childNodes) {\n            if (!isStartComment(node))\n                ko.utils.setDomNodeChildren(node, childNodes);\n            else {\n                ko.virtualElements.emptyNode(node);\n                var endCommentNode = node.nextSibling; // Must be the next sibling, as we just emptied the children\n                for (var i = 0, j = childNodes.length; i < j; i++)\n                    endCommentNode.parentNode.insertBefore(childNodes[i], endCommentNode);\n            }\n        },\n\n        prepend: function(containerNode, nodeToPrepend) {\n            if (!isStartComment(containerNode)) {\n                if (containerNode.firstChild)\n                    containerNode.insertBefore(nodeToPrepend, containerNode.firstChild);\n                else\n                    containerNode.appendChild(nodeToPrepend);\n            } else {\n                // Start comments must always have a parent and at least one following sibling (the end comment)\n                containerNode.parentNode.insertBefore(nodeToPrepend, containerNode.nextSibling);\n            }\n        },\n\n        insertAfter: function(containerNode, nodeToInsert, insertAfterNode) {\n            if (!insertAfterNode) {\n                ko.virtualElements.prepend(containerNode, nodeToInsert);\n            } else if (!isStartComment(containerNode)) {\n                // Insert after insertion point\n                if (insertAfterNode.nextSibling)\n                    containerNode.insertBefore(nodeToInsert, insertAfterNode.nextSibling);\n                else\n                    containerNode.appendChild(nodeToInsert);\n            } else {\n                // Children of start comments must always have a parent and at least one following sibling (the end comment)\n                containerNode.parentNode.insertBefore(nodeToInsert, insertAfterNode.nextSibling);\n            }\n        },\n\n        firstChild: function(node) {\n            if (!isStartComment(node))\n                return node.firstChild;\n            if (!node.nextSibling || isEndComment(node.nextSibling))\n                return null;\n            return node.nextSibling;\n        },\n\n        nextSibling: function(node) {\n            if (isStartComment(node))\n                node = getMatchingEndComment(node);\n            if (node.nextSibling && isEndComment(node.nextSibling))\n                return null;\n            return node.nextSibling;\n        },\n\n        virtualNodeBindingValue: function(node) {\n            var regexMatch = isStartComment(node);\n            return regexMatch ? regexMatch[1] : null;\n        },\n\n        normaliseVirtualElementDomStructure: function(elementVerified) {\n            // Workaround for https://github.com/SteveSanderson/knockout/issues/155\n            // (IE <= 8 or IE 9 quirks mode parses your HTML weirdly, treating closing </li> tags as if they don't exist, thereby moving comment nodes\n            // that are direct descendants of <ul> into the preceding <li>)\n            if (!htmlTagsWithOptionallyClosingChildren[ko.utils.tagNameLower(elementVerified)])\n                return;\n\n            // Scan immediate children to see if they contain unbalanced comment tags. If they do, those comment tags\n            // must be intended to appear *after* that child, so move them there.\n            var childNode = elementVerified.firstChild;\n            if (childNode) {\n                do {\n                    if (childNode.nodeType === 1) {\n                        var unbalancedTags = getUnbalancedChildTags(childNode);\n                        if (unbalancedTags) {\n                            // Fix up the DOM by moving the unbalanced tags to where they most likely were intended to be placed - *after* the child\n                            var nodeToInsertBefore = childNode.nextSibling;\n                            for (var i = 0; i < unbalancedTags.length; i++) {\n                                if (nodeToInsertBefore)\n                                    elementVerified.insertBefore(unbalancedTags[i], nodeToInsertBefore);\n                                else\n                                    elementVerified.appendChild(unbalancedTags[i]);\n                            }\n                        }\n                    }\n                } while (childNode = childNode.nextSibling);\n            }\n        }\n    };\n})();\nko.exportSymbol('virtualElements', ko.virtualElements);\nko.exportSymbol('virtualElements.allowedBindings', ko.virtualElements.allowedBindings);\nko.exportSymbol('virtualElements.emptyNode', ko.virtualElements.emptyNode);\n//ko.exportSymbol('virtualElements.firstChild', ko.virtualElements.firstChild);     // firstChild is not minified\nko.exportSymbol('virtualElements.insertAfter', ko.virtualElements.insertAfter);\n//ko.exportSymbol('virtualElements.nextSibling', ko.virtualElements.nextSibling);   // nextSibling is not minified\nko.exportSymbol('virtualElements.prepend', ko.virtualElements.prepend);\nko.exportSymbol('virtualElements.setDomNodeChildren', ko.virtualElements.setDomNodeChildren);\n(function() {\n    var defaultBindingAttributeName = \"data-bind\";\n\n    ko.bindingProvider = function() {\n        this.bindingCache = {};\n    };\n\n    ko.utils.extend(ko.bindingProvider.prototype, {\n        'nodeHasBindings': function(node) {\n            switch (node.nodeType) {\n                case 1: return node.getAttribute(defaultBindingAttributeName) != null;   // Element\n                case 8: return ko.virtualElements.virtualNodeBindingValue(node) != null; // Comment node\n                default: return false;\n            }\n        },\n\n        'getBindings': function(node, bindingContext) {\n            var bindingsString = this['getBindingsString'](node, bindingContext);\n            return bindingsString ? this['parseBindingsString'](bindingsString, bindingContext, node) : null;\n        },\n\n        // The following function is only used internally by this default provider.\n        // It's not part of the interface definition for a general binding provider.\n        'getBindingsString': function(node, bindingContext) {\n            switch (node.nodeType) {\n                case 1: return node.getAttribute(defaultBindingAttributeName);   // Element\n                case 8: return ko.virtualElements.virtualNodeBindingValue(node); // Comment node\n                default: return null;\n            }\n        },\n\n        // The following function is only used internally by this default provider.\n        // It's not part of the interface definition for a general binding provider.\n        'parseBindingsString': function(bindingsString, bindingContext, node) {\n            try {\n                var bindingFunction = createBindingsStringEvaluatorViaCache(bindingsString, this.bindingCache);\n                return bindingFunction(bindingContext, node);\n            } catch (ex) {\n                throw new Error(\"Unable to parse bindings.\\nMessage: \" + ex + \";\\nBindings value: \" + bindingsString);\n            }\n        }\n    });\n\n    ko.bindingProvider['instance'] = new ko.bindingProvider();\n\n    function createBindingsStringEvaluatorViaCache(bindingsString, cache) {\n        var cacheKey = bindingsString;\n        return cache[cacheKey]\n            || (cache[cacheKey] = createBindingsStringEvaluator(bindingsString));\n    }\n\n    function createBindingsStringEvaluator(bindingsString) {\n        // Build the source for a function that evaluates \"expression\"\n        // For each scope variable, add an extra level of \"with\" nesting\n        // Example result: with(sc1) { with(sc0) { return (expression) } }\n        var rewrittenBindings = ko.expressionRewriting.preProcessBindings(bindingsString),\n            functionBody = \"with($context){with($data||{}){return{\" + rewrittenBindings + \"}}}\";\n        return new Function(\"$context\", \"$element\", functionBody);\n    }\n})();\n\nko.exportSymbol('bindingProvider', ko.bindingProvider);\n(function () {\n    ko.bindingHandlers = {};\n\n    ko.bindingContext = function(dataItem, parentBindingContext, dataItemAlias) {\n        if (parentBindingContext) {\n            ko.utils.extend(this, parentBindingContext); // Inherit $root and any custom properties\n            this['$parentContext'] = parentBindingContext;\n            this['$parent'] = parentBindingContext['$data'];\n            this['$parents'] = (parentBindingContext['$parents'] || []).slice(0);\n            this['$parents'].unshift(this['$parent']);\n        } else {\n            this['$parents'] = [];\n            this['$root'] = dataItem;\n            // Export 'ko' in the binding context so it will be available in bindings and templates\n            // even if 'ko' isn't exported as a global, such as when using an AMD loader.\n            // See https://github.com/SteveSanderson/knockout/issues/490\n            this['ko'] = ko;\n        }\n        this['$data'] = dataItem;\n        if (dataItemAlias)\n            this[dataItemAlias] = dataItem;\n    }\n    ko.bindingContext.prototype['createChildContext'] = function (dataItem, dataItemAlias) {\n        return new ko.bindingContext(dataItem, this, dataItemAlias);\n    };\n    ko.bindingContext.prototype['extend'] = function(properties) {\n        var clone = ko.utils.extend(new ko.bindingContext(), this);\n        return ko.utils.extend(clone, properties);\n    };\n\n    function validateThatBindingIsAllowedForVirtualElements(bindingName) {\n        var validator = ko.virtualElements.allowedBindings[bindingName];\n        if (!validator)\n            throw new Error(\"The binding '\" + bindingName + \"' cannot be used with virtual elements\")\n    }\n\n    function applyBindingsToDescendantsInternal (viewModel, elementOrVirtualElement, bindingContextsMayDifferFromDomParentElement) {\n        var currentChild, nextInQueue = ko.virtualElements.firstChild(elementOrVirtualElement);\n        while (currentChild = nextInQueue) {\n            // Keep a record of the next child *before* applying bindings, in case the binding removes the current child from its position\n            nextInQueue = ko.virtualElements.nextSibling(currentChild);\n            applyBindingsToNodeAndDescendantsInternal(viewModel, currentChild, bindingContextsMayDifferFromDomParentElement);\n        }\n    }\n\n    function applyBindingsToNodeAndDescendantsInternal (viewModel, nodeVerified, bindingContextMayDifferFromDomParentElement) {\n        var shouldBindDescendants = true;\n\n        // Perf optimisation: Apply bindings only if...\n        // (1) We need to store the binding context on this node (because it may differ from the DOM parent node's binding context)\n        //     Note that we can't store binding contexts on non-elements (e.g., text nodes), as IE doesn't allow expando properties for those\n        // (2) It might have bindings (e.g., it has a data-bind attribute, or it's a marker for a containerless template)\n        var isElement = (nodeVerified.nodeType === 1);\n        if (isElement) // Workaround IE <= 8 HTML parsing weirdness\n            ko.virtualElements.normaliseVirtualElementDomStructure(nodeVerified);\n\n        var shouldApplyBindings = (isElement && bindingContextMayDifferFromDomParentElement)             // Case (1)\n                               || ko.bindingProvider['instance']['nodeHasBindings'](nodeVerified);       // Case (2)\n        if (shouldApplyBindings)\n            shouldBindDescendants = applyBindingsToNodeInternal(nodeVerified, null, viewModel, bindingContextMayDifferFromDomParentElement).shouldBindDescendants;\n\n        if (shouldBindDescendants) {\n            // We're recursing automatically into (real or virtual) child nodes without changing binding contexts. So,\n            //  * For children of a *real* element, the binding context is certainly the same as on their DOM .parentNode,\n            //    hence bindingContextsMayDifferFromDomParentElement is false\n            //  * For children of a *virtual* element, we can't be sure. Evaluating .parentNode on those children may\n            //    skip over any number of intermediate virtual elements, any of which might define a custom binding context,\n            //    hence bindingContextsMayDifferFromDomParentElement is true\n            applyBindingsToDescendantsInternal(viewModel, nodeVerified, /* bindingContextsMayDifferFromDomParentElement: */ !isElement);\n        }\n    }\n\n    function applyBindingsToNodeInternal (node, bindings, viewModelOrBindingContext, bindingContextMayDifferFromDomParentElement) {\n        // Need to be sure that inits are only run once, and updates never run until all the inits have been run\n        var initPhase = 0; // 0 = before all inits, 1 = during inits, 2 = after all inits\n\n        // Each time the dependentObservable is evaluated (after data changes),\n        // the binding attribute is reparsed so that it can pick out the correct\n        // model properties in the context of the changed data.\n        // DOM event callbacks need to be able to access this changed data,\n        // so we need a single parsedBindings variable (shared by all callbacks\n        // associated with this node's bindings) that all the closures can access.\n        var parsedBindings;\n        function makeValueAccessor(bindingKey) {\n            return function () { return parsedBindings[bindingKey] }\n        }\n        function parsedBindingsAccessor() {\n            return parsedBindings;\n        }\n\n        var bindingHandlerThatControlsDescendantBindings;\n        ko.dependentObservable(\n            function () {\n                // Ensure we have a nonnull binding context to work with\n                var bindingContextInstance = viewModelOrBindingContext && (viewModelOrBindingContext instanceof ko.bindingContext)\n                    ? viewModelOrBindingContext\n                    : new ko.bindingContext(ko.utils.unwrapObservable(viewModelOrBindingContext));\n                var viewModel = bindingContextInstance['$data'];\n\n                // Optimization: Don't store the binding context on this node if it's definitely the same as on node.parentNode, because\n                // we can easily recover it just by scanning up the node's ancestors in the DOM\n                // (note: here, parent node means \"real DOM parent\" not \"virtual parent\", as there's no O(1) way to find the virtual parent)\n                if (bindingContextMayDifferFromDomParentElement)\n                    ko.storedBindingContextForNode(node, bindingContextInstance);\n\n                // Use evaluatedBindings if given, otherwise fall back on asking the bindings provider to give us some bindings\n                var evaluatedBindings = (typeof bindings == \"function\") ? bindings(bindingContextInstance, node) : bindings;\n                parsedBindings = evaluatedBindings || ko.bindingProvider['instance']['getBindings'](node, bindingContextInstance);\n\n                if (parsedBindings) {\n                    // First run all the inits, so bindings can register for notification on changes\n                    if (initPhase === 0) {\n                        initPhase = 1;\n                        for (var bindingKey in parsedBindings) {\n                            var binding = ko.bindingHandlers[bindingKey];\n                            if (binding && node.nodeType === 8)\n                                validateThatBindingIsAllowedForVirtualElements(bindingKey);\n\n                            if (binding && typeof binding[\"init\"] == \"function\") {\n                                var handlerInitFn = binding[\"init\"];\n                                var initResult = handlerInitFn(node, makeValueAccessor(bindingKey), parsedBindingsAccessor, viewModel, bindingContextInstance);\n\n                                // If this binding handler claims to control descendant bindings, make a note of this\n                                if (initResult && initResult['controlsDescendantBindings']) {\n                                    if (bindingHandlerThatControlsDescendantBindings !== undefined)\n                                        throw new Error(\"Multiple bindings (\" + bindingHandlerThatControlsDescendantBindings + \" and \" + bindingKey + \") are trying to control descendant bindings of the same element. You cannot use these bindings together on the same element.\");\n                                    bindingHandlerThatControlsDescendantBindings = bindingKey;\n                                }\n                            }\n                        }\n                        initPhase = 2;\n                    }\n\n                    // ... then run all the updates, which might trigger changes even on the first evaluation\n                    if (initPhase === 2) {\n                        for (var bindingKey in parsedBindings) {\n                            var binding = ko.bindingHandlers[bindingKey];\n                            if (binding && typeof binding[\"update\"] == \"function\") {\n                                var handlerUpdateFn = binding[\"update\"];\n                                handlerUpdateFn(node, makeValueAccessor(bindingKey), parsedBindingsAccessor, viewModel, bindingContextInstance);\n                            }\n                        }\n                    }\n                }\n            },\n            null,\n            { disposeWhenNodeIsRemoved : node }\n        );\n\n        return {\n            shouldBindDescendants: bindingHandlerThatControlsDescendantBindings === undefined\n        };\n    };\n\n    var storedBindingContextDomDataKey = \"__ko_bindingContext__\";\n    ko.storedBindingContextForNode = function (node, bindingContext) {\n        if (arguments.length == 2)\n            ko.utils.domData.set(node, storedBindingContextDomDataKey, bindingContext);\n        else\n            return ko.utils.domData.get(node, storedBindingContextDomDataKey);\n    }\n\n    ko.applyBindingsToNode = function (node, bindings, viewModel) {\n        if (node.nodeType === 1) // If it's an element, workaround IE <= 8 HTML parsing weirdness\n            ko.virtualElements.normaliseVirtualElementDomStructure(node);\n        return applyBindingsToNodeInternal(node, bindings, viewModel, true);\n    };\n\n    ko.applyBindingsToDescendants = function(viewModel, rootNode) {\n        if (rootNode.nodeType === 1 || rootNode.nodeType === 8)\n            applyBindingsToDescendantsInternal(viewModel, rootNode, true);\n    };\n\n    ko.applyBindings = function (viewModel, rootNode) {\n        if (rootNode && (rootNode.nodeType !== 1) && (rootNode.nodeType !== 8))\n            throw new Error(\"ko.applyBindings: first parameter should be your view model; second parameter should be a DOM node\");\n        rootNode = rootNode || window.document.body; // Make \"rootNode\" parameter optional\n\n        applyBindingsToNodeAndDescendantsInternal(viewModel, rootNode, true);\n    };\n\n    // Retrieving binding context from arbitrary nodes\n    ko.contextFor = function(node) {\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)\n        switch (node.nodeType) {\n            case 1:\n            case 8:\n                var context = ko.storedBindingContextForNode(node);\n                if (context) return context;\n                if (node.parentNode) return ko.contextFor(node.parentNode);\n                break;\n        }\n        return undefined;\n    };\n    ko.dataFor = function(node) {\n        var context = ko.contextFor(node);\n        return context ? context['$data'] : undefined;\n    };\n\n    ko.exportSymbol('bindingHandlers', ko.bindingHandlers);\n    ko.exportSymbol('applyBindings', ko.applyBindings);\n    ko.exportSymbol('applyBindingsToDescendants', ko.applyBindingsToDescendants);\n    ko.exportSymbol('applyBindingsToNode', ko.applyBindingsToNode);\n    ko.exportSymbol('contextFor', ko.contextFor);\n    ko.exportSymbol('dataFor', ko.dataFor);\n})();\nvar attrHtmlToJavascriptMap = { 'class': 'className', 'for': 'htmlFor' };\nko.bindingHandlers['attr'] = {\n    'update': function(element, valueAccessor, allBindingsAccessor) {\n        var value = ko.utils.unwrapObservable(valueAccessor()) || {};\n        for (var attrName in value) {\n            if (typeof attrName == \"string\") {\n                var attrValue = ko.utils.unwrapObservable(value[attrName]);\n\n                // To cover cases like \"attr: { checked:someProp }\", we want to remove the attribute entirely\n                // when someProp is a \"no value\"-like value (strictly null, false, or undefined)\n                // (because the absence of the \"checked\" attr is how to mark an element as not checked, etc.)\n                var toRemove = (attrValue === false) || (attrValue === null) || (attrValue === undefined);\n                if (toRemove)\n                    element.removeAttribute(attrName);\n\n                // In IE <= 7 and IE8 Quirks Mode, you have to use the Javascript property name instead of the\n                // HTML attribute name for certain attributes. IE8 Standards Mode supports the correct behavior,\n                // but instead of figuring out the mode, we'll just set the attribute through the Javascript\n                // property for IE <= 8.\n                if (ko.utils.ieVersion <= 8 && attrName in attrHtmlToJavascriptMap) {\n                    attrName = attrHtmlToJavascriptMap[attrName];\n                    if (toRemove)\n                        element.removeAttribute(attrName);\n                    else\n                        element[attrName] = attrValue;\n                } else if (!toRemove) {\n                    element.setAttribute(attrName, attrValue.toString());\n                }\n\n                // Treat \"name\" specially - although you can think of it as an attribute, it also needs\n                // special handling on older versions of IE (https://github.com/SteveSanderson/knockout/pull/333)\n                // Deliberately being case-sensitive here because XHTML would regard \"Name\" as a different thing\n                // entirely, and there's no strong reason to allow for such casing in HTML.\n                if (attrName === \"name\") {\n                    ko.utils.setElementName(element, toRemove ? \"\" : attrValue.toString());\n                }\n            }\n        }\n    }\n};\nko.bindingHandlers['checked'] = {\n    'init': function (element, valueAccessor, allBindingsAccessor) {\n        var updateHandler = function() {\n            var valueToWrite;\n            if (element.type == \"checkbox\") {\n                valueToWrite = element.checked;\n            } else if ((element.type == \"radio\") && (element.checked)) {\n                valueToWrite = element.value;\n            } else {\n                return; // \"checked\" binding only responds to checkboxes and selected radio buttons\n            }\n\n            var modelValue = valueAccessor(), unwrappedValue = ko.utils.unwrapObservable(modelValue);\n            if ((element.type == \"checkbox\") && (unwrappedValue instanceof Array)) {\n                // For checkboxes bound to an array, we add/remove the checkbox value to that array\n                // This works for both observable and non-observable arrays\n                var existingEntryIndex = ko.utils.arrayIndexOf(unwrappedValue, element.value);\n                if (element.checked && (existingEntryIndex < 0))\n                    modelValue.push(element.value);\n                else if ((!element.checked) && (existingEntryIndex >= 0))\n                    modelValue.splice(existingEntryIndex, 1);\n            } else {\n                ko.expressionRewriting.writeValueToProperty(modelValue, allBindingsAccessor, 'checked', valueToWrite, true);\n            }\n        };\n        ko.utils.registerEventHandler(element, \"click\", updateHandler);\n\n        // IE 6 won't allow radio buttons to be selected unless they have a name\n        if ((element.type == \"radio\") && !element.name)\n            ko.bindingHandlers['uniqueName']['init'](element, function() { return true });\n    },\n    'update': function (element, valueAccessor) {\n        var value = ko.utils.unwrapObservable(valueAccessor());\n\n        if (element.type == \"checkbox\") {\n            if (value instanceof Array) {\n                // When bound to an array, the checkbox being checked represents its value being present in that array\n                element.checked = ko.utils.arrayIndexOf(value, element.value) >= 0;\n            } else {\n                // When bound to anything other value (not an array), the checkbox being checked represents the value being trueish\n                element.checked = value;\n            }\n        } else if (element.type == \"radio\") {\n            element.checked = (element.value == value);\n        }\n    }\n};\nvar classesWrittenByBindingKey = '__ko__cssValue';\nko.bindingHandlers['css'] = {\n    'update': function (element, valueAccessor) {\n        var value = ko.utils.unwrapObservable(valueAccessor());\n        if (typeof value == \"object\") {\n            for (var className in value) {\n                var shouldHaveClass = ko.utils.unwrapObservable(value[className]);\n                ko.utils.toggleDomNodeCssClass(element, className, shouldHaveClass);\n            }\n        } else {\n            value = String(value || ''); // Make sure we don't try to store or set a non-string value\n            ko.utils.toggleDomNodeCssClass(element, element[classesWrittenByBindingKey], false);\n            element[classesWrittenByBindingKey] = value;\n            ko.utils.toggleDomNodeCssClass(element, value, true);\n        }\n    }\n};\nko.bindingHandlers['enable'] = {\n    'update': function (element, valueAccessor) {\n        var value = ko.utils.unwrapObservable(valueAccessor());\n        if (value && element.disabled)\n            element.removeAttribute(\"disabled\");\n        else if ((!value) && (!element.disabled))\n            element.disabled = true;\n    }\n};\n\nko.bindingHandlers['disable'] = {\n    'update': function (element, valueAccessor) {\n        ko.bindingHandlers['enable']['update'](element, function() { return !ko.utils.unwrapObservable(valueAccessor()) });\n    }\n};\n// For certain common events (currently just 'click'), allow a simplified data-binding syntax\n// e.g. click:handler instead of the usual full-length event:{click:handler}\nfunction makeEventHandlerShortcut(eventName) {\n    ko.bindingHandlers[eventName] = {\n        'init': function(element, valueAccessor, allBindingsAccessor, viewModel) {\n            var newValueAccessor = function () {\n                var result = {};\n                result[eventName] = valueAccessor();\n                return result;\n            };\n            return ko.bindingHandlers['event']['init'].call(this, element, newValueAccessor, allBindingsAccessor, viewModel);\n        }\n    }\n}\n\nko.bindingHandlers['event'] = {\n    'init' : function (element, valueAccessor, allBindingsAccessor, viewModel) {\n        var eventsToHandle = valueAccessor() || {};\n        for(var eventNameOutsideClosure in eventsToHandle) {\n            (function() {\n                var eventName = eventNameOutsideClosure; // Separate variable to be captured by event handler closure\n                if (typeof eventName == \"string\") {\n                    ko.utils.registerEventHandler(element, eventName, function (event) {\n                        var handlerReturnValue;\n                        var handlerFunction = valueAccessor()[eventName];\n                        if (!handlerFunction)\n                            return;\n                        var allBindings = allBindingsAccessor();\n\n                        try {\n                            // Take all the event args, and prefix with the viewmodel\n                            var argsForHandler = ko.utils.makeArray(arguments);\n                            argsForHandler.unshift(viewModel);\n                            handlerReturnValue = handlerFunction.apply(viewModel, argsForHandler);\n                        } finally {\n                            if (handlerReturnValue !== true) { // Normally we want to prevent default action. Developer can override this be explicitly returning true.\n                                if (event.preventDefault)\n                                    event.preventDefault();\n                                else\n                                    event.returnValue = false;\n                            }\n                        }\n\n                        var bubble = allBindings[eventName + 'Bubble'] !== false;\n                        if (!bubble) {\n                            event.cancelBubble = true;\n                            if (event.stopPropagation)\n                                event.stopPropagation();\n                        }\n                    });\n                }\n            })();\n        }\n    }\n};\n// \"foreach: someExpression\" is equivalent to \"template: { foreach: someExpression }\"\n// \"foreach: { data: someExpression, afterAdd: myfn }\" is equivalent to \"template: { foreach: someExpression, afterAdd: myfn }\"\nko.bindingHandlers['foreach'] = {\n    makeTemplateValueAccessor: function(valueAccessor) {\n        return function() {\n            var modelValue = valueAccessor(),\n                unwrappedValue = ko.utils.peekObservable(modelValue);    // Unwrap without setting a dependency here\n\n            // If unwrappedValue is the array, pass in the wrapped value on its own\n            // The value will be unwrapped and tracked within the template binding\n            // (See https://github.com/SteveSanderson/knockout/issues/523)\n            if ((!unwrappedValue) || typeof unwrappedValue.length == \"number\")\n                return { 'foreach': modelValue, 'templateEngine': ko.nativeTemplateEngine.instance };\n\n            // If unwrappedValue.data is the array, preserve all relevant options and unwrap again value so we get updates\n            ko.utils.unwrapObservable(modelValue);\n            return {\n                'foreach': unwrappedValue['data'],\n                'as': unwrappedValue['as'],\n                'includeDestroyed': unwrappedValue['includeDestroyed'],\n                'afterAdd': unwrappedValue['afterAdd'],\n                'beforeRemove': unwrappedValue['beforeRemove'],\n                'afterRender': unwrappedValue['afterRender'],\n                'beforeMove': unwrappedValue['beforeMove'],\n                'afterMove': unwrappedValue['afterMove'],\n                'templateEngine': ko.nativeTemplateEngine.instance\n            };\n        };\n    },\n    'init': function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {\n        return ko.bindingHandlers['template']['init'](element, ko.bindingHandlers['foreach'].makeTemplateValueAccessor(valueAccessor));\n    },\n    'update': function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {\n        return ko.bindingHandlers['template']['update'](element, ko.bindingHandlers['foreach'].makeTemplateValueAccessor(valueAccessor), allBindingsAccessor, viewModel, bindingContext);\n    }\n};\nko.expressionRewriting.bindingRewriteValidators['foreach'] = false; // Can't rewrite control flow bindings\nko.virtualElements.allowedBindings['foreach'] = true;\nvar hasfocusUpdatingProperty = '__ko_hasfocusUpdating';\nko.bindingHandlers['hasfocus'] = {\n    'init': function(element, valueAccessor, allBindingsAccessor) {\n        var handleElementFocusChange = function(isFocused) {\n            // Where possible, ignore which event was raised and determine focus state using activeElement,\n            // as this avoids phantom focus/blur events raised when changing tabs in modern browsers.\n            // However, not all KO-targeted browsers (Firefox 2) support activeElement. For those browsers,\n            // prevent a loss of focus when changing tabs/windows by setting a flag that prevents hasfocus\n            // from calling 'blur()' on the element when it loses focus.\n            // Discussion at https://github.com/SteveSanderson/knockout/pull/352\n            element[hasfocusUpdatingProperty] = true;\n            var ownerDoc = element.ownerDocument;\n            if (\"activeElement\" in ownerDoc) {\n                isFocused = (ownerDoc.activeElement === element);\n            }\n            var modelValue = valueAccessor();\n            ko.expressionRewriting.writeValueToProperty(modelValue, allBindingsAccessor, 'hasfocus', isFocused, true);\n            element[hasfocusUpdatingProperty] = false;\n        };\n        var handleElementFocusIn = handleElementFocusChange.bind(null, true);\n        var handleElementFocusOut = handleElementFocusChange.bind(null, false);\n\n        ko.utils.registerEventHandler(element, \"focus\", handleElementFocusIn);\n        ko.utils.registerEventHandler(element, \"focusin\", handleElementFocusIn); // For IE\n        ko.utils.registerEventHandler(element, \"blur\",  handleElementFocusOut);\n        ko.utils.registerEventHandler(element, \"focusout\",  handleElementFocusOut); // For IE\n    },\n    'update': function(element, valueAccessor) {\n        var value = ko.utils.unwrapObservable(valueAccessor());\n        if (!element[hasfocusUpdatingProperty]) {\n            value ? element.focus() : element.blur();\n            ko.dependencyDetection.ignore(ko.utils.triggerEvent, null, [element, value ? \"focusin\" : \"focusout\"]); // For IE, which doesn't reliably fire \"focus\" or \"blur\" events synchronously\n        }\n    }\n};\nko.bindingHandlers['html'] = {\n    'init': function() {\n        // Prevent binding on the dynamically-injected HTML (as developers are unlikely to expect that, and it has security implications)\n        return { 'controlsDescendantBindings': true };\n    },\n    'update': function (element, valueAccessor) {\n        // setHtml will unwrap the value if needed\n        ko.utils.setHtml(element, valueAccessor());\n    }\n};\nvar withIfDomDataKey = '__ko_withIfBindingData';\n// Makes a binding like with or if\nfunction makeWithIfBinding(bindingKey, isWith, isNot, makeContextCallback) {\n    ko.bindingHandlers[bindingKey] = {\n        'init': function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {\n            ko.utils.domData.set(element, withIfDomDataKey, {});\n            return { 'controlsDescendantBindings': true };\n        },\n        'update': function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {\n            var withIfData = ko.utils.domData.get(element, withIfDomDataKey),\n                dataValue = ko.utils.unwrapObservable(valueAccessor()),\n                shouldDisplay = !isNot !== !dataValue, // equivalent to isNot ? !dataValue : !!dataValue\n                isFirstRender = !withIfData.savedNodes,\n                needsRefresh = isFirstRender || isWith || (shouldDisplay !== withIfData.didDisplayOnLastUpdate);\n\n            if (needsRefresh) {\n                if (isFirstRender) {\n                    withIfData.savedNodes = ko.utils.cloneNodes(ko.virtualElements.childNodes(element), true /* shouldCleanNodes */);\n                }\n\n                if (shouldDisplay) {\n                    if (!isFirstRender) {\n                        ko.virtualElements.setDomNodeChildren(element, ko.utils.cloneNodes(withIfData.savedNodes));\n                    }\n                    ko.applyBindingsToDescendants(makeContextCallback ? makeContextCallback(bindingContext, dataValue) : bindingContext, element);\n                } else {\n                    ko.virtualElements.emptyNode(element);\n                }\n\n                withIfData.didDisplayOnLastUpdate = shouldDisplay;\n            }\n        }\n    };\n    ko.expressionRewriting.bindingRewriteValidators[bindingKey] = false; // Can't rewrite control flow bindings\n    ko.virtualElements.allowedBindings[bindingKey] = true;\n}\n\n// Construct the actual binding handlers\nmakeWithIfBinding('if');\nmakeWithIfBinding('ifnot', false /* isWith */, true /* isNot */);\nmakeWithIfBinding('with', true /* isWith */, false /* isNot */,\n    function(bindingContext, dataValue) {\n        return bindingContext['createChildContext'](dataValue);\n    }\n);\nfunction ensureDropdownSelectionIsConsistentWithModelValue(element, modelValue, preferModelValue) {\n    if (preferModelValue) {\n        if (modelValue !== ko.selectExtensions.readValue(element))\n            ko.selectExtensions.writeValue(element, modelValue);\n    }\n\n    // No matter which direction we're syncing in, we want the end result to be equality between dropdown value and model value.\n    // If they aren't equal, either we prefer the dropdown value, or the model value couldn't be represented, so either way,\n    // change the model value to match the dropdown.\n    if (modelValue !== ko.selectExtensions.readValue(element))\n        ko.dependencyDetection.ignore(ko.utils.triggerEvent, null, [element, \"change\"]);\n};\n\nko.bindingHandlers['options'] = {\n    'update': function (element, valueAccessor, allBindingsAccessor) {\n        if (ko.utils.tagNameLower(element) !== \"select\")\n            throw new Error(\"options binding applies only to SELECT elements\");\n\n        var selectWasPreviouslyEmpty = element.length == 0;\n        var previousSelectedValues = ko.utils.arrayMap(ko.utils.arrayFilter(element.childNodes, function (node) {\n            return node.tagName && (ko.utils.tagNameLower(node) === \"option\") && node.selected;\n        }), function (node) {\n            return ko.selectExtensions.readValue(node) || node.innerText || node.textContent;\n        });\n        var previousScrollTop = element.scrollTop;\n\n        var value = ko.utils.unwrapObservable(valueAccessor());\n        var selectedValue = element.value;\n\n        // Remove all existing <option>s.\n        // Need to use .remove() rather than .removeChild() for <option>s otherwise IE behaves oddly (https://github.com/SteveSanderson/knockout/issues/134)\n        while (element.length > 0) {\n            ko.cleanNode(element.options[0]);\n            element.remove(0);\n        }\n\n        if (value) {\n            var allBindings = allBindingsAccessor(),\n                includeDestroyed = allBindings['optionsIncludeDestroyed'];\n\n            if (typeof value.length != \"number\")\n                value = [value];\n            if (allBindings['optionsCaption']) {\n                var option = document.createElement(\"option\");\n                ko.utils.setHtml(option, allBindings['optionsCaption']);\n                ko.selectExtensions.writeValue(option, undefined);\n                element.appendChild(option);\n            }\n\n            for (var i = 0, j = value.length; i < j; i++) {\n                // Skip destroyed items\n                var arrayEntry = value[i];\n                if (arrayEntry && arrayEntry['_destroy'] && !includeDestroyed)\n                    continue;\n\n                var option = document.createElement(\"option\");\n\n                function applyToObject(object, predicate, defaultValue) {\n                    var predicateType = typeof predicate;\n                    if (predicateType == \"function\")    // Given a function; run it against the data value\n                        return predicate(object);\n                    else if (predicateType == \"string\") // Given a string; treat it as a property name on the data value\n                        return object[predicate];\n                    else                                // Given no optionsText arg; use the data value itself\n                        return defaultValue;\n                }\n\n                // Apply a value to the option element\n                var optionValue = applyToObject(arrayEntry, allBindings['optionsValue'], arrayEntry);\n                ko.selectExtensions.writeValue(option, ko.utils.unwrapObservable(optionValue));\n\n                // Apply some text to the option element\n                var optionText = applyToObject(arrayEntry, allBindings['optionsText'], optionValue);\n                ko.utils.setTextContent(option, optionText);\n\n                element.appendChild(option);\n            }\n\n            // IE6 doesn't like us to assign selection to OPTION nodes before they're added to the document.\n            // That's why we first added them without selection. Now it's time to set the selection.\n            var newOptions = element.getElementsByTagName(\"option\");\n            var countSelectionsRetained = 0;\n            for (var i = 0, j = newOptions.length; i < j; i++) {\n                if (ko.utils.arrayIndexOf(previousSelectedValues, ko.selectExtensions.readValue(newOptions[i])) >= 0) {\n                    ko.utils.setOptionNodeSelectionState(newOptions[i], true);\n                    countSelectionsRetained++;\n                }\n            }\n\n            element.scrollTop = previousScrollTop;\n\n            if (selectWasPreviouslyEmpty && ('value' in allBindings)) {\n                // Ensure consistency between model value and selected option.\n                // If the dropdown is being populated for the first time here (or was otherwise previously empty),\n                // the dropdown selection state is meaningless, so we preserve the model value.\n                ensureDropdownSelectionIsConsistentWithModelValue(element, ko.utils.peekObservable(allBindings['value']), /* preferModelValue */ true);\n            }\n\n            // Workaround for IE9 bug\n            ko.utils.ensureSelectElementIsRenderedCorrectly(element);\n        }\n    }\n};\nko.bindingHandlers['options'].optionValueDomDataKey = '__ko.optionValueDomData__';\nko.bindingHandlers['selectedOptions'] = {\n    'init': function (element, valueAccessor, allBindingsAccessor) {\n        ko.utils.registerEventHandler(element, \"change\", function () {\n            var value = valueAccessor(), valueToWrite = [];\n            ko.utils.arrayForEach(element.getElementsByTagName(\"option\"), function(node) {\n                if (node.selected)\n                    valueToWrite.push(ko.selectExtensions.readValue(node));\n            });\n            ko.expressionRewriting.writeValueToProperty(value, allBindingsAccessor, 'value', valueToWrite);\n        });\n    },\n    'update': function (element, valueAccessor) {\n        if (ko.utils.tagNameLower(element) != \"select\")\n            throw new Error(\"values binding applies only to SELECT elements\");\n\n        var newValue = ko.utils.unwrapObservable(valueAccessor());\n        if (newValue && typeof newValue.length == \"number\") {\n            ko.utils.arrayForEach(element.getElementsByTagName(\"option\"), function(node) {\n                var isSelected = ko.utils.arrayIndexOf(newValue, ko.selectExtensions.readValue(node)) >= 0;\n                ko.utils.setOptionNodeSelectionState(node, isSelected);\n            });\n        }\n    }\n};\nko.bindingHandlers['style'] = {\n    'update': function (element, valueAccessor) {\n        var value = ko.utils.unwrapObservable(valueAccessor() || {});\n        for (var styleName in value) {\n            if (typeof styleName == \"string\") {\n                var styleValue = ko.utils.unwrapObservable(value[styleName]);\n                element.style[styleName] = styleValue || \"\"; // Empty string removes the value, whereas null/undefined have no effect\n            }\n        }\n    }\n};\nko.bindingHandlers['submit'] = {\n    'init': function (element, valueAccessor, allBindingsAccessor, viewModel) {\n        if (typeof valueAccessor() != \"function\")\n            throw new Error(\"The value for a submit binding must be a function\");\n        ko.utils.registerEventHandler(element, \"submit\", function (event) {\n            var handlerReturnValue;\n            var value = valueAccessor();\n            try { handlerReturnValue = value.call(viewModel, element); }\n            finally {\n                if (handlerReturnValue !== true) { // Normally we want to prevent default action. Developer can override this be explicitly returning true.\n                    if (event.preventDefault)\n                        event.preventDefault();\n                    else\n                        event.returnValue = false;\n                }\n            }\n        });\n    }\n};\nko.bindingHandlers['text'] = {\n    'update': function (element, valueAccessor) {\n        ko.utils.setTextContent(element, valueAccessor());\n    }\n};\nko.virtualElements.allowedBindings['text'] = true;\nko.bindingHandlers['uniqueName'] = {\n    'init': function (element, valueAccessor) {\n        if (valueAccessor()) {\n            var name = \"ko_unique_\" + (++ko.bindingHandlers['uniqueName'].currentIndex);\n            ko.utils.setElementName(element, name);\n        }\n    }\n};\nko.bindingHandlers['uniqueName'].currentIndex = 0;\nko.bindingHandlers['value'] = {\n    'init': function (element, valueAccessor, allBindingsAccessor) {\n        // Always catch \"change\" event; possibly other events too if asked\n        var eventsToCatch = [\"change\"];\n        var requestedEventsToCatch = allBindingsAccessor()[\"valueUpdate\"];\n        var propertyChangedFired = false;\n        if (requestedEventsToCatch) {\n            if (typeof requestedEventsToCatch == \"string\") // Allow both individual event names, and arrays of event names\n                requestedEventsToCatch = [requestedEventsToCatch];\n            ko.utils.arrayPushAll(eventsToCatch, requestedEventsToCatch);\n            eventsToCatch = ko.utils.arrayGetDistinctValues(eventsToCatch);\n        }\n\n        var valueUpdateHandler = function() {\n            propertyChangedFired = false;\n            var modelValue = valueAccessor();\n            var elementValue = ko.selectExtensions.readValue(element);\n            ko.expressionRewriting.writeValueToProperty(modelValue, allBindingsAccessor, 'value', elementValue);\n        }\n\n        // Workaround for https://github.com/SteveSanderson/knockout/issues/122\n        // IE doesn't fire \"change\" events on textboxes if the user selects a value from its autocomplete list\n        var ieAutoCompleteHackNeeded = ko.utils.ieVersion && element.tagName.toLowerCase() == \"input\" && element.type == \"text\"\n                                       && element.autocomplete != \"off\" && (!element.form || element.form.autocomplete != \"off\");\n        if (ieAutoCompleteHackNeeded && ko.utils.arrayIndexOf(eventsToCatch, \"propertychange\") == -1) {\n            ko.utils.registerEventHandler(element, \"propertychange\", function () { propertyChangedFired = true });\n            ko.utils.registerEventHandler(element, \"blur\", function() {\n                if (propertyChangedFired) {\n                    valueUpdateHandler();\n                }\n            });\n        }\n\n        ko.utils.arrayForEach(eventsToCatch, function(eventName) {\n            // The syntax \"after<eventname>\" means \"run the handler asynchronously after the event\"\n            // This is useful, for example, to catch \"keydown\" events after the browser has updated the control\n            // (otherwise, ko.selectExtensions.readValue(this) will receive the control's value *before* the key event)\n            var handler = valueUpdateHandler;\n            if (ko.utils.stringStartsWith(eventName, \"after\")) {\n                handler = function() { setTimeout(valueUpdateHandler, 0) };\n                eventName = eventName.substring(\"after\".length);\n            }\n            ko.utils.registerEventHandler(element, eventName, handler);\n        });\n    },\n    'update': function (element, valueAccessor) {\n        var valueIsSelectOption = ko.utils.tagNameLower(element) === \"select\";\n        var newValue = ko.utils.unwrapObservable(valueAccessor());\n        var elementValue = ko.selectExtensions.readValue(element);\n        var valueHasChanged = (newValue != elementValue);\n\n        // JavaScript's 0 == \"\" behavious is unfortunate here as it prevents writing 0 to an empty text box (loose equality suggests the values are the same).\n        // We don't want to do a strict equality comparison as that is more confusing for developers in certain cases, so we specifically special case 0 != \"\" here.\n        if ((newValue === 0) && (elementValue !== 0) && (elementValue !== \"0\"))\n            valueHasChanged = true;\n\n        if (valueHasChanged) {\n            var applyValueAction = function () { ko.selectExtensions.writeValue(element, newValue); };\n            applyValueAction();\n\n            // Workaround for IE6 bug: It won't reliably apply values to SELECT nodes during the same execution thread\n            // right after you've changed the set of OPTION nodes on it. So for that node type, we'll schedule a second thread\n            // to apply the value as well.\n            var alsoApplyAsynchronously = valueIsSelectOption;\n            if (alsoApplyAsynchronously)\n                setTimeout(applyValueAction, 0);\n        }\n\n        // If you try to set a model value that can't be represented in an already-populated dropdown, reject that change,\n        // because you're not allowed to have a model value that disagrees with a visible UI selection.\n        if (valueIsSelectOption && (element.length > 0))\n            ensureDropdownSelectionIsConsistentWithModelValue(element, newValue, /* preferModelValue */ false);\n    }\n};\nko.bindingHandlers['visible'] = {\n    'update': function (element, valueAccessor) {\n        var value = ko.utils.unwrapObservable(valueAccessor());\n        var isCurrentlyVisible = !(element.style.display == \"none\");\n        if (value && !isCurrentlyVisible)\n            element.style.display = \"\";\n        else if ((!value) && isCurrentlyVisible)\n            element.style.display = \"none\";\n    }\n};\n// 'click' is just a shorthand for the usual full-length event:{click:handler}\nmakeEventHandlerShortcut('click');\n// If you want to make a custom template engine,\n//\n// [1] Inherit from this class (like ko.nativeTemplateEngine does)\n// [2] Override 'renderTemplateSource', supplying a function with this signature:\n//\n//        function (templateSource, bindingContext, options) {\n//            // - templateSource.text() is the text of the template you should render\n//            // - bindingContext.$data is the data you should pass into the template\n//            //   - you might also want to make bindingContext.$parent, bindingContext.$parents,\n//            //     and bindingContext.$root available in the template too\n//            // - options gives you access to any other properties set on \"data-bind: { template: options }\"\n//            //\n//            // Return value: an array of DOM nodes\n//        }\n//\n// [3] Override 'createJavaScriptEvaluatorBlock', supplying a function with this signature:\n//\n//        function (script) {\n//            // Return value: Whatever syntax means \"Evaluate the JavaScript statement 'script' and output the result\"\n//            //               For example, the jquery.tmpl template engine converts 'someScript' to '${ someScript }'\n//        }\n//\n//     This is only necessary if you want to allow data-bind attributes to reference arbitrary template variables.\n//     If you don't want to allow that, you can set the property 'allowTemplateRewriting' to false (like ko.nativeTemplateEngine does)\n//     and then you don't need to override 'createJavaScriptEvaluatorBlock'.\n\nko.templateEngine = function () { };\n\nko.templateEngine.prototype['renderTemplateSource'] = function (templateSource, bindingContext, options) {\n    throw new Error(\"Override renderTemplateSource\");\n};\n\nko.templateEngine.prototype['createJavaScriptEvaluatorBlock'] = function (script) {\n    throw new Error(\"Override createJavaScriptEvaluatorBlock\");\n};\n\nko.templateEngine.prototype['makeTemplateSource'] = function(template, templateDocument) {\n    // Named template\n    if (typeof template == \"string\") {\n        templateDocument = templateDocument || document;\n        var elem = templateDocument.getElementById(template);\n        if (!elem)\n            throw new Error(\"Cannot find template with ID \" + template);\n        return new ko.templateSources.domElement(elem);\n    } else if ((template.nodeType == 1) || (template.nodeType == 8)) {\n        // Anonymous template\n        return new ko.templateSources.anonymousTemplate(template);\n    } else\n        throw new Error(\"Unknown template type: \" + template);\n};\n\nko.templateEngine.prototype['renderTemplate'] = function (template, bindingContext, options, templateDocument) {\n    var templateSource = this['makeTemplateSource'](template, templateDocument);\n    return this['renderTemplateSource'](templateSource, bindingContext, options);\n};\n\nko.templateEngine.prototype['isTemplateRewritten'] = function (template, templateDocument) {\n    // Skip rewriting if requested\n    if (this['allowTemplateRewriting'] === false)\n        return true;\n    return this['makeTemplateSource'](template, templateDocument)['data'](\"isRewritten\");\n};\n\nko.templateEngine.prototype['rewriteTemplate'] = function (template, rewriterCallback, templateDocument) {\n    var templateSource = this['makeTemplateSource'](template, templateDocument);\n    var rewritten = rewriterCallback(templateSource['text']());\n    templateSource['text'](rewritten);\n    templateSource['data'](\"isRewritten\", true);\n};\n\nko.exportSymbol('templateEngine', ko.templateEngine);\n\nko.templateRewriting = (function () {\n    var memoizeDataBindingAttributeSyntaxRegex = /(<[a-z]+\\d*(\\s+(?!data-bind=)[a-z0-9\\-]+(=(\\\"[^\\\"]*\\\"|\\'[^\\']*\\'))?)*\\s+)data-bind=([\"'])([\\s\\S]*?)\\5/gi;\n    var memoizeVirtualContainerBindingSyntaxRegex = /<!--\\s*ko\\b\\s*([\\s\\S]*?)\\s*-->/g;\n\n    function validateDataBindValuesForRewriting(keyValueArray) {\n        var allValidators = ko.expressionRewriting.bindingRewriteValidators;\n        for (var i = 0; i < keyValueArray.length; i++) {\n            var key = keyValueArray[i]['key'];\n            if (allValidators.hasOwnProperty(key)) {\n                var validator = allValidators[key];\n\n                if (typeof validator === \"function\") {\n                    var possibleErrorMessage = validator(keyValueArray[i]['value']);\n                    if (possibleErrorMessage)\n                        throw new Error(possibleErrorMessage);\n                } else if (!validator) {\n                    throw new Error(\"This template engine does not support the '\" + key + \"' binding within its templates\");\n                }\n            }\n        }\n    }\n\n    function constructMemoizedTagReplacement(dataBindAttributeValue, tagToRetain, templateEngine) {\n        var dataBindKeyValueArray = ko.expressionRewriting.parseObjectLiteral(dataBindAttributeValue);\n        validateDataBindValuesForRewriting(dataBindKeyValueArray);\n        var rewrittenDataBindAttributeValue = ko.expressionRewriting.preProcessBindings(dataBindKeyValueArray);\n\n        // For no obvious reason, Opera fails to evaluate rewrittenDataBindAttributeValue unless it's wrapped in an additional\n        // anonymous function, even though Opera's built-in debugger can evaluate it anyway. No other browser requires this\n        // extra indirection.\n        var applyBindingsToNextSiblingScript =\n            \"ko.__tr_ambtns(function($context,$element){return(function(){return{ \" + rewrittenDataBindAttributeValue + \" } })()})\";\n        return templateEngine['createJavaScriptEvaluatorBlock'](applyBindingsToNextSiblingScript) + tagToRetain;\n    }\n\n    return {\n        ensureTemplateIsRewritten: function (template, templateEngine, templateDocument) {\n            if (!templateEngine['isTemplateRewritten'](template, templateDocument))\n                templateEngine['rewriteTemplate'](template, function (htmlString) {\n                    return ko.templateRewriting.memoizeBindingAttributeSyntax(htmlString, templateEngine);\n                }, templateDocument);\n        },\n\n        memoizeBindingAttributeSyntax: function (htmlString, templateEngine) {\n            return htmlString.replace(memoizeDataBindingAttributeSyntaxRegex, function () {\n                return constructMemoizedTagReplacement(/* dataBindAttributeValue: */ arguments[6], /* tagToRetain: */ arguments[1], templateEngine);\n            }).replace(memoizeVirtualContainerBindingSyntaxRegex, function() {\n                return constructMemoizedTagReplacement(/* dataBindAttributeValue: */ arguments[1], /* tagToRetain: */ \"<!-- ko -->\", templateEngine);\n            });\n        },\n\n        applyMemoizedBindingsToNextSibling: function (bindings) {\n            return ko.memoization.memoize(function (domNode, bindingContext) {\n                if (domNode.nextSibling)\n                    ko.applyBindingsToNode(domNode.nextSibling, bindings, bindingContext);\n            });\n        }\n    }\n})();\n\n\n// Exported only because it has to be referenced by string lookup from within rewritten template\nko.exportSymbol('__tr_ambtns', ko.templateRewriting.applyMemoizedBindingsToNextSibling);\n(function() {\n    // A template source represents a read/write way of accessing a template. This is to eliminate the need for template loading/saving\n    // logic to be duplicated in every template engine (and means they can all work with anonymous templates, etc.)\n    //\n    // Two are provided by default:\n    //  1. ko.templateSources.domElement       - reads/writes the text content of an arbitrary DOM element\n    //  2. ko.templateSources.anonymousElement - uses ko.utils.domData to read/write text *associated* with the DOM element, but\n    //                                           without reading/writing the actual element text content, since it will be overwritten\n    //                                           with the rendered template output.\n    // You can implement your own template source if you want to fetch/store templates somewhere other than in DOM elements.\n    // Template sources need to have the following functions:\n    //   text() \t\t\t- returns the template text from your storage location\n    //   text(value)\t\t- writes the supplied template text to your storage location\n    //   data(key)\t\t\t- reads values stored using data(key, value) - see below\n    //   data(key, value)\t- associates \"value\" with this template and the key \"key\". Is used to store information like \"isRewritten\".\n    //\n    // Optionally, template sources can also have the following functions:\n    //   nodes()            - returns a DOM element containing the nodes of this template, where available\n    //   nodes(value)       - writes the given DOM element to your storage location\n    // If a DOM element is available for a given template source, template engines are encouraged to use it in preference over text()\n    // for improved speed. However, all templateSources must supply text() even if they don't supply nodes().\n    //\n    // Once you've implemented a templateSource, make your template engine use it by subclassing whatever template engine you were\n    // using and overriding \"makeTemplateSource\" to return an instance of your custom template source.\n\n    ko.templateSources = {};\n\n    // ---- ko.templateSources.domElement -----\n\n    ko.templateSources.domElement = function(element) {\n        this.domElement = element;\n    }\n\n    ko.templateSources.domElement.prototype['text'] = function(/* valueToWrite */) {\n        var tagNameLower = ko.utils.tagNameLower(this.domElement),\n            elemContentsProperty = tagNameLower === \"script\" ? \"text\"\n                                 : tagNameLower === \"textarea\" ? \"value\"\n                                 : \"innerHTML\";\n\n        if (arguments.length == 0) {\n            return this.domElement[elemContentsProperty];\n        } else {\n            var valueToWrite = arguments[0];\n            if (elemContentsProperty === \"innerHTML\")\n                ko.utils.setHtml(this.domElement, valueToWrite);\n            else\n                this.domElement[elemContentsProperty] = valueToWrite;\n        }\n    };\n\n    ko.templateSources.domElement.prototype['data'] = function(key /*, valueToWrite */) {\n        if (arguments.length === 1) {\n            return ko.utils.domData.get(this.domElement, \"templateSourceData_\" + key);\n        } else {\n            ko.utils.domData.set(this.domElement, \"templateSourceData_\" + key, arguments[1]);\n        }\n    };\n\n    // ---- ko.templateSources.anonymousTemplate -----\n    // Anonymous templates are normally saved/retrieved as DOM nodes through \"nodes\".\n    // For compatibility, you can also read \"text\"; it will be serialized from the nodes on demand.\n    // Writing to \"text\" is still supported, but then the template data will not be available as DOM nodes.\n\n    var anonymousTemplatesDomDataKey = \"__ko_anon_template__\";\n    ko.templateSources.anonymousTemplate = function(element) {\n        this.domElement = element;\n    }\n    ko.templateSources.anonymousTemplate.prototype = new ko.templateSources.domElement();\n    ko.templateSources.anonymousTemplate.prototype['text'] = function(/* valueToWrite */) {\n        if (arguments.length == 0) {\n            var templateData = ko.utils.domData.get(this.domElement, anonymousTemplatesDomDataKey) || {};\n            if (templateData.textData === undefined && templateData.containerData)\n                templateData.textData = templateData.containerData.innerHTML;\n            return templateData.textData;\n        } else {\n            var valueToWrite = arguments[0];\n            ko.utils.domData.set(this.domElement, anonymousTemplatesDomDataKey, {textData: valueToWrite});\n        }\n    };\n    ko.templateSources.domElement.prototype['nodes'] = function(/* valueToWrite */) {\n        if (arguments.length == 0) {\n            var templateData = ko.utils.domData.get(this.domElement, anonymousTemplatesDomDataKey) || {};\n            return templateData.containerData;\n        } else {\n            var valueToWrite = arguments[0];\n            ko.utils.domData.set(this.domElement, anonymousTemplatesDomDataKey, {containerData: valueToWrite});\n        }\n    };\n\n    ko.exportSymbol('templateSources', ko.templateSources);\n    ko.exportSymbol('templateSources.domElement', ko.templateSources.domElement);\n    ko.exportSymbol('templateSources.anonymousTemplate', ko.templateSources.anonymousTemplate);\n})();\n(function () {\n    var _templateEngine;\n    ko.setTemplateEngine = function (templateEngine) {\n        if ((templateEngine != undefined) && !(templateEngine instanceof ko.templateEngine))\n            throw new Error(\"templateEngine must inherit from ko.templateEngine\");\n        _templateEngine = templateEngine;\n    }\n\n    function invokeForEachNodeOrCommentInContinuousRange(firstNode, lastNode, action) {\n        var node, nextInQueue = firstNode, firstOutOfRangeNode = ko.virtualElements.nextSibling(lastNode);\n        while (nextInQueue && ((node = nextInQueue) !== firstOutOfRangeNode)) {\n            nextInQueue = ko.virtualElements.nextSibling(node);\n            if (node.nodeType === 1 || node.nodeType === 8)\n                action(node);\n        }\n    }\n\n    function activateBindingsOnContinuousNodeArray(continuousNodeArray, bindingContext) {\n        // To be used on any nodes that have been rendered by a template and have been inserted into some parent element\n        // Walks through continuousNodeArray (which *must* be continuous, i.e., an uninterrupted sequence of sibling nodes, because\n        // the algorithm for walking them relies on this), and for each top-level item in the virtual-element sense,\n        // (1) Does a regular \"applyBindings\" to associate bindingContext with this node and to activate any non-memoized bindings\n        // (2) Unmemoizes any memos in the DOM subtree (e.g., to activate bindings that had been memoized during template rewriting)\n\n        if (continuousNodeArray.length) {\n            var firstNode = continuousNodeArray[0], lastNode = continuousNodeArray[continuousNodeArray.length - 1];\n\n            // Need to applyBindings *before* unmemoziation, because unmemoization might introduce extra nodes (that we don't want to re-bind)\n            // whereas a regular applyBindings won't introduce new memoized nodes\n            invokeForEachNodeOrCommentInContinuousRange(firstNode, lastNode, function(node) {\n                ko.applyBindings(bindingContext, node);\n            });\n            invokeForEachNodeOrCommentInContinuousRange(firstNode, lastNode, function(node) {\n                ko.memoization.unmemoizeDomNodeAndDescendants(node, [bindingContext]);\n            });\n        }\n    }\n\n    function getFirstNodeFromPossibleArray(nodeOrNodeArray) {\n        return nodeOrNodeArray.nodeType ? nodeOrNodeArray\n                                        : nodeOrNodeArray.length > 0 ? nodeOrNodeArray[0]\n                                        : null;\n    }\n\n    function executeTemplate(targetNodeOrNodeArray, renderMode, template, bindingContext, options) {\n        options = options || {};\n        var firstTargetNode = targetNodeOrNodeArray && getFirstNodeFromPossibleArray(targetNodeOrNodeArray);\n        var templateDocument = firstTargetNode && firstTargetNode.ownerDocument;\n        var templateEngineToUse = (options['templateEngine'] || _templateEngine);\n        ko.templateRewriting.ensureTemplateIsRewritten(template, templateEngineToUse, templateDocument);\n        var renderedNodesArray = templateEngineToUse['renderTemplate'](template, bindingContext, options, templateDocument);\n\n        // Loosely check result is an array of DOM nodes\n        if ((typeof renderedNodesArray.length != \"number\") || (renderedNodesArray.length > 0 && typeof renderedNodesArray[0].nodeType != \"number\"))\n            throw new Error(\"Template engine must return an array of DOM nodes\");\n\n        var haveAddedNodesToParent = false;\n        switch (renderMode) {\n            case \"replaceChildren\":\n                ko.virtualElements.setDomNodeChildren(targetNodeOrNodeArray, renderedNodesArray);\n                haveAddedNodesToParent = true;\n                break;\n            case \"replaceNode\":\n                ko.utils.replaceDomNodes(targetNodeOrNodeArray, renderedNodesArray);\n                haveAddedNodesToParent = true;\n                break;\n            case \"ignoreTargetNode\": break;\n            default:\n                throw new Error(\"Unknown renderMode: \" + renderMode);\n        }\n\n        if (haveAddedNodesToParent) {\n            activateBindingsOnContinuousNodeArray(renderedNodesArray, bindingContext);\n            if (options['afterRender'])\n                ko.dependencyDetection.ignore(options['afterRender'], null, [renderedNodesArray, bindingContext['$data']]);\n        }\n\n        return renderedNodesArray;\n    }\n\n    ko.renderTemplate = function (template, dataOrBindingContext, options, targetNodeOrNodeArray, renderMode) {\n        options = options || {};\n        if ((options['templateEngine'] || _templateEngine) == undefined)\n            throw new Error(\"Set a template engine before calling renderTemplate\");\n        renderMode = renderMode || \"replaceChildren\";\n\n        if (targetNodeOrNodeArray) {\n            var firstTargetNode = getFirstNodeFromPossibleArray(targetNodeOrNodeArray);\n\n            var whenToDispose = function () { return (!firstTargetNode) || !ko.utils.domNodeIsAttachedToDocument(firstTargetNode); }; // Passive disposal (on next evaluation)\n            var activelyDisposeWhenNodeIsRemoved = (firstTargetNode && renderMode == \"replaceNode\") ? firstTargetNode.parentNode : firstTargetNode;\n\n            return ko.dependentObservable( // So the DOM is automatically updated when any dependency changes\n                function () {\n                    // Ensure we've got a proper binding context to work with\n                    var bindingContext = (dataOrBindingContext && (dataOrBindingContext instanceof ko.bindingContext))\n                        ? dataOrBindingContext\n                        : new ko.bindingContext(ko.utils.unwrapObservable(dataOrBindingContext));\n\n                    // Support selecting template as a function of the data being rendered\n                    var templateName = typeof(template) == 'function' ? template(bindingContext['$data'], bindingContext) : template;\n\n                    var renderedNodesArray = executeTemplate(targetNodeOrNodeArray, renderMode, templateName, bindingContext, options);\n                    if (renderMode == \"replaceNode\") {\n                        targetNodeOrNodeArray = renderedNodesArray;\n                        firstTargetNode = getFirstNodeFromPossibleArray(targetNodeOrNodeArray);\n                    }\n                },\n                null,\n                { disposeWhen: whenToDispose, disposeWhenNodeIsRemoved: activelyDisposeWhenNodeIsRemoved }\n            );\n        } else {\n            // We don't yet have a DOM node to evaluate, so use a memo and render the template later when there is a DOM node\n            return ko.memoization.memoize(function (domNode) {\n                ko.renderTemplate(template, dataOrBindingContext, options, domNode, \"replaceNode\");\n            });\n        }\n    };\n\n    ko.renderTemplateForEach = function (template, arrayOrObservableArray, options, targetNode, parentBindingContext) {\n        // Since setDomNodeChildrenFromArrayMapping always calls executeTemplateForArrayItem and then\n        // activateBindingsCallback for added items, we can store the binding context in the former to use in the latter.\n        var arrayItemContext;\n\n        // This will be called by setDomNodeChildrenFromArrayMapping to get the nodes to add to targetNode\n        var executeTemplateForArrayItem = function (arrayValue, index) {\n            // Support selecting template as a function of the data being rendered\n            arrayItemContext = parentBindingContext['createChildContext'](ko.utils.unwrapObservable(arrayValue), options['as']);\n            arrayItemContext['$index'] = index;\n            var templateName = typeof(template) == 'function' ? template(arrayValue, arrayItemContext) : template;\n            return executeTemplate(null, \"ignoreTargetNode\", templateName, arrayItemContext, options);\n        }\n\n        // This will be called whenever setDomNodeChildrenFromArrayMapping has added nodes to targetNode\n        var activateBindingsCallback = function(arrayValue, addedNodesArray, index) {\n            activateBindingsOnContinuousNodeArray(addedNodesArray, arrayItemContext);\n            if (options['afterRender'])\n                options['afterRender'](addedNodesArray, arrayValue);\n        };\n\n        return ko.dependentObservable(function () {\n            var unwrappedArray = ko.utils.unwrapObservable(arrayOrObservableArray) || [];\n            if (typeof unwrappedArray.length == \"undefined\") // Coerce single value into array\n                unwrappedArray = [unwrappedArray];\n\n            // Filter out any entries marked as destroyed\n            var filteredArray = ko.utils.arrayFilter(unwrappedArray, function(item) {\n                return options['includeDestroyed'] || item === undefined || item === null || !ko.utils.unwrapObservable(item['_destroy']);\n            });\n\n            // Call setDomNodeChildrenFromArrayMapping, ignoring any observables unwrapped within (most likely from a callback function).\n            // If the array items are observables, though, they will be unwrapped in executeTemplateForArrayItem and managed within setDomNodeChildrenFromArrayMapping.\n            ko.dependencyDetection.ignore(ko.utils.setDomNodeChildrenFromArrayMapping, null, [targetNode, filteredArray, executeTemplateForArrayItem, options, activateBindingsCallback]);\n\n        }, null, { disposeWhenNodeIsRemoved: targetNode });\n    };\n\n    var templateComputedDomDataKey = '__ko__templateComputedDomDataKey__';\n    function disposeOldComputedAndStoreNewOne(element, newComputed) {\n        var oldComputed = ko.utils.domData.get(element, templateComputedDomDataKey);\n        if (oldComputed && (typeof(oldComputed.dispose) == 'function'))\n            oldComputed.dispose();\n        ko.utils.domData.set(element, templateComputedDomDataKey, (newComputed && newComputed.isActive()) ? newComputed : undefined);\n    }\n\n    ko.bindingHandlers['template'] = {\n        'init': function(element, valueAccessor) {\n            // Support anonymous templates\n            var bindingValue = ko.utils.unwrapObservable(valueAccessor());\n            if ((typeof bindingValue != \"string\") && (!bindingValue['name']) && (element.nodeType == 1 || element.nodeType == 8)) {\n                // It's an anonymous template - store the element contents, then clear the element\n                var templateNodes = element.nodeType == 1 ? element.childNodes : ko.virtualElements.childNodes(element),\n                    container = ko.utils.moveCleanedNodesToContainerElement(templateNodes); // This also removes the nodes from their current parent\n                new ko.templateSources.anonymousTemplate(element)['nodes'](container);\n            }\n            return { 'controlsDescendantBindings': true };\n        },\n        'update': function (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {\n            var templateName = ko.utils.unwrapObservable(valueAccessor()),\n                options = {},\n                shouldDisplay = true,\n                dataValue,\n                templateComputed = null;\n\n            if (typeof templateName != \"string\") {\n                options = templateName;\n                templateName = options['name'];\n\n                // Support \"if\"/\"ifnot\" conditions\n                if ('if' in options)\n                    shouldDisplay = ko.utils.unwrapObservable(options['if']);\n                if (shouldDisplay && 'ifnot' in options)\n                    shouldDisplay = !ko.utils.unwrapObservable(options['ifnot']);\n\n                dataValue = ko.utils.unwrapObservable(options['data']);\n            }\n\n            if ('foreach' in options) {\n                // Render once for each data point (treating data set as empty if shouldDisplay==false)\n                var dataArray = (shouldDisplay && options['foreach']) || [];\n                templateComputed = ko.renderTemplateForEach(templateName || element, dataArray, options, element, bindingContext);\n            } else if (!shouldDisplay) {\n                ko.virtualElements.emptyNode(element);\n            } else {\n                // Render once for this single data point (or use the viewModel if no data was provided)\n                var innerBindingContext = ('data' in options) ?\n                    bindingContext['createChildContext'](dataValue, options['as']) :  // Given an explitit 'data' value, we create a child binding context for it\n                    bindingContext;                                                        // Given no explicit 'data' value, we retain the same binding context\n                templateComputed = ko.renderTemplate(templateName || element, innerBindingContext, options, element);\n            }\n\n            // It only makes sense to have a single template computed per element (otherwise which one should have its output displayed?)\n            disposeOldComputedAndStoreNewOne(element, templateComputed);\n        }\n    };\n\n    // Anonymous templates can't be rewritten. Give a nice error message if you try to do it.\n    ko.expressionRewriting.bindingRewriteValidators['template'] = function(bindingValue) {\n        var parsedBindingValue = ko.expressionRewriting.parseObjectLiteral(bindingValue);\n\n        if ((parsedBindingValue.length == 1) && parsedBindingValue[0]['unknown'])\n            return null; // It looks like a string literal, not an object literal, so treat it as a named template (which is allowed for rewriting)\n\n        if (ko.expressionRewriting.keyValueArrayContainsKey(parsedBindingValue, \"name\"))\n            return null; // Named templates can be rewritten, so return \"no error\"\n        return \"This template engine does not support anonymous templates nested within its templates\";\n    };\n\n    ko.virtualElements.allowedBindings['template'] = true;\n})();\n\nko.exportSymbol('setTemplateEngine', ko.setTemplateEngine);\nko.exportSymbol('renderTemplate', ko.renderTemplate);\n\nko.utils.compareArrays = (function () {\n    var statusNotInOld = 'added', statusNotInNew = 'deleted';\n\n    // Simple calculation based on Levenshtein distance.\n    function compareArrays(oldArray, newArray, dontLimitMoves) {\n        oldArray = oldArray || [];\n        newArray = newArray || [];\n\n        if (oldArray.length <= newArray.length)\n            return compareSmallArrayToBigArray(oldArray, newArray, statusNotInOld, statusNotInNew, dontLimitMoves);\n        else\n            return compareSmallArrayToBigArray(newArray, oldArray, statusNotInNew, statusNotInOld, dontLimitMoves);\n    }\n\n    function compareSmallArrayToBigArray(smlArray, bigArray, statusNotInSml, statusNotInBig, dontLimitMoves) {\n        var myMin = Math.min,\n            myMax = Math.max,\n            editDistanceMatrix = [],\n            smlIndex, smlIndexMax = smlArray.length,\n            bigIndex, bigIndexMax = bigArray.length,\n            compareRange = (bigIndexMax - smlIndexMax) || 1,\n            maxDistance = smlIndexMax + bigIndexMax + 1,\n            thisRow, lastRow,\n            bigIndexMaxForRow, bigIndexMinForRow;\n\n        for (smlIndex = 0; smlIndex <= smlIndexMax; smlIndex++) {\n            lastRow = thisRow;\n            editDistanceMatrix.push(thisRow = []);\n            bigIndexMaxForRow = myMin(bigIndexMax, smlIndex + compareRange);\n            bigIndexMinForRow = myMax(0, smlIndex - 1);\n            for (bigIndex = bigIndexMinForRow; bigIndex <= bigIndexMaxForRow; bigIndex++) {\n                if (!bigIndex)\n                    thisRow[bigIndex] = smlIndex + 1;\n                else if (!smlIndex)  // Top row - transform empty array into new array via additions\n                    thisRow[bigIndex] = bigIndex + 1;\n                else if (smlArray[smlIndex - 1] === bigArray[bigIndex - 1])\n                    thisRow[bigIndex] = lastRow[bigIndex - 1];                  // copy value (no edit)\n                else {\n                    var northDistance = lastRow[bigIndex] || maxDistance;       // not in big (deletion)\n                    var westDistance = thisRow[bigIndex - 1] || maxDistance;    // not in small (addition)\n                    thisRow[bigIndex] = myMin(northDistance, westDistance) + 1;\n                }\n            }\n        }\n\n        var editScript = [], meMinusOne, notInSml = [], notInBig = [];\n        for (smlIndex = smlIndexMax, bigIndex = bigIndexMax; smlIndex || bigIndex;) {\n            meMinusOne = editDistanceMatrix[smlIndex][bigIndex] - 1;\n            if (bigIndex && meMinusOne === editDistanceMatrix[smlIndex][bigIndex-1]) {\n                notInSml.push(editScript[editScript.length] = {     // added\n                    'status': statusNotInSml,\n                    'value': bigArray[--bigIndex],\n                    'index': bigIndex });\n            } else if (smlIndex && meMinusOne === editDistanceMatrix[smlIndex - 1][bigIndex]) {\n                notInBig.push(editScript[editScript.length] = {     // deleted\n                    'status': statusNotInBig,\n                    'value': smlArray[--smlIndex],\n                    'index': smlIndex });\n            } else {\n                editScript.push({\n                    'status': \"retained\",\n                    'value': bigArray[--bigIndex] });\n                --smlIndex;\n            }\n        }\n\n        if (notInSml.length && notInBig.length) {\n            // Set a limit on the number of consecutive non-matching comparisons; having it a multiple of\n            // smlIndexMax keeps the time complexity of this algorithm linear.\n            var limitFailedCompares = smlIndexMax * 10, failedCompares,\n                a, d, notInSmlItem, notInBigItem;\n            // Go through the items that have been added and deleted and try to find matches between them.\n            for (failedCompares = a = 0; (dontLimitMoves || failedCompares < limitFailedCompares) && (notInSmlItem = notInSml[a]); a++) {\n                for (d = 0; notInBigItem = notInBig[d]; d++) {\n                    if (notInSmlItem['value'] === notInBigItem['value']) {\n                        notInSmlItem['moved'] = notInBigItem['index'];\n                        notInBigItem['moved'] = notInSmlItem['index'];\n                        notInBig.splice(d,1);       // This item is marked as moved; so remove it from notInBig list\n                        failedCompares = d = 0;     // Reset failed compares count because we're checking for consecutive failures\n                        break;\n                    }\n                }\n                failedCompares += d;\n            }\n        }\n        return editScript.reverse();\n    }\n\n    return compareArrays;\n})();\n\nko.exportSymbol('utils.compareArrays', ko.utils.compareArrays);\n\n(function () {\n    // Objective:\n    // * Given an input array, a container DOM node, and a function from array elements to arrays of DOM nodes,\n    //   map the array elements to arrays of DOM nodes, concatenate together all these arrays, and use them to populate the container DOM node\n    // * Next time we're given the same combination of things (with the array possibly having mutated), update the container DOM node\n    //   so that its children is again the concatenation of the mappings of the array elements, but don't re-map any array elements that we\n    //   previously mapped - retain those nodes, and just insert/delete other ones\n\n    // \"callbackAfterAddingNodes\" will be invoked after any \"mapping\"-generated nodes are inserted into the container node\n    // You can use this, for example, to activate bindings on those nodes.\n\n    function fixUpNodesToBeMovedOrRemoved(contiguousNodeArray) {\n        // Before moving, deleting, or replacing a set of nodes that were previously outputted by the \"map\" function, we have to reconcile\n        // them against what is in the DOM right now. It may be that some of the nodes have already been removed from the document,\n        // or that new nodes might have been inserted in the middle, for example by a binding. Also, there may previously have been\n        // leading comment nodes (created by rewritten string-based templates) that have since been removed during binding.\n        // So, this function translates the old \"map\" output array into its best guess of what set of current DOM nodes should be removed.\n        //\n        // Rules:\n        //   [A] Any leading nodes that aren't in the document any more should be ignored\n        //       These most likely correspond to memoization nodes that were already removed during binding\n        //       See https://github.com/SteveSanderson/knockout/pull/440\n        //   [B] We want to output a contiguous series of nodes that are still in the document. So, ignore any nodes that\n        //       have already been removed, and include any nodes that have been inserted among the previous collection\n\n        // Rule [A]\n        while (contiguousNodeArray.length && !ko.utils.domNodeIsAttachedToDocument(contiguousNodeArray[0]))\n            contiguousNodeArray.splice(0, 1);\n\n        // Rule [B]\n        if (contiguousNodeArray.length > 1) {\n            // Build up the actual new contiguous node set\n            var current = contiguousNodeArray[0], last = contiguousNodeArray[contiguousNodeArray.length - 1], newContiguousSet = [current];\n            while (current !== last) {\n                current = current.nextSibling;\n                if (!current) // Won't happen, except if the developer has manually removed some DOM elements (then we're in an undefined scenario)\n                    return;\n                newContiguousSet.push(current);\n            }\n\n            // ... then mutate the input array to match this.\n            // (The following line replaces the contents of contiguousNodeArray with newContiguousSet)\n            Array.prototype.splice.apply(contiguousNodeArray, [0, contiguousNodeArray.length].concat(newContiguousSet));\n        }\n        return contiguousNodeArray;\n    }\n\n    function mapNodeAndRefreshWhenChanged(containerNode, mapping, valueToMap, callbackAfterAddingNodes, index) {\n        // Map this array value inside a dependentObservable so we re-map when any dependency changes\n        var mappedNodes = [];\n        var dependentObservable = ko.dependentObservable(function() {\n            var newMappedNodes = mapping(valueToMap, index) || [];\n\n            // On subsequent evaluations, just replace the previously-inserted DOM nodes\n            if (mappedNodes.length > 0) {\n                ko.utils.replaceDomNodes(fixUpNodesToBeMovedOrRemoved(mappedNodes), newMappedNodes);\n                if (callbackAfterAddingNodes)\n                    ko.dependencyDetection.ignore(callbackAfterAddingNodes, null, [valueToMap, newMappedNodes, index]);\n            }\n\n            // Replace the contents of the mappedNodes array, thereby updating the record\n            // of which nodes would be deleted if valueToMap was itself later removed\n            mappedNodes.splice(0, mappedNodes.length);\n            ko.utils.arrayPushAll(mappedNodes, newMappedNodes);\n        }, null, { disposeWhenNodeIsRemoved: containerNode, disposeWhen: function() { return (mappedNodes.length == 0) || !ko.utils.domNodeIsAttachedToDocument(mappedNodes[0]) } });\n        return { mappedNodes : mappedNodes, dependentObservable : (dependentObservable.isActive() ? dependentObservable : undefined) };\n    }\n\n    var lastMappingResultDomDataKey = \"setDomNodeChildrenFromArrayMapping_lastMappingResult\";\n\n    ko.utils.setDomNodeChildrenFromArrayMapping = function (domNode, array, mapping, options, callbackAfterAddingNodes) {\n        // Compare the provided array against the previous one\n        array = array || [];\n        options = options || {};\n        var isFirstExecution = ko.utils.domData.get(domNode, lastMappingResultDomDataKey) === undefined;\n        var lastMappingResult = ko.utils.domData.get(domNode, lastMappingResultDomDataKey) || [];\n        var lastArray = ko.utils.arrayMap(lastMappingResult, function (x) { return x.arrayEntry; });\n        var editScript = ko.utils.compareArrays(lastArray, array);\n\n        // Build the new mapping result\n        var newMappingResult = [];\n        var lastMappingResultIndex = 0;\n        var newMappingResultIndex = 0;\n\n        var nodesToDelete = [];\n        var itemsToProcess = [];\n        var itemsForBeforeRemoveCallbacks = [];\n        var itemsForMoveCallbacks = [];\n        var itemsForAfterAddCallbacks = [];\n        var mapData;\n\n        function itemMovedOrRetained(editScriptIndex, oldPosition) {\n            mapData = lastMappingResult[oldPosition];\n            if (newMappingResultIndex !== oldPosition)\n                itemsForMoveCallbacks[editScriptIndex] = mapData;\n            // Since updating the index might change the nodes, do so before calling fixUpNodesToBeMovedOrRemoved\n            mapData.indexObservable(newMappingResultIndex++);\n            fixUpNodesToBeMovedOrRemoved(mapData.mappedNodes);\n            newMappingResult.push(mapData);\n            itemsToProcess.push(mapData);\n        }\n\n        function callCallback(callback, items) {\n            if (callback) {\n                for (var i = 0, n = items.length; i < n; i++) {\n                    if (items[i]) {\n                        ko.utils.arrayForEach(items[i].mappedNodes, function(node) {\n                            callback(node, i, items[i].arrayEntry);\n                        });\n                    }\n                }\n            }\n        }\n\n        for (var i = 0, editScriptItem, movedIndex; editScriptItem = editScript[i]; i++) {\n            movedIndex = editScriptItem['moved'];\n            switch (editScriptItem['status']) {\n                case \"deleted\":\n                    if (movedIndex === undefined) {\n                        mapData = lastMappingResult[lastMappingResultIndex];\n\n                        // Stop tracking changes to the mapping for these nodes\n                        if (mapData.dependentObservable)\n                            mapData.dependentObservable.dispose();\n\n                        // Queue these nodes for later removal\n                        nodesToDelete.push.apply(nodesToDelete, fixUpNodesToBeMovedOrRemoved(mapData.mappedNodes));\n                        if (options['beforeRemove']) {\n                            itemsForBeforeRemoveCallbacks[i] = mapData;\n                            itemsToProcess.push(mapData);\n                        }\n                    }\n                    lastMappingResultIndex++;\n                    break;\n\n                case \"retained\":\n                    itemMovedOrRetained(i, lastMappingResultIndex++);\n                    break;\n\n                case \"added\":\n                    if (movedIndex !== undefined) {\n                        itemMovedOrRetained(i, movedIndex);\n                    } else {\n                        mapData = { arrayEntry: editScriptItem['value'], indexObservable: ko.observable(newMappingResultIndex++) };\n                        newMappingResult.push(mapData);\n                        itemsToProcess.push(mapData);\n                        if (!isFirstExecution)\n                            itemsForAfterAddCallbacks[i] = mapData;\n                    }\n                    break;\n            }\n        }\n\n        // Call beforeMove first before any changes have been made to the DOM\n        callCallback(options['beforeMove'], itemsForMoveCallbacks);\n\n        // Next remove nodes for deleted items (or just clean if there's a beforeRemove callback)\n        ko.utils.arrayForEach(nodesToDelete, options['beforeRemove'] ? ko.cleanNode : ko.removeNode);\n\n        // Next add/reorder the remaining items (will include deleted items if there's a beforeRemove callback)\n        for (var i = 0, nextNode = ko.virtualElements.firstChild(domNode), lastNode, node; mapData = itemsToProcess[i]; i++) {\n            // Get nodes for newly added items\n            if (!mapData.mappedNodes)\n                ko.utils.extend(mapData, mapNodeAndRefreshWhenChanged(domNode, mapping, mapData.arrayEntry, callbackAfterAddingNodes, mapData.indexObservable));\n\n            // Put nodes in the right place if they aren't there already\n            for (var j = 0; node = mapData.mappedNodes[j]; nextNode = node.nextSibling, lastNode = node, j++) {\n                if (node !== nextNode)\n                    ko.virtualElements.insertAfter(domNode, node, lastNode);\n            }\n\n            // Run the callbacks for newly added nodes (for example, to apply bindings, etc.)\n            if (!mapData.initialized && callbackAfterAddingNodes) {\n                callbackAfterAddingNodes(mapData.arrayEntry, mapData.mappedNodes, mapData.indexObservable);\n                mapData.initialized = true;\n            }\n        }\n\n        // If there's a beforeRemove callback, call it after reordering.\n        // Note that we assume that the beforeRemove callback will usually be used to remove the nodes using\n        // some sort of animation, which is why we first reorder the nodes that will be removed. If the\n        // callback instead removes the nodes right away, it would be more efficient to skip reordering them.\n        // Perhaps we'll make that change in the future if this scenario becomes more common.\n        callCallback(options['beforeRemove'], itemsForBeforeRemoveCallbacks);\n\n        // Finally call afterMove and afterAdd callbacks\n        callCallback(options['afterMove'], itemsForMoveCallbacks);\n        callCallback(options['afterAdd'], itemsForAfterAddCallbacks);\n\n        // Store a copy of the array items we just considered so we can difference it next time\n        ko.utils.domData.set(domNode, lastMappingResultDomDataKey, newMappingResult);\n    }\n})();\n\nko.exportSymbol('utils.setDomNodeChildrenFromArrayMapping', ko.utils.setDomNodeChildrenFromArrayMapping);\nko.nativeTemplateEngine = function () {\n    this['allowTemplateRewriting'] = false;\n}\n\nko.nativeTemplateEngine.prototype = new ko.templateEngine();\nko.nativeTemplateEngine.prototype['renderTemplateSource'] = function (templateSource, bindingContext, options) {\n    var useNodesIfAvailable = !(ko.utils.ieVersion < 9), // IE<9 cloneNode doesn't work properly\n        templateNodesFunc = useNodesIfAvailable ? templateSource['nodes'] : null,\n        templateNodes = templateNodesFunc ? templateSource['nodes']() : null;\n\n    if (templateNodes) {\n        return ko.utils.makeArray(templateNodes.cloneNode(true).childNodes);\n    } else {\n        var templateText = templateSource['text']();\n        return ko.utils.parseHtmlFragment(templateText);\n    }\n};\n\nko.nativeTemplateEngine.instance = new ko.nativeTemplateEngine();\nko.setTemplateEngine(ko.nativeTemplateEngine.instance);\n\nko.exportSymbol('nativeTemplateEngine', ko.nativeTemplateEngine);\n(function() {\n    ko.jqueryTmplTemplateEngine = function () {\n        // Detect which version of jquery-tmpl you're using. Unfortunately jquery-tmpl\n        // doesn't expose a version number, so we have to infer it.\n        // Note that as of Knockout 1.3, we only support jQuery.tmpl 1.0.0pre and later,\n        // which KO internally refers to as version \"2\", so older versions are no longer detected.\n        var jQueryTmplVersion = this.jQueryTmplVersion = (function() {\n            if ((typeof(jQuery) == \"undefined\") || !(jQuery['tmpl']))\n                return 0;\n            // Since it exposes no official version number, we use our own numbering system. To be updated as jquery-tmpl evolves.\n            try {\n                if (jQuery['tmpl']['tag']['tmpl']['open'].toString().indexOf('__') >= 0) {\n                    // Since 1.0.0pre, custom tags should append markup to an array called \"__\"\n                    return 2; // Final version of jquery.tmpl\n                }\n            } catch(ex) { /* Apparently not the version we were looking for */ }\n\n            return 1; // Any older version that we don't support\n        })();\n\n        function ensureHasReferencedJQueryTemplates() {\n            if (jQueryTmplVersion < 2)\n                throw new Error(\"Your version of jQuery.tmpl is too old. Please upgrade to jQuery.tmpl 1.0.0pre or later.\");\n        }\n\n        function executeTemplate(compiledTemplate, data, jQueryTemplateOptions) {\n            return jQuery['tmpl'](compiledTemplate, data, jQueryTemplateOptions);\n        }\n\n        this['renderTemplateSource'] = function(templateSource, bindingContext, options) {\n            options = options || {};\n            ensureHasReferencedJQueryTemplates();\n\n            // Ensure we have stored a precompiled version of this template (don't want to reparse on every render)\n            var precompiled = templateSource['data']('precompiled');\n            if (!precompiled) {\n                var templateText = templateSource['text']() || \"\";\n                // Wrap in \"with($whatever.koBindingContext) { ... }\"\n                templateText = \"{{ko_with $item.koBindingContext}}\" + templateText + \"{{/ko_with}}\";\n\n                precompiled = jQuery['template'](null, templateText);\n                templateSource['data']('precompiled', precompiled);\n            }\n\n            var data = [bindingContext['$data']]; // Prewrap the data in an array to stop jquery.tmpl from trying to unwrap any arrays\n            var jQueryTemplateOptions = jQuery['extend']({ 'koBindingContext': bindingContext }, options['templateOptions']);\n\n            var resultNodes = executeTemplate(precompiled, data, jQueryTemplateOptions);\n            resultNodes['appendTo'](document.createElement(\"div\")); // Using \"appendTo\" forces jQuery/jQuery.tmpl to perform necessary cleanup work\n\n            jQuery['fragments'] = {}; // Clear jQuery's fragment cache to avoid a memory leak after a large number of template renders\n            return resultNodes;\n        };\n\n        this['createJavaScriptEvaluatorBlock'] = function(script) {\n            return \"{{ko_code ((function() { return \" + script + \" })()) }}\";\n        };\n\n        this['addTemplate'] = function(templateName, templateMarkup) {\n            document.write(\"<script type='text/html' id='\" + templateName + \"'>\" + templateMarkup + \"</script>\");\n        };\n\n        if (jQueryTmplVersion > 0) {\n            jQuery['tmpl']['tag']['ko_code'] = {\n                open: \"__.push($1 || '');\"\n            };\n            jQuery['tmpl']['tag']['ko_with'] = {\n                open: \"with($1) {\",\n                close: \"} \"\n            };\n        }\n    };\n\n    ko.jqueryTmplTemplateEngine.prototype = new ko.templateEngine();\n\n    // Use this one by default *only if jquery.tmpl is referenced*\n    var jqueryTmplTemplateEngineInstance = new ko.jqueryTmplTemplateEngine();\n    if (jqueryTmplTemplateEngineInstance.jQueryTmplVersion > 0)\n        ko.setTemplateEngine(jqueryTmplTemplateEngineInstance);\n\n    ko.exportSymbol('jqueryTmplTemplateEngine', ko.jqueryTmplTemplateEngine);\n})();\n});\n})(window,document,navigator,window[\"jQuery\"]);\n})();\n","/*\n===============================================================================\n    Author:     Eric M. Barnard - @ericmbarnard                                \n    License:    MIT (http://opensource.org/licenses/mit-license.php)           \n                                                                               \n    Description: Validation Library for KnockoutJS                             \n===============================================================================\n*/\n\n/*jshint\n    sub:true, \n    curly: true,eqeqeq: true,\n    immed: true,\n    latedef: true,\n    newcap: true,\n    noarg: true,\n    sub: true,\n    undef: true,\n    boss: true,\n    eqnull: true,\n    browser: true\n*/\n\n/*globals\n    jQuery: false,\n    require: false,\n    exports: false,\n    define: false,\n    ko: false\n*/\n\n(function (factory) {\n    factory(ko, ko.validation = {});\n}(function ( ko, exports ) {\n\n    if (typeof (ko) === undefined) { throw 'Knockout is required, please ensure it is loaded before loading this validation plug-in'; }\n\n    // create our namespace object\n    var validation = exports;\n    ko.validation = validation;\n\n    var defaults = {\n        registerExtenders: true,\n        messagesOnModified: true,\n        errorsAsTitle: true,            // enables/disables showing of errors as title attribute of the target element.\n        errorsAsTitleOnModified: false, // shows the error when hovering the input field (decorateElement must be true)\n        messageTemplate: null,\n        insertMessages: true,           // automatically inserts validation messages as <span></span>\n        parseInputAttributes: false,    // parses the HTML5 validation attribute from a form element and adds that to the object\n        writeInputAttributes: false,    // adds HTML5 input validation attributes to form elements that ko observable's are bound to\n        decorateElement: false,         // false to keep backward compatibility\n        decorateElementOnModified: true,// true to keep backward compatibility\n        errorClass: null,               // single class for error message and element\n        errorElementClass: 'validationElement',  // class to decorate error element\n        errorMessageClass: 'validationMessage',  // class to decorate error message\n        grouping: {\n            deep: false,        //by default grouping is shallow\n            observable: true    //and using observables\n        }\n    };\n\n    // make a copy  so we can use 'reset' later\n    var configuration = ko.utils.extend({}, defaults);\n\n    var html5Attributes = ['required', 'pattern', 'min', 'max', 'step'];\n    var html5InputTypes = ['email', 'number', 'date'];\n\n    var async = function (expr) {\n        if (window.setImmediate) { window.setImmediate(expr); }\n        else { window.setTimeout(expr, 0); }\n    };\n\n    //#region Utilities\n\n    var utils = (function () {\n        var seedId = new Date().getTime();\n\n        var domData = {}; //hash of data objects that we reference from dom elements\n        var domDataKey = '__ko_validation__';\n\n        return {\n            isArray: function (o) {\n                return o.isArray || Object.prototype.toString.call(o) === '[object Array]';\n            },\n            isObject: function (o) {\n                return o !== null && typeof o === 'object';\n            },\n            values: function (o) {\n                var r = [];\n                for (var i in o) {\n                    if (o.hasOwnProperty(i)) {\n                        r.push(o[i]);\n                    }\n                }\n                return r;\n            },\n            getValue: function (o) {\n                return (typeof o === 'function' ? o() : o);\n            },\n            hasAttribute: function (node, attr) {\n                return node.getAttribute(attr) !== null;\n            },\n            getAttribute: function(element, attr){\n                return element.getAttribute(attr);\n            },\n            setAttribute: function(element, attr, value){\n                return element.setAttribute(attr, value);\n            },\n            isValidatable: function (o) {\n                return o && o.rules && o.isValid && o.isModified;\n            },\n            insertAfter: function (node, newNode) {\n                node.parentNode.insertBefore(newNode, node.nextSibling);\n            },\n            newId: function () {\n                return seedId += 1;\n            },\n            getConfigOptions: function (element) {\n                var options = utils.contextFor(element);\n\n                return options || configuration;\n            },\n            setDomData: function (node, data) {\n                var key = node[domDataKey];\n\n                if (!key) {\n                    node[domDataKey] = key = utils.newId();\n                }\n\n                domData[key] = data;\n            },\n            getDomData: function (node) {\n                var key = node[domDataKey];\n\n                if (!key) {\n                    return undefined;\n                }\n\n                return domData[key];\n            },\n            contextFor: function (node) {\n                switch (node.nodeType) {\n                    case 1:\n                    case 8:\n                        var context = utils.getDomData(node);\n                        if (context) { return context; }\n                        if (node.parentNode) { return utils.contextFor(node.parentNode); }\n                        break;\n                }\n                return undefined;\n            },\n            isEmptyVal: function (val) {\n                if (val === undefined) {\n                    return true;\n                }\n                if (val === null) {\n                    return true;\n                }\n                if (val === \"\") {\n                    return true;\n                }\n            },\n            getOriginalElementTitle: function (element) {\n                var savedOriginalTitle = utils.getAttribute(element, 'data-orig-title'),\n                    currentTitle = element.title,\n                    hasSavedOriginalTitle = utils.hasAttribute(element, 'data-orig-title');\n                \n                return hasSavedOriginalTitle ? \n                    savedOriginalTitle : currentTitle;\n            }\n        };\n    } ());\n\n    //#endregion\n\n    //#region Public API\n    var api = (function () {\n\n        var isInitialized = 0;\n\n        return {\n            utils: utils,\n\n            //Call this on startup\n            //any config can be overridden with the passed in options\n            init: function (options, force) {\n                //done run this multiple times if we don't really want to\n                if (isInitialized > 0 && !force) {\n                    return;\n                }\n\n                //becuase we will be accessing options properties it has to be an object at least\n                options = options || {};\n                //if specific error classes are not provided then apply generic errorClass\n                //it has to be done on option so that options.errorClass can override default\n                //errorElementClass and errorMessage class but not those provided in options\n                options.errorElementClass = options.errorElementClass || options.errorClass || configuration.errorElementClass;\n                options.errorMessageClass = options.errorMessageClass || options.errorClass || configuration.errorMessageClass;\n\n                ko.utils.extend(configuration, options);\n\n                if (configuration.registerExtenders) {\n                    exports.registerExtenders();\n                }\n\n                isInitialized = 1;\n            },\n            // backwards compatability\n            configure: function (options) { exports.init(options); },\n\n            // resets the config back to its original state\n            reset: function () { ko.utils.extend(configuration, defaults); },\n\n            // recursivly walks a viewModel and creates an object that\n            // provides validation information for the entire viewModel\n            // obj -> the viewModel to walk\n            // options -> {\n            //      deep: false, // if true, will walk past the first level of viewModel properties\n            //      observable: false // if true, returns a computed observable indicating if the viewModel is valid\n            // }\n            group: function group(obj, options) { // array of observables or viewModel\n                options = ko.utils.extend(ko.utils.extend({}, configuration.grouping), options);\n\n                var validatables = ko.observableArray([]),\n                result = null,\n\n                //anonymous, immediate function to traverse objects hierarchically\n                //if !options.deep then it will stop on top level\n                traverse = function traverse(obj, level) {\n                    var objValues = [],\n                        val = ko.utils.unwrapObservable(obj);\n\n                    //default level value depends on deep option.\n                    level = (level !== undefined ? level : options.deep ? 1 : -1);\n\n                    // if object is observable then add it to the list\n                    if (ko.isObservable(obj)) {\n\n                        //make sure it is validatable object\n                        if (!obj.isValid) { obj.extend({ validatable: true }); }\n                        validatables.push(obj);\n                    }\n\n                    //get list of values either from array or object but ignore non-objects\n                    if (val) {\n                        if (utils.isArray(val)) {\n                            objValues = val;\n                        } else if (utils.isObject(val)) {\n                            objValues = utils.values(val);\n                        }\n                    }\n\n                    //process recurisvely if it is deep grouping\n                    if (level !== 0) {\n                        ko.utils.arrayForEach(objValues, function (observable) {\n\n                            //but not falsy things and not HTML Elements\n                            if (observable && !observable.nodeType) { traverse(observable, level + 1); }\n                        });\n                    }\n                };\n\n                //if using observables then traverse structure once and add observables\n                if (options.observable) {\n\n                    traverse(obj);\n\n                    result = ko.computed(function () {\n                        var errors = [];\n                        ko.utils.arrayForEach(validatables(), function (observable) {\n                            if (!observable.isValid()) {\n                                errors.push(observable.error);\n                            }\n                        });\n                        return errors;\n                    });\n\n                } else { //if not using observables then every call to error() should traverse the structure\n                    result = function () {\n                        var errors = [];\n                        validatables([]); //clear validatables\n                        traverse(obj); // and traverse tree again\n                        ko.utils.arrayForEach(validatables(), function (observable) {\n                            if (!observable.isValid()) {\n                                errors.push(observable.error);\n                            }\n                        });\n                        return errors;\n                    };\n\n\n                }\n\n                result.showAllMessages = function (show) { // thanks @heliosPortal\n                    if (show === undefined) {//default to true\n                        show = true;\n                    }\n\n                    // ensure we have latest changes\n                    result();\n\n                    ko.utils.arrayForEach(validatables(), function (observable) {\n                        observable.isModified(show);\n                    });\n                };\n\n                obj.errors = result;\n                obj.isValid = function () {\n                    return obj.errors().length === 0;\n                };\n                obj.isAnyMessageShown = function() {\n                    var invalidAndModifiedPresent = false;\n                    \n                    // ensure we have latest changes\n                    result();\n                    \n                    ko.utils.arrayForEach(validatables(), function (observable) {\n                        if (!observable.isValid() && observable.isModified()) {\n                            invalidAndModifiedPresent = true;\n                        }\n                    });\n                    return invalidAndModifiedPresent;\n                };\n\n                return result;\n            },\n\n            formatMessage: function (message, params) {\n                if (typeof (message) === 'function') {\n                    return message(params);\n                }\n                return message.replace(/\\{0\\}/gi, ko.utils.unwrapObservable(params));\n            },\n\n            // addRule:\n            // This takes in a ko.observable and a Rule Context - which is just a rule name and params to supply to the validator\n            // ie: ko.validation.addRule(myObservable, {\n            //          rule: 'required',\n            //          params: true\n            //      });\n            //\n            addRule: function (observable, rule) {\n                observable.extend({ validatable: true });\n\n                //push a Rule Context to the observables local array of Rule Contexts\n                observable.rules.push(rule);\n                return observable;\n            },\n\n            // addAnonymousRule:\n            // Anonymous Rules essentially have all the properties of a Rule, but are only specific for a certain property\n            // and developers typically are wanting to add them on the fly or not register a rule with the 'ko.validation.rules' object\n            //\n            // Example:\n            // var test = ko.observable('something').extend{(\n            //      validation: {\n            //          validator: function(val, someOtherVal){\n            //              return true;\n            //          },\n            //          message: \"Something must be really wrong!',\n            //          params: true\n            //      }\n            //  )};\n            addAnonymousRule: function (observable, ruleObj) {\n                var ruleName = utils.newId();\n\n                if ( ruleObj['message'] === undefined ) {\n                    ruleObj['message'] = 'Error';\n                }\n\n                //Create an anonymous rule to reference\n                exports.rules[ruleName] = ruleObj;\n\n                //add the anonymous rule to the observable\n                exports.addRule(observable, {\n                    rule: ruleName,\n                    params: ruleObj.params\n                });\n            },\n\n            addExtender: function (ruleName) {\n                ko.extenders[ruleName] = function (observable, params) {\n                    //params can come in a few flavors\n                    // 1. Just the params to be passed to the validator\n                    // 2. An object containing the Message to be used and the Params to pass to the validator\n                    // 3. A condition when the validation rule to be applied\n                    //\n                    // Example:\n                    // var test = ko.observable(3).extend({\n                    //      max: {\n                    //          message: 'This special field has a Max of {0}',\n                    //          params: 2,\n                    //          onlyIf: function() {\n                    //                      return specialField.IsVisible();\n                    //                  }\n                    //      }\n                    //  )};\n                    //\n                    if (params.message || params.onlyIf) { //if it has a message or condition object, then its an object literal to use\n                        return exports.addRule(observable, {\n                            rule: ruleName,\n                            message: params.message,\n                            params: utils.isEmptyVal(params.params) ? true : params.params,\n                            condition: params.onlyIf\n                        });\n                    } else {\n                        return exports.addRule(observable, {\n                            rule: ruleName,\n                            params: params\n                        });\n                    }\n                };\n            },\n\n            // loops through all ko.validation.rules and adds them as extenders to\n            // ko.extenders\n            registerExtenders: function () { // root extenders optional, use 'validation' extender if would cause conflicts\n                if (configuration.registerExtenders) {\n                    for (var ruleName in exports.rules) {\n                        if (exports.rules.hasOwnProperty(ruleName)) {\n                            if (!ko.extenders[ruleName]) {\n                                exports.addExtender(ruleName);\n                            }\n                        }\n                    }\n                }\n            },\n\n            //creates a span next to the @element with the specified error class\n            insertValidationMessage: function (element) {\n                var span = document.createElement('SPAN');\n                span.className = utils.getConfigOptions(element).errorMessageClass;\n                utils.insertAfter(element, span);\n                return span;\n            },\n\n            // if html-5 validation attributes have been specified, this parses\n            // the attributes on @element\n            parseInputValidationAttributes: function (element, valueAccessor) {\n                ko.utils.arrayForEach(html5Attributes, function (attr) {\n                    if (utils.hasAttribute(element, attr)) {\n                        exports.addRule(valueAccessor(), {\n                            rule: attr,\n                            params: element.getAttribute(attr) || true\n                        });\n                    }\n                });\n\n                var currentType = element.getAttribute('type');\n                ko.utils.arrayForEach(html5InputTypes, function (type) {\n                    if (type === currentType){\n                        exports.addRule(valueAccessor(), {\n                            rule: (type === 'date')?'dateISO':type,\n                            params: true\n                        });\n                    }\n                });\n            },\n\n            // writes html5 validation attributes on the element passed in\n            writeInputValidationAttributes: function (element, valueAccessor) {\n                var observable = valueAccessor();\n\n                if (!observable || !observable.rules) {\n                    return;\n                }\n\n                var contexts = observable.rules(); // observable array\n\n                // loop through the attributes and add the information needed\n                ko.utils.arrayForEach(html5Attributes, function (attr) {\n                    var params;\n                    var ctx = ko.utils.arrayFirst(contexts, function (ctx) {\n                        return ctx.rule.toLowerCase() === attr.toLowerCase();\n                    });\n\n                    if (!ctx) {\n                        return;\n                    }\n\n                    params = ctx.params;\n\n                    // we have to do some special things for the pattern validation\n                    if (ctx.rule === \"pattern\") {\n                        if (ctx.params instanceof RegExp) {\n                            params = ctx.params.source; // we need the pure string representation of the RegExpr without the //gi stuff\n                        }\n                    }\n\n                    // we have a rule matching a validation attribute at this point\n                    // so lets add it to the element along with the params\n                    element.setAttribute(attr, params);\n                });\n\n                contexts = null;\n            },\n\n            //take an existing binding handler and make it cause automatic validations\n            makeBindingHandlerValidatable: function (handlerName) {\n                var init = ko.bindingHandlers[handlerName].init;\n\n                ko.bindingHandlers[handlerName].init = function (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {\n\n                    init(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext);\n\n                    return ko.bindingHandlers['validationCore'].init(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext);\n                };\n            }\n        };\n    }());\n\n    // expose api publicly\n    ko.utils.extend(validation, api);\n    //#endregion\n\n    //#region Core Validation Rules\n\n    //Validation Rules:\n    // You can view and override messages or rules via:\n    // ko.validation.rules[ruleName]\n    //\n    // To implement a custom Rule, simply use this template:\n    // ko.validation.rules['<custom rule name>'] = {\n    //      validator: function (val, param) {\n    //          <custom logic>\n    //          return <true or false>;\n    //      },\n    //      message: '<custom validation message>' //optionally you can also use a '{0}' to denote a placeholder that will be replaced with your 'param'\n    // };\n    //\n    // Example:\n    // ko.validation.rules['mustEqual'] = {\n    //      validator: function( val, mustEqualVal ){\n    //          return val === mustEqualVal;\n    //      },\n    //      message: 'This field must equal {0}'\n    // };\n    //\n    validation.rules = {};\n    validation.rules['required'] = {\n        validator: function (val, required) {\n            var stringTrimRegEx = /^\\s+|\\s+$/g,\n                testVal;\n\n            if (val === undefined || val === null) {\n                return !required;\n            }\n\n            testVal = val;\n            if (typeof (val) === \"string\") {\n                testVal = val.replace(stringTrimRegEx, '');\n            }\n\n            if (!required) {// if they passed: { required: false }, then don't require this\n                return true;\n            }\n\n            return ((testVal + '').length > 0);\n        },\n        message: 'This field is required.'\n    };\n\n    validation.rules['min'] = {\n        validator: function (val, min) {\n            return utils.isEmptyVal(val) || val >= min;\n        },\n        message: 'Please enter a value greater than or equal to {0}.'\n    };\n\n    validation.rules['max'] = {\n        validator: function (val, max) {\n            return utils.isEmptyVal(val) || val <= max;\n        },\n        message: 'Please enter a value less than or equal to {0}.'\n    };\n\n    validation.rules['minLength'] = {\n        validator: function (val, minLength) {\n            return utils.isEmptyVal(val) || val.length >= minLength;\n        },\n        message: 'Please enter at least {0} characters.'\n    };\n\n    validation.rules['maxLength'] = {\n        validator: function (val, maxLength) {\n            return utils.isEmptyVal(val) || val.length <= maxLength;\n        },\n        message: 'Please enter no more than {0} characters.'\n    };\n\n    validation.rules['pattern'] = {\n        validator: function (val, regex) {\n            return utils.isEmptyVal(val) || val.toString().match(regex) !== null;\n        },\n        message: 'Please check this value.'\n    };\n\n    validation.rules['step'] = {\n        validator: function (val, step) {\n\n            // in order to handle steps of .1 & .01 etc.. Modulus won't work\n            // if the value is a decimal, so we have to correct for that\n            if (utils.isEmptyVal(val) || step == 'any') return true;\n            var dif = (val * 100) % (step * 100);\n            return Math.abs(dif) < 0.00001 || Math.abs(1 - dif) < 0.00001;\n        },\n        message: 'The value must increment by {0}'\n    };\n\n    validation.rules['email'] = {\n        validator: function (val, validate) {\n            if (!validate) { return true; }\n\n            //I think an empty email address is also a valid entry\n            //if one want's to enforce entry it should be done with 'required: true'\n            return utils.isEmptyVal(val) || (\n                // jquery validate regex - thanks Scott Gonzalez\n                validate && /^[\\u0021-\\u003f\\u0041-\\uffff]+@[\\u0021-\\u003f\\u0041-\\uffff]+\\.[\\u0021-\\u003f\\u0041-\\uffff]{2,63}$/i.test(val)\n            );\n        },\n        message: 'Please enter a proper email address'\n    };\n\n    validation.rules['date'] = {\n        validator: function (value, validate) {\n            if (!validate) { return true; }\n            return utils.isEmptyVal(value) || (validate && !/Invalid|NaN/.test(new Date(value)));\n        },\n        message: 'Please enter a proper date'\n    };\n\n    validation.rules['dateISO'] = {\n        validator: function (value, validate) {\n            if (!validate) { return true; }\n            return utils.isEmptyVal(value) || (validate && /^\\d{4}[\\/\\-]\\d{1,2}[\\/\\-]\\d{1,2}$/.test(value));\n        },\n        message: 'Please enter a proper date'\n    };\n\n    validation.rules['number'] = {\n        validator: function (value, validate) {\n            if (!validate) { return true; }\n            return utils.isEmptyVal(value) || (validate && /^-?(?:\\d+|\\d{1,3}(?:,\\d{3})+)(?:\\.\\d+)?$/.test(value));\n        },\n        message: 'Please enter a number'\n    };\n\n    validation.rules['digit'] = {\n        validator: function (value, validate) {\n            if (!validate) { return true; }\n            return utils.isEmptyVal(value) || (validate && /^\\d+$/.test(value));\n        },\n        message: 'Please enter a digit'\n    };\n\n    validation.rules['equal'] = {\n        validator: function (val, params) {\n            var otherValue = params;\n            return val === utils.getValue(otherValue);\n        },\n        message: 'Values must equal'\n    };\n\n    validation.rules['notEqual'] = {\n        validator: function (val, params) {\n            var otherValue = params;\n            return val !== utils.getValue(otherValue);\n        },\n        message: 'Please choose another value.'\n    };\n\n    //unique in collection\n    // options are:\n    //    collection: array or function returning (observable) array\n    //              in which the value has to be unique\n    //    valueAccessor: function that returns value from an object stored in collection\n    //              if it is null the value is compared directly\n    //    external: set to true when object you are validating is automatically updating collection\n    validation.rules['unique'] = {\n        validator: function (val, options) {\n            var c = utils.getValue(options.collection),\n                external = utils.getValue(options.externalValue),\n                counter = 0;\n\n            if (!val || !c) { return true; }\n\n            ko.utils.arrayFilter(ko.utils.unwrapObservable(c), function (item) {\n                if (val === (options.valueAccessor ? options.valueAccessor(item) : item)) { counter++; }\n            });\n            // if value is external even 1 same value in collection means the value is not unique\n            return counter < (external !== undefined && val !== external ? 1 : 2);\n        },\n        message: 'Please make sure the value is unique.'\n    };\n\n\n    //now register all of these!\n    (function () {\n        validation.registerExtenders();\n    } ());\n\n    //#endregion\n\n    //#region Knockout Binding Handlers\n\n    // The core binding handler\n    // this allows us to setup any value binding that internally always\n    // performs the same functionality\n    ko.bindingHandlers['validationCore'] = (function () {\n\n        return {\n            init: function (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {\n                var config = utils.getConfigOptions(element);\n\n                // parse html5 input validation attributes, optional feature\n                if (config.parseInputAttributes) {\n                    async(function () { exports.parseInputValidationAttributes(element, valueAccessor); });\n                }\n\n                // if requested insert message element and apply bindings\n                if (config.insertMessages && utils.isValidatable(valueAccessor())) {\n\n                    // insert the <span></span>\n                    var validationMessageElement = exports.insertValidationMessage(element);\n\n                    // if we're told to use a template, make sure that gets rendered\n                    if (config.messageTemplate) {\n                        ko.renderTemplate(config.messageTemplate, { field: valueAccessor() }, null, validationMessageElement, 'replaceNode');\n                    } else {\n                        ko.applyBindingsToNode(validationMessageElement, { validationMessage: valueAccessor() });\n                    }\n                }\n\n                // write the html5 attributes if indicated by the config\n                if (config.writeInputAttributes && utils.isValidatable(valueAccessor())) {\n\n                    exports.writeInputValidationAttributes(element, valueAccessor);\n                }\n\n                // if requested, add binding to decorate element\n                if (config.decorateElement && utils.isValidatable(valueAccessor())) {\n                    ko.applyBindingsToNode(element, { validationElement: valueAccessor() });\n                }\n            },\n\n            update: function (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {\n                // hook for future extensibility\n            }\n        };\n\n    }());\n\n    // override for KO's default 'value' and 'checked' bindings\n    api.makeBindingHandlerValidatable(\"value\");\n    api.makeBindingHandlerValidatable(\"checked\");\n\n\n    ko.bindingHandlers['validationMessage'] = { // individual error message, if modified or post binding\n        update: function (element, valueAccessor) {\n            var obsv = valueAccessor(),\n                config = utils.getConfigOptions(element),\n                val = ko.utils.unwrapObservable(obsv),\n                msg = null,\n                isModified = false,\n                isValid = false;\n                \n            obsv.extend({ validatable: true });\n\n            isModified = obsv.isModified();\n            isValid = obsv.isValid();\n            \n            // create a handler to correctly return an error message\n            var errorMsgAccessor = function () {\n                if (!config.messagesOnModified || isModified) {\n                    return isValid ? null : obsv.error;\n                } else {\n                    return null;\n                }\n            };\n\n            //toggle visibility on validation messages when validation hasn't been evaluated, or when the object isValid\n            var visiblityAccessor = function () {\n                return (!config.messagesOnModified || isModified) ? !isValid : false;\n            };\n\n            ko.bindingHandlers.text.update(element, errorMsgAccessor);\n            ko.bindingHandlers.visible.update(element, visiblityAccessor);\n        }\n    };\n\n    ko.bindingHandlers['validationElement'] = {\n        update: function (element, valueAccessor) {\n            var obsv = valueAccessor(),\n                config = utils.getConfigOptions(element),\n                val = ko.utils.unwrapObservable(obsv),\n                msg = null,\n                isModified = false,\n                isValid = false;\n\n            obsv.extend({ validatable: true });\n\n            isModified = obsv.isModified();\n            isValid = obsv.isValid();\n\n            // create an evaluator function that will return something like:\n            // css: { validationElement: true }\n            var cssSettingsAccessor = function () {\n                var css = {};\n\n                var shouldShow = ((!config.decorateElementOnModified || isModified) ? !isValid : false);\n\n                if (!config.decorateElement) { shouldShow = false; }\n\n                // css: { validationElement: false }\n                css[config.errorElementClass] = shouldShow;\n\n                return css;\n            };\n\n            //add or remove class on the element;\n            ko.bindingHandlers.css.update(element, cssSettingsAccessor);\n            if (!config.errorsAsTitle) { return; }\n            \n\t\t\tvar origTitle = utils.getAttribute(element, 'data-orig-title'),\n                elementTitle = element.title,\n                titleIsErrorMsg = utils.getAttribute(element, 'data-orig-title') === \"true\";\n\n            var errorMsgTitleAccessor = function () {\n                if (!config.errorsAsTitleOnModified || isModified) {\n                    if (!isValid) {\n                        return { title: obsv.error, 'data-orig-title': utils.getOriginalElementTitle(element) };\n                    } else {\n                        return { title: utils.getOriginalElementTitle(element), 'data-orig-title': null };\n                    }\n                }\n            };\n            ko.bindingHandlers.attr.update(element, errorMsgTitleAccessor);\n        }\n    };\n\n    // ValidationOptions:\n    // This binding handler allows you to override the initial config by setting any of the options for a specific element or context of elements\n    //\n    // Example:\n    // <div data-bind=\"validationOptions: { insertMessages: true, messageTemplate: 'customTemplate', errorMessageClass: 'mySpecialClass'}\">\n    //      <input type=\"text\" data-bind=\"value: someValue\"/>\n    //      <input type=\"text\" data-bind=\"value: someValue2\"/>\n    // </div>\n    ko.bindingHandlers['validationOptions'] = (function () {\n        return {\n            init: function (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {\n                var options = ko.utils.unwrapObservable(valueAccessor());\n                if (options) {\n                    var newConfig = ko.utils.extend({}, configuration);\n                    ko.utils.extend(newConfig, options);\n\n                    //store the validation options on the node so we can retrieve it later\n                    utils.setDomData(element, newConfig);\n                }\n            }\n        };\n    } ());\n    //#endregion\n\n    //#region Knockout Extenders\n\n    // Validation Extender:\n    // This is for creating custom validation logic on the fly\n    // Example:\n    // var test = ko.observable('something').extend{(\n    //      validation: {\n    //          validator: function(val, someOtherVal){\n    //              return true;\n    //          },\n    //          message: \"Something must be really wrong!',\n    //          params: true\n    //      }\n    //  )};\n    ko.extenders['validation'] = function (observable, rules) { // allow single rule or array\n        ko.utils.arrayForEach(utils.isArray(rules) ? rules : [rules], function (rule) {\n            // the 'rule' being passed in here has no name to identify a core Rule,\n            // so we add it as an anonymous rule\n            // If the developer is wanting to use a core Rule, but use a different message see the 'addExtender' logic for examples\n            exports.addAnonymousRule(observable, rule);\n        });\n        return observable;\n    };\n\n    //This is the extender that makes a Knockout Observable also 'Validatable'\n    //examples include:\n    // 1. var test = ko.observable('something').extend({validatable: true});\n    // this will ensure that the Observable object is setup properly to respond to rules\n    //\n    // 2. test.extend({validatable: false});\n    // this will remove the validation properties from the Observable object should you need to do that.\n    ko.extenders['validatable'] = function (observable, enable) {\n        if (enable && !utils.isValidatable(observable)) {\n\n            observable.error = ko.observable(null); // holds the error message, we only need one since we stop processing validators when one is invalid\n\n            // observable.rules:\n            // ObservableArray of Rule Contexts, where a Rule Context is simply the name of a rule and the params to supply to it\n            //\n            // Rule Context = { rule: '<rule name>', params: '<passed in params>', message: '<Override of default Message>' }\n            observable.rules = ko.observableArray(); //holds the rule Contexts to use as part of validation\n\n            //in case async validation is occuring\n            observable.isValidating = ko.observable(false);\n\n            //the true holder of whether the observable is valid or not\n            observable.__valid__ = ko.observable(true);\n\n            observable.isModified = ko.observable(false);\n\n            // we use a computed here to ensure that anytime a dependency changes, the\n            // validation logic evaluates\n            var h_obsValidationTrigger = ko.computed(function () {\n                var obs = observable(),\n                    ruleContexts = observable.rules();\n\n                exports.validateObservable(observable);\n\n                return true;\n            });\n\n            // a semi-protected observable\n            observable.isValid = ko.computed(function () {\n                return observable.__valid__();\n            });\n\n\t\t\t//manually set error state\n            observable.setError = function (error) {\n\t\t\t\tobservable.error(error);\n            \tobservable.__valid__(false);\n            };\n\n\t\t\t//manually clear error state\n            observable.clearError = function () {\n            \tobservable.error(null);\n\t\t\t\tobservable.__valid__(true);\n            };\n\n            //subscribe to changes in the observable\n            var h_change = observable.subscribe(function () {\n                observable.isModified(true);\n            });\n\n            observable._disposeValidation = function () {\n                //first dispose of the subscriptions\n                observable.isValid.dispose();\n                observable.rules.removeAll();\n                observable.isModified._subscriptions['change'] = [];\n                observable.isValidating._subscriptions['change'] = [];\n                observable.__valid__._subscriptions['change'] = [];\n                h_change.dispose();\n                h_obsValidationTrigger.dispose();\n\n                delete observable['rules'];\n                delete observable['error'];\n                delete observable['isValid'];\n                delete observable['isValidating'];\n                delete observable['__valid__'];\n                delete observable['isModified'];\n            };\n        } else if (enable === false && utils.isValidatable(observable)) {\n\n            if (observable._disposeValidation) {\n                observable._disposeValidation();\n            }\n        }\n        return observable;\n    };\n\n    function validateSync(observable, rule, ctx) {\n        //Execute the validator and see if its valid\n        if (!rule.validator(observable(), ctx.params === undefined ? true : ctx.params)) { // default param is true, eg. required = true\n\n            //not valid, so format the error message and stick it in the 'error' variable\n            observable.error(exports.formatMessage(ctx.message || rule.message, ctx.params));\n            observable.__valid__(false);\n            return false;\n        } else {\n            return true;\n        }\n    }\n\n    function validateAsync(observable, rule, ctx) {\n        observable.isValidating(true);\n\n        var callBack = function (valObj) {\n            var isValid = false,\n                msg = '';\n\n            if (!observable.__valid__()) {\n\n                // since we're returning early, make sure we turn this off\n                observable.isValidating(false);\n\n                return; //if its already NOT valid, don't add to that\n            }\n\n            //we were handed back a complex object\n            if (valObj['message']) {\n                isValid = valObj.isValid;\n                msg = valObj.message;\n            } else {\n                isValid = valObj;\n            }\n\n            if (!isValid) {\n                //not valid, so format the error message and stick it in the 'error' variable\n                observable.error(exports.formatMessage(msg || ctx.message || rule.message, ctx.params));\n                observable.__valid__(isValid);\n            }\n\n            // tell it that we're done\n            observable.isValidating(false);\n        };\n\n        //fire the validator and hand it the callback\n        rule.validator(observable(), ctx.params || true, callBack);\n    }\n\n    validation.validateObservable = function (observable) {\n        var i = 0,\n            rule, // the rule validator to execute\n            ctx, // the current Rule Context for the loop\n            ruleContexts = observable.rules(), //cache for iterator\n            len = ruleContexts.length; //cache for iterator\n\n        for (; i < len; i++) {\n\n            //get the Rule Context info to give to the core Rule\n            ctx = ruleContexts[i];\n\n            // checks an 'onlyIf' condition\n            if (ctx.condition && !ctx.condition()) {\n                continue;\n            }\n\n            //get the core Rule to use for validation\n            rule = exports.rules[ctx.rule];\n\n            if (rule['async'] || ctx['async']) {\n                //run async validation\n                validateAsync(observable, rule, ctx);\n\n            } else {\n                //run normal sync validation\n                if (!validateSync(observable, rule, ctx)) {\n                    return false; //break out of the loop\n                }\n            }\n        }\n        //finally if we got this far, make the observable valid again!\n        observable.error(null);\n        observable.__valid__(true);\n        return true;\n    };\n\n    //#endregion\n\n    //#region Validated Observable\n\n    ko.validatedObservable = function (initialValue) {\n        if (!exports.utils.isObject(initialValue)) { return ko.observable(initialValue).extend({ validatable: true }); }\n\n        var obsv = ko.observable(initialValue);\n        obsv.errors = exports.group(initialValue);\n        obsv.isValid = ko.computed(function () {\n            return obsv.errors().length === 0;\n        });\n\n        return obsv;\n    };\n\n    //#endregion\n\n    //#region Localization\n\n    //quick function to override rule messages\n    validation.localize = function (msgTranslations) {\n\n        var msg, rule;\n\n        //loop the properties in the object and assign the msg to the rule\n        for (rule in msgTranslations) {\n            if (exports.rules.hasOwnProperty(rule)) {\n                exports.rules[rule].message = msgTranslations[rule];\n            }\n        }\n    };\n    //#endregion\n\n    //#region ApplyBindings Added Functionality\n    ko.applyBindingsWithValidation = function (viewModel, rootNode, options) {\n        var len = arguments.length,\n            node, config;\n\n        if (len > 2) { // all parameters were passed\n            node = rootNode;\n            config = options;\n        } else if (len < 2) {\n            node = document.body;\n        } else { //have to figure out if they passed in a root node or options\n            if (arguments[1].nodeType) { //its a node\n                node = rootNode;\n            } else {\n                config = arguments[1];\n            }\n        }\n\n        exports.init();\n\n        if (config) { exports.utils.setDomData(node, config); }\n\n        ko.applyBindings(viewModel, rootNode);\n    };\n\n    //override the original applyBindings so that we can ensure all new rules and what not are correctly registered\n    var origApplyBindings = ko.applyBindings;\n    ko.applyBindings = function (viewModel, rootNode) {\n\n        exports.init();\n\n        origApplyBindings(viewModel, rootNode);\n    };\n\n    //#endregion\n}));\n","//     Underscore.js 1.4.4\n//     http://underscorejs.org\n//     (c) 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.\n//     Underscore may be freely distributed under the MIT license.\n\n(function() {\n\n  // Baseline setup\n  // --------------\n\n  // Establish the root object, `window` in the browser, or `global` on the server.\n  var root = window;\n\n  // Save the previous value of the `_` variable.\n  var previousUnderscore = root._;\n\n  // Establish the object that gets returned to break out of a loop iteration.\n  var breaker = {};\n\n  // Save bytes in the minified (but not gzipped) version:\n  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;\n\n  // Create quick reference variables for speed access to core prototypes.\n  var push             = ArrayProto.push,\n      slice            = ArrayProto.slice,\n      concat           = ArrayProto.concat,\n      toString         = ObjProto.toString,\n      hasOwnProperty   = ObjProto.hasOwnProperty;\n\n  // All **ECMAScript 5** native function implementations that we hope to use\n  // are declared here.\n  var\n    nativeForEach      = ArrayProto.forEach,\n    nativeMap          = ArrayProto.map,\n    nativeReduce       = ArrayProto.reduce,\n    nativeReduceRight  = ArrayProto.reduceRight,\n    nativeFilter       = ArrayProto.filter,\n    nativeEvery        = ArrayProto.every,\n    nativeSome         = ArrayProto.some,\n    nativeIndexOf      = ArrayProto.indexOf,\n    nativeLastIndexOf  = ArrayProto.lastIndexOf,\n    nativeIsArray      = Array.isArray,\n    nativeKeys         = Object.keys,\n    nativeBind         = FuncProto.bind;\n\n  // Create a safe reference to the Underscore object for use below.\n  var _ = function(obj) {\n    if (obj instanceof _) return obj;\n    if (!(this instanceof _)) return new _(obj);\n    this._wrapped = obj;\n  };\n\n  root._ = _;\n\n  // Current version.\n  _.VERSION = '1.4.4';\n\n  // Collection Functions\n  // --------------------\n\n  // The cornerstone, an `each` implementation, aka `forEach`.\n  // Handles objects with the built-in `forEach`, arrays, and raw objects.\n  // Delegates to **ECMAScript 5**'s native `forEach` if available.\n  var each = _.each = _.forEach = function(obj, iterator, context) {\n    if (obj == null) return;\n    if (nativeForEach && obj.forEach === nativeForEach) {\n      obj.forEach(iterator, context);\n    } else if (obj.length === +obj.length) {\n      for (var i = 0, l = obj.length; i < l; i++) {\n        if (iterator.call(context, obj[i], i, obj) === breaker) return;\n      }\n    } else {\n      for (var key in obj) {\n        if (_.has(obj, key)) {\n          if (iterator.call(context, obj[key], key, obj) === breaker) return;\n        }\n      }\n    }\n  };\n\n  // Return the results of applying the iterator to each element.\n  // Delegates to **ECMAScript 5**'s native `map` if available.\n  _.map = _.collect = function(obj, iterator, context) {\n    var results = [];\n    if (obj == null) return results;\n    if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);\n    each(obj, function(value, index, list) {\n      results[results.length] = iterator.call(context, value, index, list);\n    });\n    return results;\n  };\n\n  var reduceError = 'Reduce of empty array with no initial value';\n\n  // **Reduce** builds up a single result from a list of values, aka `inject`,\n  // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.\n  _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {\n    var initial = arguments.length > 2;\n    if (obj == null) obj = [];\n    if (nativeReduce && obj.reduce === nativeReduce) {\n      if (context) iterator = _.bind(iterator, context);\n      return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);\n    }\n    each(obj, function(value, index, list) {\n      if (!initial) {\n        memo = value;\n        initial = true;\n      } else {\n        memo = iterator.call(context, memo, value, index, list);\n      }\n    });\n    if (!initial) throw new TypeError(reduceError);\n    return memo;\n  };\n\n  // The right-associative version of reduce, also known as `foldr`.\n  // Delegates to **ECMAScript 5**'s native `reduceRight` if available.\n  _.reduceRight = _.foldr = function(obj, iterator, memo, context) {\n    var initial = arguments.length > 2;\n    if (obj == null) obj = [];\n    if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {\n      if (context) iterator = _.bind(iterator, context);\n      return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);\n    }\n    var length = obj.length;\n    if (length !== +length) {\n      var keys = _.keys(obj);\n      length = keys.length;\n    }\n    each(obj, function(value, index, list) {\n      index = keys ? keys[--length] : --length;\n      if (!initial) {\n        memo = obj[index];\n        initial = true;\n      } else {\n        memo = iterator.call(context, memo, obj[index], index, list);\n      }\n    });\n    if (!initial) throw new TypeError(reduceError);\n    return memo;\n  };\n\n  // Return the first value which passes a truth test. Aliased as `detect`.\n  _.find = _.detect = function(obj, iterator, context) {\n    var result;\n    any(obj, function(value, index, list) {\n      if (iterator.call(context, value, index, list)) {\n        result = value;\n        return true;\n      }\n    });\n    return result;\n  };\n\n  // Return all the elements that pass a truth test.\n  // Delegates to **ECMAScript 5**'s native `filter` if available.\n  // Aliased as `select`.\n  _.filter = _.select = function(obj, iterator, context) {\n    var results = [];\n    if (obj == null) return results;\n    if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);\n    each(obj, function(value, index, list) {\n      if (iterator.call(context, value, index, list)) results[results.length] = value;\n    });\n    return results;\n  };\n\n  // Return all the elements for which a truth test fails.\n  _.reject = function(obj, iterator, context) {\n    return _.filter(obj, function(value, index, list) {\n      return !iterator.call(context, value, index, list);\n    }, context);\n  };\n\n  // Determine whether all of the elements match a truth test.\n  // Delegates to **ECMAScript 5**'s native `every` if available.\n  // Aliased as `all`.\n  _.every = _.all = function(obj, iterator, context) {\n    iterator || (iterator = _.identity);\n    var result = true;\n    if (obj == null) return result;\n    if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);\n    each(obj, function(value, index, list) {\n      if (!(result = result && iterator.call(context, value, index, list))) return breaker;\n    });\n    return !!result;\n  };\n\n  // Determine if at least one element in the object matches a truth test.\n  // Delegates to **ECMAScript 5**'s native `some` if available.\n  // Aliased as `any`.\n  var any = _.some = _.any = function(obj, iterator, context) {\n    iterator || (iterator = _.identity);\n    var result = false;\n    if (obj == null) return result;\n    if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);\n    each(obj, function(value, index, list) {\n      if (result || (result = iterator.call(context, value, index, list))) return breaker;\n    });\n    return !!result;\n  };\n\n  // Determine if the array or object contains a given value (using `===`).\n  // Aliased as `include`.\n  _.contains = _.include = function(obj, target) {\n    if (obj == null) return false;\n    if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;\n    return any(obj, function(value) {\n      return value === target;\n    });\n  };\n\n  // Invoke a method (with arguments) on every item in a collection.\n  _.invoke = function(obj, method) {\n    var args = slice.call(arguments, 2);\n    var isFunc = _.isFunction(method);\n    return _.map(obj, function(value) {\n      return (isFunc ? method : value[method]).apply(value, args);\n    });\n  };\n\n  // Convenience version of a common use case of `map`: fetching a property.\n  _.pluck = function(obj, key) {\n    return _.map(obj, function(value){ return value[key]; });\n  };\n\n  // Convenience version of a common use case of `filter`: selecting only objects\n  // containing specific `key:value` pairs.\n  _.where = function(obj, attrs, first) {\n    if (_.isEmpty(attrs)) return first ? null : [];\n    return _[first ? 'find' : 'filter'](obj, function(value) {\n      for (var key in attrs) {\n        if (attrs[key] !== value[key]) return false;\n      }\n      return true;\n    });\n  };\n\n  // Convenience version of a common use case of `find`: getting the first object\n  // containing specific `key:value` pairs.\n  _.findWhere = function(obj, attrs) {\n    return _.where(obj, attrs, true);\n  };\n\n  // Return the maximum element or (element-based computation).\n  // Can't optimize arrays of integers longer than 65,535 elements.\n  // See: https://bugs.webkit.org/show_bug.cgi?id=80797\n  _.max = function(obj, iterator, context) {\n    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {\n      return Math.max.apply(Math, obj);\n    }\n    if (!iterator && _.isEmpty(obj)) return -Infinity;\n    var result = {computed : -Infinity, value: -Infinity};\n    each(obj, function(value, index, list) {\n      var computed = iterator ? iterator.call(context, value, index, list) : value;\n      computed >= result.computed && (result = {value : value, computed : computed});\n    });\n    return result.value;\n  };\n\n  // Return the minimum element (or element-based computation).\n  _.min = function(obj, iterator, context) {\n    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {\n      return Math.min.apply(Math, obj);\n    }\n    if (!iterator && _.isEmpty(obj)) return Infinity;\n    var result = {computed : Infinity, value: Infinity};\n    each(obj, function(value, index, list) {\n      var computed = iterator ? iterator.call(context, value, index, list) : value;\n      computed < result.computed && (result = {value : value, computed : computed});\n    });\n    return result.value;\n  };\n\n  // Shuffle an array.\n  _.shuffle = function(obj) {\n    var rand;\n    var index = 0;\n    var shuffled = [];\n    each(obj, function(value) {\n      rand = _.random(index++);\n      shuffled[index - 1] = shuffled[rand];\n      shuffled[rand] = value;\n    });\n    return shuffled;\n  };\n\n  // An internal function to generate lookup iterators.\n  var lookupIterator = function(value) {\n    return _.isFunction(value) ? value : function(obj){ return obj[value]; };\n  };\n\n  // Sort the object's values by a criterion produced by an iterator.\n  _.sortBy = function(obj, value, context) {\n    var iterator = lookupIterator(value);\n    return _.pluck(_.map(obj, function(value, index, list) {\n      return {\n        value : value,\n        index : index,\n        criteria : iterator.call(context, value, index, list)\n      };\n    }).sort(function(left, right) {\n      var a = left.criteria;\n      var b = right.criteria;\n      if (a !== b) {\n        if (a > b || a === void 0) return 1;\n        if (a < b || b === void 0) return -1;\n      }\n      return left.index < right.index ? -1 : 1;\n    }), 'value');\n  };\n\n  // An internal function used for aggregate \"group by\" operations.\n  var group = function(obj, value, context, behavior) {\n    var result = {};\n    var iterator = lookupIterator(value || _.identity);\n    each(obj, function(value, index) {\n      var key = iterator.call(context, value, index, obj);\n      behavior(result, key, value);\n    });\n    return result;\n  };\n\n  // Groups the object's values by a criterion. Pass either a string attribute\n  // to group by, or a function that returns the criterion.\n  _.groupBy = function(obj, value, context) {\n    return group(obj, value, context, function(result, key, value) {\n      (_.has(result, key) ? result[key] : (result[key] = [])).push(value);\n    });\n  };\n\n  // Counts instances of an object that group by a certain criterion. Pass\n  // either a string attribute to count by, or a function that returns the\n  // criterion.\n  _.countBy = function(obj, value, context) {\n    return group(obj, value, context, function(result, key) {\n      if (!_.has(result, key)) result[key] = 0;\n      result[key]++;\n    });\n  };\n\n  // Use a comparator function to figure out the smallest index at which\n  // an object should be inserted so as to maintain order. Uses binary search.\n  _.sortedIndex = function(array, obj, iterator, context) {\n    iterator = iterator == null ? _.identity : lookupIterator(iterator);\n    var value = iterator.call(context, obj);\n    var low = 0, high = array.length;\n    while (low < high) {\n      var mid = (low + high) >>> 1;\n      iterator.call(context, array[mid]) < value ? low = mid + 1 : high = mid;\n    }\n    return low;\n  };\n\n  // Safely convert anything iterable into a real, live array.\n  _.toArray = function(obj) {\n    if (!obj) return [];\n    if (_.isArray(obj)) return slice.call(obj);\n    if (obj.length === +obj.length) return _.map(obj, _.identity);\n    return _.values(obj);\n  };\n\n  // Return the number of elements in an object.\n  _.size = function(obj) {\n    if (obj == null) return 0;\n    return (obj.length === +obj.length) ? obj.length : _.keys(obj).length;\n  };\n\n  // Array Functions\n  // ---------------\n\n  // Get the first element of an array. Passing **n** will return the first N\n  // values in the array. Aliased as `head` and `take`. The **guard** check\n  // allows it to work with `_.map`.\n  _.first = _.head = _.take = function(array, n, guard) {\n    if (array == null) return void 0;\n    return (n != null) && !guard ? slice.call(array, 0, n) : array[0];\n  };\n\n  // Returns everything but the last entry of the array. Especially useful on\n  // the arguments object. Passing **n** will return all the values in\n  // the array, excluding the last N. The **guard** check allows it to work with\n  // `_.map`.\n  _.initial = function(array, n, guard) {\n    return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));\n  };\n\n  // Get the last element of an array. Passing **n** will return the last N\n  // values in the array. The **guard** check allows it to work with `_.map`.\n  _.last = function(array, n, guard) {\n    if (array == null) return void 0;\n    if ((n != null) && !guard) {\n      return slice.call(array, Math.max(array.length - n, 0));\n    } else {\n      return array[array.length - 1];\n    }\n  };\n\n  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.\n  // Especially useful on the arguments object. Passing an **n** will return\n  // the rest N values in the array. The **guard**\n  // check allows it to work with `_.map`.\n  _.rest = _.tail = _.drop = function(array, n, guard) {\n    return slice.call(array, (n == null) || guard ? 1 : n);\n  };\n\n  // Trim out all falsy values from an array.\n  _.compact = function(array) {\n    return _.filter(array, _.identity);\n  };\n\n  // Internal implementation of a recursive `flatten` function.\n  var flatten = function(input, shallow, output) {\n    each(input, function(value) {\n      if (_.isArray(value)) {\n        shallow ? push.apply(output, value) : flatten(value, shallow, output);\n      } else {\n        output.push(value);\n      }\n    });\n    return output;\n  };\n\n  // Return a completely flattened version of an array.\n  _.flatten = function(array, shallow) {\n    return flatten(array, shallow, []);\n  };\n\n  // Return a version of the array that does not contain the specified value(s).\n  _.without = function(array) {\n    return _.difference(array, slice.call(arguments, 1));\n  };\n\n  // Produce a duplicate-free version of the array. If the array has already\n  // been sorted, you have the option of using a faster algorithm.\n  // Aliased as `unique`.\n  _.uniq = _.unique = function(array, isSorted, iterator, context) {\n    if (_.isFunction(isSorted)) {\n      context = iterator;\n      iterator = isSorted;\n      isSorted = false;\n    }\n    var initial = iterator ? _.map(array, iterator, context) : array;\n    var results = [];\n    var seen = [];\n    each(initial, function(value, index) {\n      if (isSorted ? (!index || seen[seen.length - 1] !== value) : !_.contains(seen, value)) {\n        seen.push(value);\n        results.push(array[index]);\n      }\n    });\n    return results;\n  };\n\n  // Produce an array that contains the union: each distinct element from all of\n  // the passed-in arrays.\n  _.union = function() {\n    return _.uniq(concat.apply(ArrayProto, arguments));\n  };\n\n  // Produce an array that contains every item shared between all the\n  // passed-in arrays.\n  _.intersection = function(array) {\n    var rest = slice.call(arguments, 1);\n    return _.filter(_.uniq(array), function(item) {\n      return _.every(rest, function(other) {\n        return _.indexOf(other, item) >= 0;\n      });\n    });\n  };\n\n  // Take the difference between one array and a number of other arrays.\n  // Only the elements present in just the first array will remain.\n  _.difference = function(array) {\n    var rest = concat.apply(ArrayProto, slice.call(arguments, 1));\n    return _.filter(array, function(value){ return !_.contains(rest, value); });\n  };\n\n  // Zip together multiple lists into a single array -- elements that share\n  // an index go together.\n  _.zip = function() {\n    var args = slice.call(arguments);\n    var length = _.max(_.pluck(args, 'length'));\n    var results = new Array(length);\n    for (var i = 0; i < length; i++) {\n      results[i] = _.pluck(args, \"\" + i);\n    }\n    return results;\n  };\n\n  // Converts lists into objects. Pass either a single array of `[key, value]`\n  // pairs, or two parallel arrays of the same length -- one of keys, and one of\n  // the corresponding values.\n  _.object = function(list, values) {\n    if (list == null) return {};\n    var result = {};\n    for (var i = 0, l = list.length; i < l; i++) {\n      if (values) {\n        result[list[i]] = values[i];\n      } else {\n        result[list[i][0]] = list[i][1];\n      }\n    }\n    return result;\n  };\n\n  // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),\n  // we need this function. Return the position of the first occurrence of an\n  // item in an array, or -1 if the item is not included in the array.\n  // Delegates to **ECMAScript 5**'s native `indexOf` if available.\n  // If the array is large and already in sort order, pass `true`\n  // for **isSorted** to use binary search.\n  _.indexOf = function(array, item, isSorted) {\n    if (array == null) return -1;\n    var i = 0, l = array.length;\n    if (isSorted) {\n      if (typeof isSorted == 'number') {\n        i = (isSorted < 0 ? Math.max(0, l + isSorted) : isSorted);\n      } else {\n        i = _.sortedIndex(array, item);\n        return array[i] === item ? i : -1;\n      }\n    }\n    if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);\n    for (; i < l; i++) if (array[i] === item) return i;\n    return -1;\n  };\n\n  // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.\n  _.lastIndexOf = function(array, item, from) {\n    if (array == null) return -1;\n    var hasIndex = from != null;\n    if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) {\n      return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);\n    }\n    var i = (hasIndex ? from : array.length);\n    while (i--) if (array[i] === item) return i;\n    return -1;\n  };\n\n  // Generate an integer Array containing an arithmetic progression. A port of\n  // the native Python `range()` function. See\n  // [the Python documentation](http://docs.python.org/library/functions.html#range).\n  _.range = function(start, stop, step) {\n    if (arguments.length <= 1) {\n      stop = start || 0;\n      start = 0;\n    }\n    step = arguments[2] || 1;\n\n    var len = Math.max(Math.ceil((stop - start) / step), 0);\n    var idx = 0;\n    var range = new Array(len);\n\n    while(idx < len) {\n      range[idx++] = start;\n      start += step;\n    }\n\n    return range;\n  };\n\n  // Function (ahem) Functions\n  // ------------------\n\n  // Create a function bound to a given object (assigning `this`, and arguments,\n  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if\n  // available.\n  _.bind = function(func, context) {\n    if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));\n    var args = slice.call(arguments, 2);\n    return function() {\n      return func.apply(context, args.concat(slice.call(arguments)));\n    };\n  };\n\n  // Partially apply a function by creating a version that has had some of its\n  // arguments pre-filled, without changing its dynamic `this` context.\n  _.partial = function(func) {\n    var args = slice.call(arguments, 1);\n    return function() {\n      return func.apply(this, args.concat(slice.call(arguments)));\n    };\n  };\n\n  // Bind all of an object's methods to that object. Useful for ensuring that\n  // all callbacks defined on an object belong to it.\n  _.bindAll = function(obj) {\n    var funcs = slice.call(arguments, 1);\n    if (funcs.length === 0) funcs = _.functions(obj);\n    each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });\n    return obj;\n  };\n\n  // Memoize an expensive function by storing its results.\n  _.memoize = function(func, hasher) {\n    var memo = {};\n    hasher || (hasher = _.identity);\n    return function() {\n      var key = hasher.apply(this, arguments);\n      return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));\n    };\n  };\n\n  // Delays a function for the given number of milliseconds, and then calls\n  // it with the arguments supplied.\n  _.delay = function(func, wait) {\n    var args = slice.call(arguments, 2);\n    return setTimeout(function(){ return func.apply(null, args); }, wait);\n  };\n\n  // Defers a function, scheduling it to run after the current call stack has\n  // cleared.\n  _.defer = function(func) {\n    return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));\n  };\n\n  // Returns a function, that, when invoked, will only be triggered at most once\n  // during a given window of time.\n  _.throttle = function(func, wait) {\n    var context, args, timeout, result;\n    var previous = 0;\n    var later = function() {\n      previous = new Date;\n      timeout = null;\n      result = func.apply(context, args);\n    };\n    return function() {\n      var now = new Date;\n      var remaining = wait - (now - previous);\n      context = this;\n      args = arguments;\n      if (remaining <= 0) {\n        clearTimeout(timeout);\n        timeout = null;\n        previous = now;\n        result = func.apply(context, args);\n      } else if (!timeout) {\n        timeout = setTimeout(later, remaining);\n      }\n      return result;\n    };\n  };\n\n  // Returns a function, that, as long as it continues to be invoked, will not\n  // be triggered. The function will be called after it stops being called for\n  // N milliseconds. If `immediate` is passed, trigger the function on the\n  // leading edge, instead of the trailing.\n  _.debounce = function(func, wait, immediate) {\n    var timeout, result;\n    return function() {\n      var context = this, args = arguments;\n      var later = function() {\n        timeout = null;\n        if (!immediate) result = func.apply(context, args);\n      };\n      var callNow = immediate && !timeout;\n      clearTimeout(timeout);\n      timeout = setTimeout(later, wait);\n      if (callNow) result = func.apply(context, args);\n      return result;\n    };\n  };\n\n  // Returns a function that will be executed at most one time, no matter how\n  // often you call it. Useful for lazy initialization.\n  _.once = function(func) {\n    var ran = false, memo;\n    return function() {\n      if (ran) return memo;\n      ran = true;\n      memo = func.apply(this, arguments);\n      func = null;\n      return memo;\n    };\n  };\n\n  // Returns the first function passed as an argument to the second,\n  // allowing you to adjust arguments, run code before and after, and\n  // conditionally execute the original function.\n  _.wrap = function(func, wrapper) {\n    return function() {\n      var args = [func];\n      push.apply(args, arguments);\n      return wrapper.apply(this, args);\n    };\n  };\n\n  // Returns a function that is the composition of a list of functions, each\n  // consuming the return value of the function that follows.\n  _.compose = function() {\n    var funcs = arguments;\n    return function() {\n      var args = arguments;\n      for (var i = funcs.length - 1; i >= 0; i--) {\n        args = [funcs[i].apply(this, args)];\n      }\n      return args[0];\n    };\n  };\n\n  // Returns a function that will only be executed after being called N times.\n  _.after = function(times, func) {\n    if (times <= 0) return func();\n    return function() {\n      if (--times < 1) {\n        return func.apply(this, arguments);\n      }\n    };\n  };\n\n  // Object Functions\n  // ----------------\n\n  // Retrieve the names of an object's properties.\n  // Delegates to **ECMAScript 5**'s native `Object.keys`\n  _.keys = nativeKeys || function(obj) {\n    if (obj !== Object(obj)) throw new TypeError('Invalid object');\n    var keys = [];\n    for (var key in obj) if (_.has(obj, key)) keys[keys.length] = key;\n    return keys;\n  };\n\n  // Retrieve the values of an object's properties.\n  _.values = function(obj) {\n    var values = [];\n    for (var key in obj) if (_.has(obj, key)) values.push(obj[key]);\n    return values;\n  };\n\n  // Convert an object into a list of `[key, value]` pairs.\n  _.pairs = function(obj) {\n    var pairs = [];\n    for (var key in obj) if (_.has(obj, key)) pairs.push([key, obj[key]]);\n    return pairs;\n  };\n\n  // Invert the keys and values of an object. The values must be serializable.\n  _.invert = function(obj) {\n    var result = {};\n    for (var key in obj) if (_.has(obj, key)) result[obj[key]] = key;\n    return result;\n  };\n\n  // Return a sorted list of the function names available on the object.\n  // Aliased as `methods`\n  _.functions = _.methods = function(obj) {\n    var names = [];\n    for (var key in obj) {\n      if (_.isFunction(obj[key])) names.push(key);\n    }\n    return names.sort();\n  };\n\n  // Extend a given object with all the properties in passed-in object(s).\n  _.extend = function(obj) {\n    each(slice.call(arguments, 1), function(source) {\n      if (source) {\n        for (var prop in source) {\n          obj[prop] = source[prop];\n        }\n      }\n    });\n    return obj;\n  };\n\n  // Return a copy of the object only containing the whitelisted properties.\n  _.pick = function(obj) {\n    var copy = {};\n    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));\n    each(keys, function(key) {\n      if (key in obj) copy[key] = obj[key];\n    });\n    return copy;\n  };\n\n   // Return a copy of the object without the blacklisted properties.\n  _.omit = function(obj) {\n    var copy = {};\n    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));\n    for (var key in obj) {\n      if (!_.contains(keys, key)) copy[key] = obj[key];\n    }\n    return copy;\n  };\n\n  // Fill in a given object with default properties.\n  _.defaults = function(obj) {\n    each(slice.call(arguments, 1), function(source) {\n      if (source) {\n        for (var prop in source) {\n          if (obj[prop] == null) obj[prop] = source[prop];\n        }\n      }\n    });\n    return obj;\n  };\n\n  // Create a (shallow-cloned) duplicate of an object.\n  _.clone = function(obj) {\n    if (!_.isObject(obj)) return obj;\n    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);\n  };\n\n  // Invokes interceptor with the obj, and then returns obj.\n  // The primary purpose of this method is to \"tap into\" a method chain, in\n  // order to perform operations on intermediate results within the chain.\n  _.tap = function(obj, interceptor) {\n    interceptor(obj);\n    return obj;\n  };\n\n  // Internal recursive comparison function for `isEqual`.\n  var eq = function(a, b, aStack, bStack) {\n    // Identical objects are equal. `0 === -0`, but they aren't identical.\n    // See the Harmony `egal` proposal: http://wiki.ecmascript.org/doku.php?id=harmony:egal.\n    if (a === b) return a !== 0 || 1 / a == 1 / b;\n    // A strict comparison is necessary because `null == undefined`.\n    if (a == null || b == null) return a === b;\n    // Unwrap any wrapped objects.\n    if (a instanceof _) a = a._wrapped;\n    if (b instanceof _) b = b._wrapped;\n    // Compare `[[Class]]` names.\n    var className = toString.call(a);\n    if (className != toString.call(b)) return false;\n    switch (className) {\n      // Strings, numbers, dates, and booleans are compared by value.\n      case '[object String]':\n        // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n        // equivalent to `new String(\"5\")`.\n        return a == String(b);\n      case '[object Number]':\n        // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for\n        // other numeric values.\n        return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);\n      case '[object Date]':\n      case '[object Boolean]':\n        // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n        // millisecond representations. Note that invalid dates with millisecond representations\n        // of `NaN` are not equivalent.\n        return +a == +b;\n      // RegExps are compared by their source patterns and flags.\n      case '[object RegExp]':\n        return a.source == b.source &&\n               a.global == b.global &&\n               a.multiline == b.multiline &&\n               a.ignoreCase == b.ignoreCase;\n    }\n    if (typeof a != 'object' || typeof b != 'object') return false;\n    // Assume equality for cyclic structures. The algorithm for detecting cyclic\n    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n    var length = aStack.length;\n    while (length--) {\n      // Linear search. Performance is inversely proportional to the number of\n      // unique nested structures.\n      if (aStack[length] == a) return bStack[length] == b;\n    }\n    // Add the first object to the stack of traversed objects.\n    aStack.push(a);\n    bStack.push(b);\n    var size = 0, result = true;\n    // Recursively compare objects and arrays.\n    if (className == '[object Array]') {\n      // Compare array lengths to determine if a deep comparison is necessary.\n      size = a.length;\n      result = size == b.length;\n      if (result) {\n        // Deep compare the contents, ignoring non-numeric properties.\n        while (size--) {\n          if (!(result = eq(a[size], b[size], aStack, bStack))) break;\n        }\n      }\n    } else {\n      // Objects with different constructors are not equivalent, but `Object`s\n      // from different frames are.\n      var aCtor = a.constructor, bCtor = b.constructor;\n      if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&\n                               _.isFunction(bCtor) && (bCtor instanceof bCtor))) {\n        return false;\n      }\n      // Deep compare objects.\n      for (var key in a) {\n        if (_.has(a, key)) {\n          // Count the expected number of properties.\n          size++;\n          // Deep compare each member.\n          if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;\n        }\n      }\n      // Ensure that both objects contain the same number of properties.\n      if (result) {\n        for (key in b) {\n          if (_.has(b, key) && !(size--)) break;\n        }\n        result = !size;\n      }\n    }\n    // Remove the first object from the stack of traversed objects.\n    aStack.pop();\n    bStack.pop();\n    return result;\n  };\n\n  // Perform a deep comparison to check if two objects are equal.\n  _.isEqual = function(a, b) {\n    return eq(a, b, [], []);\n  };\n\n  // Is a given array, string, or object empty?\n  // An \"empty\" object has no enumerable own-properties.\n  _.isEmpty = function(obj) {\n    if (obj == null) return true;\n    if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;\n    for (var key in obj) if (_.has(obj, key)) return false;\n    return true;\n  };\n\n  // Is a given value a DOM element?\n  _.isElement = function(obj) {\n    return !!(obj && obj.nodeType === 1);\n  };\n\n  // Is a given value an array?\n  // Delegates to ECMA5's native Array.isArray\n  _.isArray = nativeIsArray || function(obj) {\n    return toString.call(obj) == '[object Array]';\n  };\n\n  // Is a given variable an object?\n  _.isObject = function(obj) {\n    return obj === Object(obj);\n  };\n\n  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.\n  each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {\n    _['is' + name] = function(obj) {\n      return toString.call(obj) == '[object ' + name + ']';\n    };\n  });\n\n  // Define a fallback version of the method in browsers (ahem, IE), where\n  // there isn't any inspectable \"Arguments\" type.\n  if (!_.isArguments(arguments)) {\n    _.isArguments = function(obj) {\n      return !!(obj && _.has(obj, 'callee'));\n    };\n  }\n\n  // Optimize `isFunction` if appropriate.\n  if (typeof (/./) !== 'function') {\n    _.isFunction = function(obj) {\n      return typeof obj === 'function';\n    };\n  }\n\n  // Is a given object a finite number?\n  _.isFinite = function(obj) {\n    return isFinite(obj) && !isNaN(parseFloat(obj));\n  };\n\n  // Is the given value `NaN`? (NaN is the only number which does not equal itself).\n  _.isNaN = function(obj) {\n    return _.isNumber(obj) && obj != +obj;\n  };\n\n  // Is a given value a boolean?\n  _.isBoolean = function(obj) {\n    return obj === true || obj === false || toString.call(obj) == '[object Boolean]';\n  };\n\n  // Is a given value equal to null?\n  _.isNull = function(obj) {\n    return obj === null;\n  };\n\n  // Is a given variable undefined?\n  _.isUndefined = function(obj) {\n    return obj === void 0;\n  };\n\n  // Shortcut function for checking if an object has a given property directly\n  // on itself (in other words, not on a prototype).\n  _.has = function(obj, key) {\n    return hasOwnProperty.call(obj, key);\n  };\n\n  // Utility Functions\n  // -----------------\n\n  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its\n  // previous owner. Returns a reference to the Underscore object.\n  _.noConflict = function() {\n    root._ = previousUnderscore;\n    return this;\n  };\n\n  // Keep the identity function around for default iterators.\n  _.identity = function(value) {\n    return value;\n  };\n\n  // Run a function **n** times.\n  _.times = function(n, iterator, context) {\n    var accum = Array(n);\n    for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);\n    return accum;\n  };\n\n  // Return a random integer between min and max (inclusive).\n  _.random = function(min, max) {\n    if (max == null) {\n      max = min;\n      min = 0;\n    }\n    return min + Math.floor(Math.random() * (max - min + 1));\n  };\n\n  // List of HTML entities for escaping.\n  var entityMap = {\n    escape: {\n      '&': '&amp;',\n      '<': '&lt;',\n      '>': '&gt;',\n      '\"': '&quot;',\n      \"'\": '&#x27;',\n      '/': '&#x2F;'\n    }\n  };\n  entityMap.unescape = _.invert(entityMap.escape);\n\n  // Regexes containing the keys and values listed immediately above.\n  var entityRegexes = {\n    escape:   new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'),\n    unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g')\n  };\n\n  // Functions for escaping and unescaping strings to/from HTML interpolation.\n  _.each(['escape', 'unescape'], function(method) {\n    _[method] = function(string) {\n      if (string == null) return '';\n      return ('' + string).replace(entityRegexes[method], function(match) {\n        return entityMap[method][match];\n      });\n    };\n  });\n\n  // If the value of the named property is a function then invoke it;\n  // otherwise, return it.\n  _.result = function(object, property) {\n    if (object == null) return null;\n    var value = object[property];\n    return _.isFunction(value) ? value.call(object) : value;\n  };\n\n  // Add your own custom functions to the Underscore object.\n  _.mixin = function(obj) {\n    each(_.functions(obj), function(name){\n      var func = _[name] = obj[name];\n      _.prototype[name] = function() {\n        var args = [this._wrapped];\n        push.apply(args, arguments);\n        return result.call(this, func.apply(_, args));\n      };\n    });\n  };\n\n  // Generate a unique integer id (unique within the entire client session).\n  // Useful for temporary DOM ids.\n  var idCounter = 0;\n  _.uniqueId = function(prefix) {\n    var id = ++idCounter + '';\n    return prefix ? prefix + id : id;\n  };\n\n  // By default, Underscore uses ERB-style template delimiters, change the\n  // following template settings to use alternative delimiters.\n  _.templateSettings = {\n    evaluate    : /<%([\\s\\S]+?)%>/g,\n    interpolate : /<%=([\\s\\S]+?)%>/g,\n    escape      : /<%-([\\s\\S]+?)%>/g\n  };\n\n  // When customizing `templateSettings`, if you don't want to define an\n  // interpolation, evaluation or escaping regex, we need one that is\n  // guaranteed not to match.\n  var noMatch = /(.)^/;\n\n  // Certain characters need to be escaped so that they can be put into a\n  // string literal.\n  var escapes = {\n    \"'\":      \"'\",\n    '\\\\':     '\\\\',\n    '\\r':     'r',\n    '\\n':     'n',\n    '\\t':     't',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  var escaper = /\\\\|'|\\r|\\n|\\t|\\u2028|\\u2029/g;\n\n  // JavaScript micro-templating, similar to John Resig's implementation.\n  // Underscore templating handles arbitrary delimiters, preserves whitespace,\n  // and correctly escapes quotes within interpolated code.\n  _.template = function(text, data, settings) {\n    var render;\n    settings = _.defaults({}, settings, _.templateSettings);\n\n    // Combine delimiters into one regular expression via alternation.\n    var matcher = new RegExp([\n      (settings.escape || noMatch).source,\n      (settings.interpolate || noMatch).source,\n      (settings.evaluate || noMatch).source\n    ].join('|') + '|$', 'g');\n\n    // Compile the template source, escaping string literals appropriately.\n    var index = 0;\n    var source = \"__p+='\";\n    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {\n      source += text.slice(index, offset)\n        .replace(escaper, function(match) { return '\\\\' + escapes[match]; });\n\n      if (escape) {\n        source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n      }\n      if (interpolate) {\n        source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n      }\n      if (evaluate) {\n        source += \"';\\n\" + evaluate + \"\\n__p+='\";\n      }\n      index = offset + match.length;\n      return match;\n    });\n    source += \"';\\n\";\n\n    // If a variable is not specified, place data values in local scope.\n    if (!settings.variable) source = 'with(obj||{}){\\n' + source + '}\\n';\n\n    source = \"var __t,__p='',__j=Array.prototype.join,\" +\n      \"print=function(){__p+=__j.call(arguments,'');};\\n\" +\n      source + \"return __p;\\n\";\n\n    try {\n      render = new Function(settings.variable || 'obj', '_', source);\n    } catch (e) {\n      e.source = source;\n      throw e;\n    }\n\n    if (data) return render(data, _);\n    var template = function(data) {\n      return render.call(this, data, _);\n    };\n\n    // Provide the compiled function source as a convenience for precompilation.\n    template.source = 'function(' + (settings.variable || 'obj') + '){\\n' + source + '}';\n\n    return template;\n  };\n\n  // Add a \"chain\" function, which will delegate to the wrapper.\n  _.chain = function(obj) {\n    return _(obj).chain();\n  };\n\n  // OOP\n  // ---------------\n  // If Underscore is called as a function, it returns a wrapped object that\n  // can be used OO-style. This wrapper holds altered versions of all the\n  // underscore functions. Wrapped objects may be chained.\n\n  // Helper function to continue chaining intermediate results.\n  var result = function(obj) {\n    return this._chain ? _(obj).chain() : obj;\n  };\n\n  // Add all of the Underscore functions to the wrapper object.\n  _.mixin(_);\n\n  // Add all mutator Array functions to the wrapper.\n  each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {\n    var method = ArrayProto[name];\n    _.prototype[name] = function() {\n      var obj = this._wrapped;\n      method.apply(obj, arguments);\n      if ((name == 'shift' || name == 'splice') && obj.length === 0) delete obj[0];\n      return result.call(this, obj);\n    };\n  });\n\n  // Add all accessor Array functions to the wrapper.\n  each(['concat', 'join', 'slice'], function(name) {\n    var method = ArrayProto[name];\n    _.prototype[name] = function() {\n      return result.call(this, method.apply(this._wrapped, arguments));\n    };\n  });\n\n  _.extend(_.prototype, {\n\n    // Start chaining a wrapped Underscore object.\n    chain: function() {\n      this._chain = true;\n      return this;\n    },\n\n    // Extracts the result from a wrapped and chained object.\n    value: function() {\n      return this._wrapped;\n    }\n\n  });\n\n}).call(this);\n"],"x_google_ignoreList":[1,2,4]}