{"version":3,"file":"vendor.js","mappings":"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","names":["Observable","constructor","subscribe","this","_subscribe","lift","operator","observable","source","observerOrNext","error","complete","subscriber","value","Subscriber","isFunction","next","isObserver","isSubscription","isSubscriber","SafeSubscriber","errorContext","add","call","_trySubscribe","sink","err","forEach","promiseCtor","getPromiseCtor","resolve","reject","unsubscribe","_a","Symbol_observable","pipe","operations","pipeFromArray","toPromise","x","create","config","Promise","ObjectUnsubscribedError","createErrorClass","_super","name","message","Subject","super","closed","currentObservers","observers","isStopped","hasError","thrownError","subject","AnonymousSubject","_throwIfClosed","Array","from","observer","length","shift","observed","_checkFinalizedStatuses","_innerSubscribe","EMPTY_SUBSCRIPTION","push","Subscription","arrRemove","asObservable","destination","_b","COMPLETE_NOTIFICATION","createNotification","undefined","kind","H","EMPTY_OBSERVER","handleStoppedNotification","nextNotification","_next","errorNotification","_error","_complete","_bind","Function","prototype","bind","fn","thisArg","partialObserver","handleUnhandledError","context","Object","ConsumerObserver","captureError","reportUnhandledError","notification","onStoppedNotification","timeoutProvider","noop","UnsubscriptionError","errors","map","i","toString","join","initialTeardown","_parentage","_finalizers","isArray","parent","remove","initialFinalizer","e","finalizer","execFinalizer","ve","teardown","_hasParent","_addParent","includes","_removeParent","EMPTY","empty","onUnhandledError","useDeprecatedSynchronousErrorHandling","useDeprecatedNextContext","scheduler","delay","operate","schedule","input","Error","executeSchedule","iterator","Symbol","asyncIterator","then","result","done","isInteropObservable","innerFrom","subscribeOn","observeOn","scheduleObservable","isArrayLike","scheduleArray","isPromise","schedulePromise","isAsyncIterable","scheduleAsyncIterable","isIterable","Symbol_iterator","return","scheduleIterable","isReadableStreamLike","readableStreamLikeToAsyncGenerator","scheduleReadableStreamLike","createInvalidObservableTypeError","scheduled","obj","obs","TypeError","fromInteropObservable","array","fromArrayLike","promise","fromPromise","fromAsyncIterable","iterable","fromIterable","readableStream","fromReadableStreamLike","asyncIterable","asyncIterable_1","asyncIterable_1_1","e_1","__awaiter","__asyncValues","e_1_1","process","catch","args","popScheduler","concurrent","popNumber","Infinity","sources","ie","mergeAll","onNext","onComplete","onError","onFinalize","OperatorSubscriber","shouldUnsubscribe","project","index","createOperatorSubscriber","mergeMap","identity","resultSelector","a","b","ii","onBeforeNext","expand","innerSubScheduler","additionalFinalizer","buffer","active","isComplete","checkComplete","outerNext","doInnerSub","innerComplete","innerValue","Ce","bufferedValue","mergeInternals","options","connector","resetOnError","resetOnComplete","resetOnRefCountZero","wrapperSource","connection","resetConnection","refCount","hasCompleted","hasErrored","cancelReset","reset","resetAndUnsubscribe","conn","dest","handleReset","on","onSubscriber","setTimeout","handler","timeout","delegate","clearTimeout","handle","getSymbolIterator","arr","last","pop","isScheduler","defaultValue","item","indexOf","splice","createImpl","ctorFunc","instance","stack","cb","isRoot","errorThrown","parentSubscription","work","repeat","scheduleSubscription","de","__asyncGenerator","arguments","reader","getReader","__await","read","releaseLock","init","hasLift","liftedSource","fns","reduce","prev","Te","Ft","ke","At","se","oe","Q","Je","yn","Kn","dt","tt","X","_DOM","adapter","DOCUMENT","InjectionToken","PlatformLocation","historyGo","relativePosition","ɵfac","ɵprov","i0","factory","ɵɵinject","BrowserPlatformLocation","useBrowserPlatformLocation","providedIn","LOCATION_INITIALIZED","_doc","_init","location","window","_history","history","getBaseHrefFromDOM","getDOM","getBaseHref","onPopState","getGlobalEventTarget","addEventListener","removeEventListener","onHashChange","href","protocol","hostname","port","pathname","search","hash","newPath","pushState","state","title","url","supportsState","replaceState","forward","back","go","getState","createBrowserPlatformLocation","start","end","slashes","endsWith","startsWith","substring","match","pathEndIdx","slice","params","LocationStrategy","platformLocation","PathLocationStrategy","origin","provideLocationStrategy","APP_BASE_HREF","_platformLocation","_removeListenerFns","_baseHref","ngOnDestroy","prepareExternalUrl","internal","joinWithSlash","path","includeHash","normalizeQueryParams","queryParams","externalUrl","HashLocationStrategy","Location","platformStrategy","_subject","EventEmitter","_urlChangeListeners","_platformStrategy","browserBaseHref","stripTrailingSlash","_stripIndexHtml","ev","emit","type","normalize","isCurrentPathEqualTo","query","baseHref","_stripBaseHref","_notifyUrlChangeListeners","onUrlChange","_urlChangeSubscription","v","onThrow","onReturn","createLocation","replace","CURRENCIES_EN","ADP","AFN","ALL","AMD","AOA","ARS","AUD","AZN","BAM","BBD","BDT","BHD","BIF","BMD","BND","BOB","BRL","BSD","BWP","BYN","BYR","BZD","CAD","CHF","CLF","CLP","CNY","COP","CRC","CUC","CUP","CZK","DJF","DKK","DOP","EGP","ESP","EUR","FJD","FKP","GBP","GEL","GHS","GIP","GNF","GTQ","GYD","HKD","HNL","HRK","HUF","IDR","ILS","INR","IQD","IRR","ISK","ITL","JMD","JOD","JPY","KHR","KMF","KPW","KRW","KWD","KYD","KZT","LAK","LBP","LKR","LRD","LTL","LUF","LVL","LYD","MGA","MGF","MMK","MNT","MRO","MUR","MXN","MYR","NAD","NGN","NIO","NOK","NPR","NZD","OMR","PHP","PKR","PLN","PYG","RON","RSD","RUB","RUR","RWF","SBD","SEK","SGD","SHP","SLL","SOS","SRD","SSP","STD","STN","SYP","THB","TMM","TND","TOP","TRL","TRY","TTD","TWD","TZS","UAH","UGX","USD","UYI","UYU","UYW","UZS","VEF","VND","VUV","XAF","XCD","XOF","XPF","XXX","YER","ZAR","ZMK","ZMW","ZWD","NumberFormatStyle","Decimal","Percent","Currency","Scientific","FormStyle","Format","Standalone","TranslationWidth","Narrow","Abbreviated","Wide","Short","FormatWidth","Medium","Long","Full","NumberSymbol","Group","List","PercentSign","PlusSign","MinusSign","Exponential","SuperscriptingExponent","PerMille","NaN","TimeSeparator","CurrencyDecimal","CurrencyGroup","locale","width","getLastDefinedValue","ɵfindLocaleData","ɵLocaleDataIndex","data","symbol","res","time","h","m","split","hours","minutes","ISO8601_DATE_REGEX","NAMED_FORMATS","DATE_FORMATS_SPLIT","ZoneWidth","ShortGMT","Extended","DateType","FullYear","Month","Date","Hours","Minutes","Seconds","FractionalSeconds","Day","TranslationType","DayPeriods","Days","Months","Eras","format","timezone","date","isDate","isNaN","trim","test","y","d","val","createDate","parsedNb","parseFloat","tzHour","tzMin","dateSetter","setUTCFullYear","setFullYear","timeSetter","setUTCHours","setHours","Number","s","ms","Math","floor","isoStringToDate","toDate","namedFormat","parts","exec","concat","part","dateTimezoneOffset","getTimezoneOffset","timezoneToOffset","reverse","reverseValue","getTime","setMinutes","getMinutes","addDateMinutes","convertTimezoneToLocal","text","dateFormatter","DATE_FORMATS","formatter","dateStrGetter","dateGetter","weekNumberingYearGetter","weekGetter","timeZoneGetter","getDateFormatter","year","month","newDate","localeId","getLocaleId","formatValue","getLocaleDateFormat","getLocaleTimeFormat","shortTime","getNamedFormat","shortDate","formatDateTime","getLocaleDateTimeFormat","mediumTime","mediumDate","longTime","longDate","fullTime","fullDate","str","opt_values","key","num","digits","minusSign","negWrap","neg","strNum","String","substr","size","offset","getFullYear","getMonth","getDate","getHours","getSeconds","getMilliseconds","getDay","getDatePart","milliseconds","strMs","formatFractionalSeconds","localeMinus","getLocaleNumberSymbol","padNumber","form","extended","formStyle","months","getLocaleMonthNames","days","getLocaleDayNames","currentHours","currentMinutes","rules","checkFullData","rule","extractTime","getLocaleExtraDayPeriodRules","dayPeriods","getLocaleExtraDayPeriods","findIndex","to","afterFrom","beforeTo","amPm","getLocaleDayPeriods","getLocaleEraNames","unexpected","getDateTranslation","zone","ceil","abs","datetime","monthBased","nbDaysBefore1stDayOfMonth","today","thisThurs","getThursdayThisWeek","firstThurs","firstDayOfYear","THURSDAY","getFirstThursdayOfYear","diff","round","fallback","requestedTimezoneOffset","parse","valueOf","NUMBER_FORMAT_REGEXP","currency","currencyCode","digitsInfo","pattern","p","minInt","minFrac","maxFrac","posPre","posSuf","negPre","negSuf","gSize","lgSize","patternParts","positive","negative","positiveParts","lastIndexOf","integer","fraction","ch","charAt","ht","groups","trunkLen","pos","parseNumberFormat","getLocaleNumberFormat","code","DEFAULT_NB_OF_CURRENCY_DIGITS","getNumberOfCurrencyDigits","groupSymbol","decimalSymbol","isPercent","formattedText","isZero","isFinite","parsedNumber","integerLen","j","zeros","numStr","exponent","MAX_DIGITS","parseNumber","fractionLen","toPercent","minFraction","maxFraction","minIntPart","minFractionPart","maxFractionPart","parseIntAutoRadix","li","fractionSize","min","max","roundAt","digit","k","unshift","dropTrailingZeros","minLen","carry","reduceRight","roundNumber","decimals","every","parseInt","extraData","ɵregisterLocaleData","cookieStr","encodeURIComponent","cookie","eqIndex","cookieName","cookieValue","decodeURIComponent","NgClass","_iterableDiffers","_keyValueDiffers","_ngEl","_renderer","_iterableDiffer","_keyValueDiffer","_initialClasses","_rawClass","klass","_removeClasses","_applyClasses","ngClass","ɵisListLikeIterable","find","ngDoCheck","iterableChanges","_applyIterableChanges","keyValueChanges","_applyKeyValueChanges","changes","forEachAddedItem","record","_toggleClass","currentValue","forEachChangedItem","forEachRemovedItem","previousValue","ɵstringify","rawClassVal","Set","keys","enabled","addClass","nativeElement","removeClass","ɵdir","selectors","$implicit","ngForOf","count","first","even","odd","NgForOf","_viewContainer","_template","_differs","_ngForOf","_ngForOfDirty","_differ","ngForTrackBy","_trackByFn","ngForTemplate","_applyChanges","viewContainer","forEachOperation","adjustedPreviousIndex","currentIndex","previousIndex","createEmbeddedView","NgForOfContext","view","get","move","applyViewChange","ilen","viewRef","forEachIdentityChange","dir","ctx","NgIf","templateRef","_context","NgIfContext","_thenTemplateRef","_elseTemplateRef","_thenViewRef","_elseViewRef","ngIf","condition","_updateView","ngIfThen","assertTemplate","ngIfElse","clear","property","_viewContainerRef","_templateRef","_created","destroy","enforceState","created","NgSwitch","_defaultUsed","_caseCount","_lastCaseCheckIndex","_lastCasesMatched","ngSwitch","newValue","_ngSwitch","_updateDefaultCases","_addCase","_addDefault","_defaultViews","_matchCase","matched","useDefault","NgSwitchCase","_view","SwitchView","ngSwitchCase","NgSwitchDefault","NgStyle","_ngStyle","ngStyle","values","_setStyle","nameAndUnit","unit","setStyle","removeStyle","NgTemplateOutlet","_viewRef","ngTemplateOutletContext","ngTemplateOutlet","ngOnChanges","viewContainerRef","ɵRuntimeError","errorMessage","createSubscription","async","updateLatestValue","dispose","subscription","onDestroy","_promiseStrategy","PromiseStrategy","_subscribableStrategy","SubscribableStrategy","AsyncPipe","_ref","_latestValue","_subscription","_obj","_strategy","_dispose","transform","_selectStrategy","_updateLatestValue","ɵisPromise","ɵisSubscribable","invalidPipeArgumentError","markForCheck","ɵpipe","pure","DATE_PIPE_DEFAULT_TIMEZONE","DatePipe","defaultTimezone","formatDate","LOCALE_ID","CurrencyPipe","_locale","_defaultCurrencyCode","display","isValue","getLocaleCurrencies","symbolNarrow","getCurrencySymbol","formatCurrency","strToNumber","DEFAULT_CURRENCY_CODE","CommonModule","ɵmod","ɵinj","PLATFORM_BROWSER_ID","platformId","ViewportScroller","ɵɵdefineInjectable","token","BrowserViewportScroller","document","setOffset","getScrollPosition","supportsScrolling","pageXOffset","pageYOffset","scrollToPosition","position","scrollTo","scrollToAnchor","target","elSelected","documentResult","getElementById","getElementsByName","createTreeWalker","body","createShadowRoot","attachShadow","treeWalker","NodeFilter","SHOW_ELEMENT","currentNode","shadowRoot","querySelector","nextNode","findAnchorFromDocument","scrollToElement","focus","setHistoryScrollRestoration","scrollRestoration","supportScrollRestoration","el","rect","getBoundingClientRect","left","top","scrollRestorationDescriptor","getScrollRestorationProperty","getPrototypeOf","writable","set","getOwnPropertyDescriptor","ViewEncapsulation","Emulated","None","ShadowDom","self","WorkerGlobalScope","global","BigInteger","clone","other","addToSelf","maxNrOfDigits","digitSum","powerOfTwos","getValue","multiplyBy","product","zero","multiplyByAndAddTo","getMultipliedByPowerOfTwo","previousPower","base","exponents","BigIntForMultiplication","one","toThePowerOf","utf8","encoded","codePoint","charCodeAt","low","utf8Encode","hi","hash32","lo","msg","meaning","msgFingerprint","fingerprint","meaningFingerprint","ah","bh","add32to64","l","add32","add64","rol64","decimal","base256","wordsToDecimalString","bytes","c","len","wordAt","Endian","Little","mix","sub32","Big","high","endian","word","byteAt","BigIntExponentiation","useClass","useFactory","useValue","useExisting","defaultEncapsulation","useJit","jitDevMode","missingTranslation","preserveWhitespaces","strictInjectionParameters","preserveWhitespacesOption","defaultSetting","preserveWhitespacesDefault","noUndefined","definitionMap","objWithPropertyToExtract","getClosureSafeProperty","hasOwnProperty","stringify","overriddenName","newLineIndex","before","after","__forward_ref__","forwardRefFn","forwardRef","isForwardRef","formatRuntimeError","renderStringify","injectorName","injectorDetails","RuntimeError","stringifyForError","actual","expected","comparison","opts","defineInjectable","providers","imports","getOwnDefinition","NG_PROV_DEF","NG_INJECTABLE_DEF","field","NG_INJ_DEF","NG_INJECTOR_DEF","ngInjectableDef","ngInjectorDef","InjectFlags","Default","Host","Self","SkipSelf","Optional","_injectImplementation","impl","previous","notFoundValue","flags","injectableDef","getInjectableDef","throwProviderNotFoundError","ChangeDetectionStrategy","OnPush","ViewEncapsulation$1","__globalThis","globalThis","__window","__self","_global","EMPTY_OBJ","EMPTY_ARRAY","NG_COMP_DEF","ɵcmp","NG_DIR_DEF","NG_PIPE_DEF","NG_MOD_DEF","NG_FACTORY_DEF","NG_ELEMENT_ID","__NG_ELEMENT_ID__","_renderCompCount","componentDefinition","noSideEffects","declaredInputs","def","providersResolver","decls","vars","template","consts","ngContentSelectors","hostBindings","hostVars","hostAttrs","contentQueries","inputs","outputs","exportAs","onPush","changeDetection","directiveDefs","pipeDefs","viewQuery","features","encapsulation","id","styles","_","setInput","schemas","tView","directiveTypes","directives","feature","pipeTypes","pipes","invertObject","extractDirectiveDef","extractPipeDef","getComponentDef","getDirectiveDef","getPipeDef$1","autoRegisterModuleById","bootstrap","declarations","exports","transitiveCompileScopes","scope","ngModuleDef","getNgModuleDef","secondary","newLookup","minifiedKey","publicName","declaredName","ɵɵdefineDirective","ɵɵdefineComponent","pipeDef","throwNotFound","tNode","firstChange","isFirstChange","NgOnChangesFeatureImpl","definition","ngOnChangesSetInput","rememberChangeHistoryAndInvokeOnChangesHook","simpleChangesStore","getSimpleChangesStore","current","privateName","store","SIMPLE_CHANGES_STORE","setSimpleChangesStore","previousChange","SimpleChange","ɵɵNgOnChangesFeature","ngInherit","renderer","listen","domRendererFactory3","createRenderer","hostElement","rendererType","getDocument","lView","unwrapRNode","nodeIndex","hostView","slotValue","isLView","HOST","lContainer","amount","viewOrContainer","PARENT","instructionState","lFrame","createLFrame","bindingsEnabled","viewToRestore","contextLView","CONTEXT","currentTNode","getCurrentTNodePlaceholderOk","isParent","bindingRootIndex","bindingStartIndex","bindingIndex","isInI18nBlock","inI18n","currentDirectiveIndex","setCurrentDirectiveIndex","tData","currentQueryIndex","declTNode","parentTNode","parentLView","getDeclarationTNode","allocLFrame","newView","newLFrame","firstChild","currentLFrame","childLFrame","child","selectedIndex","elementDepthCount","currentNamespace","oldLFrame","leaveDI","leaveViewLight","getTNode","SVG_NAMESPACE","namespaceHTMLInternal","directiveStart","directiveEnd","lifecycleHooks","directiveDef","ngAfterContentInit","ngAfterContentChecked","ngAfterViewInit","ngAfterViewChecked","contentHooks","contentCheckHooks","viewHooks","viewCheckHooks","destroyHooks","hooks","callHooks","initPhase","currentView","currentNodeIndex","nodeIndexLimit","lastNodeIndexFound","isInitHook","callHook","hook","directive","indexWithintInitPhase","isViewProvider","injectImplementation","resolving","canSeeViewProviders","injectImpl","native","attrs","isProc","isProceduralRenderer","namespaceURI","attrName","attrVal","setAttribute","setAttributeNS","isAnimationProp","setProperty","marker","dst","src","srcMarker","mergeHostAttribute","key1","key2","markerInsertPosition","dstValue","parentLocation","NO_PARENT_INJECTOR","startView","viewOffset","getParentInjectorViewOffset","parentView","includeViewProviders","oldValue","nextNgElementId","existingInjectorIndex","getInjectorIndex","firstCreatePass","injectorIndex","insertBloom","blueprint","parentLoc","getParentInjectorLocation","hasParentInjector","parentIndex","getParentInjectorIndex","getParentInjectorView","parentData","footer","declarationViewOffset","lViewCursor","tViewType","bloomHash","BLOOM_SIZE","mask","bloomAdd","moduleInjector","previousInjectImplementation","setInjectImplementation","injectRootLimpMode","notFoundValueOrThrow","tokenId","createNodeInjector","bloomHashBitOrFactory","enterDI","lookupTokenUsingModuleInjector","previousTView","hostTElementNode","g","shouldSearchParent","bloomHasToken","searchTokensOnInjector","NOT_FOUND","NodeInjector","getCurrentTNode","getLView","currentTView","injectableIdx","locateDirectiveOrProvider","isComponentHost","getNodeInjectable","canAccessViewProviders","isHostSpecialCase","nodeProviderIndexes","providerIndexes","tInjectables","injectablesStart","directivesStart","cptViewProvidersCount","endIndex","providerTokenOrDef","dirDef","isComponentDef","NodeInjectorFactory","isFactory","depPath","throwCyclicDependencyError","previousIncludeViewProviders","setIncludeViewProviders","directiveIndex","ngOnInit","wrappedOnChanges","preOrderHooks","preOrderCheckHooks","registerPreOrderHooks","injectorView","isFirstHostTNode","_tNode","_lView","getOrCreateInjectable","ownConstructor","ownFactory","getFactoryOf","objectPrototype","t","resolveForwardRef","getFactoryDef","attrNameToInject","classes","attrsLength","isNameOnlyAttributeMarker","injectAttributeImpl","PARAMETERS","props","parentClass","metaCtor","propName","makeMetadataCtor","ParamDecoratorFactory","apply","annotationInstance","ParamDecorator","annotation","cls","unusedKey","parameters","defineProperty","ngMetadataName","annotationCls","_desc","ANALYZE_FOR_ENTRY_COMPONENTS","Type","list","flatten","deepForEach","keyValueArray","keyValueArrayIndexOf","value1","value2","arrayInsert2","middle","_arrayIndexOfSorted","THROW_IF_NOT_FOUND","DI_DECORATOR_FLAG","NG_TEMP_TOKEN_PATH","NEW_LINE","SOURCE","USE_VALUE$1","provide","_currentInjector","injector","former","getInjectImplementation","injectInjectorOnly","inject","types","arg","meta","flag","getInjectFlag","decorator","Inject","attachInjectFlag","makeParamDecorator","RendererStyleFlags2","Important","DashCase","COMMENT_DISALLOWED","COMMENT_DELIMITER","MONKEY_PATCH_KEY_NAME","readPatchedData","_icuContainerIterate","tIcuContainerNode","isLContainer","getNearestLContainer","CHILD_HEAD","container","NEXT","action","lNodeToHandle","beforeNode","isComponent","rNode","u","nativeAppendChild","nativeInsertBefore","nativeRemoveNode","destroyNode","parentRElement","anchor","applyToElementOrContainer","applyView","applyContainer","createText","createTextNode","setValue","textContent","createComment","COMMENT_DELIMITER_ESCAPED","escapeCommentText","namespace","createElement","namespaceUri","toLowerCase","getNamespaceUri","createElementNS","declarationContainer","movedViews","declarationViewIndex","insertionLContainer","updateTransplantedViewCount","removeIndex","indexInContainer","viewToDetach","declarationLContainer","detachMovedView","removedLView","removeFromArray","removeViewFromContainer","lQueries","detachView","rootView","lViewOrLContainer","cleanUpView","firstView","destroyViewTree","toCall","callContext","executeOnDestroys","tCleanup","cleanup","lCleanup","lastLCleanupIndex","idxOrTargetGetter","listener","useCaptureOrSubIdx","E","processCleanups","getClosestRElement","getNativeByTNode","isMove","insertBefore","appendChild","node","parentNode","_getInsertInFrontOfRNodeWithI18n","_processI18nInsertBefore","policy$1","policy","getInsertInFrontOfRNodeWithNoI18n","getInsertInFrontOfRNodeWithI18n","processI18nInsertBefore","childRNode","childTNode","parentRNode","getParentRElement","anchorNode","getInsertInFrontOfRNode","nativeAppendOrInsertBefore","tNodeType","getBeforeNodeForView","elIcuContainerChild","getFirstNativeNode","rNodeOrLContainer","projectionNodes","getProjectionNodes","getLViewParent","componentView","projection","viewIndexInContainer","nextViewIndex","firstTNodeOfView","NATIVE","isHostElement","nativeParent","nativeParentNode","removeChild","nativeRemoveChild","isProjection","rawSlotValue","attachPatchData","applyNodes","nextRNode","icuContainerIterate","applyProjectionRecursive","projectionNext","tProjectionNode","componentLView","nodeToProjectOrRNodes","componentNode","element","style","cssText","removeAttribute","className","html","trustedTypes","createPolicy","createHTML","createScript","createScriptURL","getPolicy$1","getPolicy","changingThisBreaksApplicationSecurity","SafeValueImpl","getTypeName","actualType","getSanitizationBypassType","trustedHtml","SafeHtmlImpl","trustedStyle","SafeStyleImpl","trustedScript","SafeScriptImpl","trustedUrl","SafeUrlImpl","trustedResourceUrl","SafeResourceUrlImpl","defaultDoc","inertDocumentHelper","InertDocumentHelper","DOMParser","parseFromString","trustedHTMLFromString","isDOMParserAvailable","DOMParserHelper","getInertBodyElement","inertDocument","implementation","createHTMLDocument","inertHtml","inertBodyElement","templateEl","innerHTML","inertBody","documentMode","stripCustomNsAttrs","elAttrs","attributes","attrib","childNode","nodeType","Node","ELEMENT_NODE","nextSibling","SAFE_URL_PATTERN","DATA_URL_PATTERN","srcset","_sanitizeUrl","tags","sets","VOID_ELEMENTS","tagSet","OPTIONAL_END_TAG_BLOCK_ELEMENTS","OPTIONAL_END_TAG_INLINE_ELEMENTS","VALID_ELEMENTS","merge","URI_ATTRS","SRCSET_ATTRS","VALID_ATTRS","SKIP_TRAVERSING_CONTENT_IF_INVALID_ELEMENTS","sanitizedSomething","buf","sanitizeChildren","traverseContent","startElement","TEXT_NODE","chars","nodeValue","endElement","checkClobberedElement","tagName","nodeName","elAttr","lower","sanitizeSrcset","encodeEntities","compareDocumentPosition","DOCUMENT_POSITION_CONTAINED_BY","outerHTML","SURROGATE_PAIR_REGEXP","NON_ALPHANUMERIC_REGEXP","inertBodyHelper","unsafeHtmlInput","getInertBodyHelper","unsafeHtml","mXSSAttempts","parsedHtml","sanitizer","SanitizingHtmlSerializer","getTemplateContent","safeHtml","isTemplateElement","content","SecurityContext","NONE","HTML","STYLE","SCRIPT","URL","RESOURCE_URL","getSanitizer","trustedHTMLFromStringBypass","sanitize","allowSanitizationBypassAndThrow","unwrapSafeValue","_sanitizeHtml","unsafeUrl","SANITIZER","ERROR_ORIGINAL_ERROR","console","_console","handleError","originalError","_findOriginalError","errorLogger","ERROR_LOGGER","defaultErrorLogger","getErrorLogger","getOriginalError","defaultScheduler","requestAnimationFrame","ownerDocument","defaultView","classToSearch","startingIndex","foundIndex","NG_TEMPLATE_SELECTOR","cssClassToMatch","isProjectionMode","classIndexOf","currentSelector","tagNameToCompare","selector","mode","nodeAttrs","nameOnlyMarkerIdx","getNameOnlyMarkerIndex","skipToNextSelector","hasTagAndTypeMatch","isPositive","selectorAttrValue","isCssClassMatching","attrIndexInNode","findAttrIndexInNode","isInlineTemplate","nodeAttrValue","compareAgainstClassName","bindingsMode","maybeAttrName","attr","matchTemplateAttribute","isNodeMatchingSelector","selectorListLoop","currentSelectorInList","isNegativeMode","chunk","currentChunk","valueOrMarker","attrValue","maybeWrapInNotSelector","NO_CHANGE","delta","selectIndexInternal","getTView","getSelectedIndex","checkNoChangesMode","executeCheckHooks","executeInitAndCheckHooks","setSelectedIndex","tStylingRange","queryStartIdx","directiveDefIdx","setCurrentQueryIndex","host","tHostNode","rendererFactory","resetPreOrderHookFlags","createTNodeAtIndex","getCurrentParentTNode","setCurrentTNode","isCurrentTNodeParent","tParent","insertBeforeIndex","directiveStylingLast","propertyBindings","mergedAttrs","localNames","initialInputs","tViews","stylesWithoutHost","residualStyles","classesWithoutHost","residualClasses","classBindings","styleBindings","createTNode","numSlotsToAlloc","initialValue","allocIdx","enterView","executeViewQueryFn","templateFn","executeTemplate","staticContentQueries","refreshContentQueries","staticViewQueries","components","hostLView","renderComponent$1","renderChildComponents","leaveView","incompleteFirstPass","setBindingIndex","hooksInitPhaseCompleted","incrementInitPhaseFlags","getFirstLContainer","getNextLContainer","movedLView","markTransplantedViewsForRefresh","embeddedLView","embeddedTView","viewAttachedToChangeDetector","refreshView","refreshEmbeddedViews","hostBindingOpCodes","opCode","directiveIdx","bindingRootIndx","hostBindingFn","setBindingRootForHostBindings","processHostBindingOpCodes","refreshComponent","refreshChildComponents","firstUpdatePass","creationModeIsActive","isCreationMode","begin","renderView","rf","prevSelectedIndex","isUpdatePhase","isContentQueryHost","getBindingsEnabled","getOrCreateNodeInjectorForNode","addComponentLogic","setInputsFromAttrs","getComponentLViewByIndex","instantiateAllDirectives","elementIndex","getCurrentDirectiveIndex","dirIndex","invokeHostBindingsInCreationMode","invokeDirectivesHostBindings","viewData","localRefExtractor","localIndex","createTView","constsOrFactory","initialViewLength","createViewBlueprint","queries","fill","expandoStartIndex","directiveRegistry","pipeRegistry","cleanupFn","getOrCreateLViewCleanup","getOrCreateTViewCleanup","inputAliasMap","propStore","internalName","nativeOnly","dataValue","inputData","setInputsForProperty","viewIndex","childComponentLView","markDirtyIfOnPush","n","mapPropName","$t","localRefs","hasDirectives","registry","matches","isNodeMatchingSelectorList","diPublicInInjector","dn","markAsComponentHost","findDirectiveDefMatches","exportsMap","initTNodeFlags","preOrderHooksFound","preOrderCheckHooksFound","allocExpando","mergeHostAttrs","configureViewWithDirective","saveNameToExportMap","lifeCycleHooks","tViewData","tNodeAttrs","inputsFromAttrs","inputsStore","outputsStore","directiveInputs","generateInitialInputs","generatePropertyAliases","initializeInputAndOutputAliases","ngDevMode","cacheMatchingLocalNames","directiveVarsIdx","elementIndx","lastSelectedElementIdx","hostTNode","numberOfDirectives","directiveFactory","nodeInjectorFactory","registerHostBindingOpCodes","getOrCreateTComponentView","addToViewTree","createLView","strValue","initialInputData","inputsToStore","hostNative","componentHostIdx","refreshContainsDirtyView","componentTView","syncViewWithBlueprint","isRootView","rootContext","rootComponent","readPatchedLView","renderComponentOrTemplate","tickRootContext","viewQueryFn","component","CLEAN_PROMISE","currentDef","unwrapLView","RENDERER","errorHandler","ErrorHandler","getNativeByIndex","updateTextNode","writeToHost","concatStringsWithSpace","INJECTOR","INJECTOR_SCOPE","NOT_YET","CIRCULAR","NULL_INJECTOR$1","NullInjector","defType","additionalProviders","createInjectorWithoutInjectorInstances","_resolveInjectorDefTypes","R3Injector","getNullInjector","records","Map","injectorDefTypes","_destroyed","dedupStack","provider","processProvider","injectorDef","processInjectorType","makeRecord","destroyed","assertNotDestroyed","service","previousInjector","setCurrentInjector","couldBeInjectableType","injectableDefInScope","injectableDefOrInjectorDefFactory","hydrate","o","injectorErrorName","tokenPath","JSON","formatError","NG_TOKEN_PATH","catchInjectorError","tokens","defOrWrappedDef","parents","getInjectorDef","ngModule","isDuplicate","importTypesWithProviders","imported","defProviders","injectorType","ngModuleType","isTypeProvider","isValueProvider","providerToFactory","providerToRecord","multi","multiRecord","injectArgs","hasOnDestroy","has","paramLength","newArray","inheritedInjectableDef","typeName","warn","getInheritedInjectableDef","getUndecoratedInjectableFactory","unwrappedProvider","isFactoryProvider","deps","isExistingProvider","classRef","hasDeps","Injector","static","createInjector","NULL","registerPostOrderHooks","superType","getSuperType","shouldInheritFields","inheritanceChain","superDef","writeableDef","maybeUnwrapEmpty","superHostBindings","inheritHostBindings","superViewQuery","superContentQueries","inheritViewQuery","inheritContentQueries","fillProperties","animation","defData","ɵɵInheritDefinitionFeature","mergeHostAttrsAcrossInheritance","prevViewQuery","prevContentQueries","prevHostBindings","_symbolIterator","getOwnPropertyNames","entries","isJsObject","is","exp1","exp2","different","bindingUpdated","exp3","bindingUpdated2","nextBindingIndex","setElementAttribute","elementAttributeInternal","getSelectedTNode","ɵɵattribute","prefix","v0","suffix","attrsIndex","localRefsIndex","adjustedIndex","tViewConsts","getOrCreateTNode","getConstant","resolveDirectives","templateFirstCreatePass","comment","createLContainer","isDirectiveHost","createDirectivesInstances","saveResolvedLocalsInData","load","getContextLView","elementPropertyInternal","ɵɵproperty","isClassBased","createElementNode","getNamespace$1","computeStaticStyling","elementStart","elementStartFirstCreatePass","setUpAttributes","writeDirectClass","writeDirectStyle","getElementDepthCount","increaseElementDepthCount","executeContentQueries","ɵɵelementStart","setCurrentTNodeAsNotParent","decreaseElementDepthCount","elementEnd","hasClassInput","setDirectiveInputsWhichShadowsStyling","hasStyleInput","ɵɵelementEnd","ɵɵelement","elementContainerStartFirstCreatePass","ɵɵelementContainerStart","ɵɵelementContainerEnd","ɵɵelementContainer","isObservable","isSubscribable","eventName","listenerFn","useCapture","eventTargetResolver","listenerInternal","ɵɵlistener","loadComponentRenderer","getCurrentDirectiveDef","ɵɵsyntheticHostListener","isTNodeDirectiveHost","processOutputs","lCleanupIndex","existingListener","tNodeIdx","cleanupEventName","listenerIdxInLCleanup","findExistingListener","__ngLastListenerFn__","__ngNextListenerFn__","wrapListener","propsLength","output","idx","profiler","wrapWithPreventDefault","markViewDirty","executeListenerWithErrorHandling","nextListenerFn","wrapListenerIn_markDirtyAndPreventDefault","preventDefault","returnValue","level","nestingLevel","walkUpViews","nextContextImpl","projectionSlots","wildcardNgContentIndex","ngProjectAsAttrVal","ngProjectAsAttrIdx","getProjectAsAttrValue","isSelectorInSelectorList","projectionHeads","tails","componentChild","slotIndex","matchingProjectionSlotIndex","selectorIndex","applyProjection","ɵɵpropertyInterpolate1","ɵɵpropertyInterpolate","interpolatedValue","interpolation1","tStylingKey","isPrevDir","isClassBinding","tStylingAtIndex","isMap","cursor","getTStylingRangePrev","getTStylingRangeNext","foundDuplicate","tStyleRangeAtCursor","isStylingMatch","setTStylingRangeNextDuplicate","setTStylingRangePrevDuplicate","tStylingKeyCursor","parserState","textEnd","keyEnd","valueEnd","startIndex","consumeClassToken","consumeWhitespace","consumeStyleKey","consumeSeparator","ch1","ch2","ch3","lastChIndex","consumeQuotedText","consumeStyleValue","separator","quoteCharCode","prop","checkStylingProperty","ɵɵstyleProp","ɵɵclassProp","checkStylingMap","styleKeyValueArraySet","styleStringParser","resetParserState","parseStyleNext","parseStyle","getLastParsedKey","getLastParsedValue","keyValueArraySet","classStringParser","parseClassNameNext","parseClassName","incrementBindingIndex","stylingFirstUpdatePass","updateStyling","normalizeSuffix","stringParser","hasStylingInputShadow","isInHostBindings","staticPrefix","oldKeyValueArray","newKeyValueArray","oldIndex","newIndex","oldKey","newKey","setKey","updateStylingMap","styleKeyValueArray","unwrappedValue","toStylingKeyValueArray","isHostBindings","stylingKey","hostDirectiveDef","residual","collectStylingFromTAttrs","collectStylingFromDirectives","templateStylingKey","bindings","getTemplateHeadTStylingKey","setTemplateHeadTStylingKey","collectResidual","wrapInStaticStylingKey","tStylingKeyWithStatic","isHostBinding","tBindings","tmplHead","tmplTail","isKeyDuplicateOfStatic","staticKeyValueArray","previousNode","toTStylingRange","setTStylingRangeNext","setTStylingRangePrev","f","markDuplicates","markDuplicateOfResidualStyling","insertTStylingBinding","currentDirective","desiredMarker","currentMarker","tRange","isStylingValuePresent","getTStylingRangeNextDuplicate","findStylingValue","getTStylingRangePrevDuplicate","isProcedural","classList","removeProperty","isImportant","applyStyling","isPrevDirection","rawKey","containsStatics","isStylingMap","valueAtLViewIndex","keyValueArrayGet","textNative","ɵɵtextInterpolate1","ɵɵtextInterpolate","interpolated","textBindingInternal","v1","getBindingIndex","interpolation2","ɵɵtextInterpolate2","i1","v2","bindingUpdated3","interpolation3","ɵɵtextInterpolate3","ɵɵhostProperty","ɵɵsyntheticHostProperty","localeEn","LOCALE_DATA","LocaleDataIndex","LocaleId","ExtraData","normalizedLocale","normalizeLocale","getLocaleData","parentLocale","PluralCase","ng","common","locales","DayPeriodsFormat","DayPeriodsStandalone","DaysFormat","DaysStandalone","MonthsFormat","MonthsStandalone","FirstDayOfWeek","WeekendRange","DateFormat","TimeFormat","DateTimeFormat","NumberSymbols","NumberFormats","CurrencyCode","CurrencySymbol","CurrencyName","Currencies","Directionality","pluralMapping","DEFAULT_LOCALE_ID","ELEMENT_MARKER","ICU_MARKER","I18nCreateOpCode","SHIFT","APPEND_EAGERLY","COMMENT","LOCALE_ID$1","tNodeInsertBeforeIndex","i18nParent","anchorRNode","previousTNodes","newTNode","existingTNode","isI18nText","isNewTNodeCreatedBefore","getInsertBeforeIndex","setInsertBeforeIndex","setI18nHandling","addTNodeAndUpdateInsertBeforeIndex","tIcu","currentCase","currentCaseLViewIndex","mergedCode","changeMask","changeMaskCounter","mutableOpCodes","rootRNode","rootIdx","textNodeIndex","parentIdx","getParentFromIcuCreateOpCode","insertInFrontOf","refIdx","getRefFromIcuCreateOpCode","getTIcu","caseIndex","getCurrentICUCaseIndex","applyMutableOpCodes","anchorIdx","commentValue","commentNodeIndex","createCommentNode","elementNodeIndex","updateOpCodes","bindingsStartIndex","checkBit","skipCodes","sanitizeFn","tNodeOrTagName","rText","applyIcuSwitchCase","applyIcuUpdateCase","activeCaseIndex","applyUpdateOpCodes","update","icuExpression","bindingValue","cases","resolvedCase","plural","getLocalePluralCase","getPluralCase","getCaseIndex","applyIcuSwitchCaseRemove","removeCodes","nodeOrIcuIndex","_stack","_removes","_index","removeOpCode","enterIcu","icuContainerIteratorNext","icuContainerIteratorStart","BINDING_REGEXP","NESTED_ICU","ICU_BLOCK_REGEXP","SUBTEMPLATE_REGEXP","PH_REGEXP","NGSP_UNICODE_REGEXP","rootTNode","existingTNodes","createOpCodes","isICU","i18nNodeIdx","loader","ensureIcuContainerVisitorLoaded","loadIcuContainerVisitor","throwError","assertEqual","setTNodeInsertBeforeIndex","hasBinding","createTNodeAndAddOpCode","generateBindingUpdateOpCodes","destinationNode","bindingStart","maskIndex","sizeIndex","textParts","textValue","toMaskBit","tagMatched","inTemplate","bindingMask","mainBinding","addUpdateIcuSwitch","setTIcu","valueArr","nestedIcus","icuIndex","parseIcuCase","addUpdateIcuUpdate","icuType","i18nParseTextIntoPartsAndICU","binding","blocks","prevPos","braceStack","results","braces","lastIndex","block","parseICUBlock","caseName","unsafeCaseHtml","inertRootNode","walkIcuTree","sharedUpdateOpCodes","depth","addCreateNodeAndAppend","lowerAttrName","Tc","addCreateAttribute","addRemoveNode","COMMENT_NODE","isNestedIcu","icuStart","addRemoveNestedIcu","appendToParentIdx","createAtIdx","icuCreateOpCode","messageIndex","subTemplateIndex","parentTNodeIndex","existingTNodeStack","isRootTemplateMessage","removeInnerTemplateTranslation","RegExp","getTranslationForTemplate","msgParts","replaceNgsp","i18nStartFirstCreatePassProcessTextNode","icuContainerTNode","icuNodeIndex","isClosing","createTNodePlaceholder","i18nStartFirstCreatePass","tI18n","isComment","appendNow","applyCreateOpCodes","setInI18nBlock","ɵɵi18nStart","ɵɵi18nEnd","setMaskBit","hasChange","ɵɵi18nExp","applyI18n","HEADER_OFFSET","lInjectablesBlueprint","resolveProvider","providerFactory","beginIndex","ɵɵdirectiveInject","existingFactoryIndex","registerDestroyHooksIfSupported","existingProvidersFactoryIndex","existingViewProvidersFactoryIndex","doesProvidersFactoryExist","doesViewProvidersFactoryExist","factoryFn","componentProviders","multiFactoryAdd","multiFactory","multiViewProvidersFactoryResolver","multiProvidersFactoryResolver","contextIndex","indexInFactory","providerIsTypeProvider","providerIsClassProvider","isClassProvider","existingCallbacksIndex","isComponentProvider","lData","multiResolve","factories","componentCount","multiProviders","viewProviders","processProvidersFn","resolveComponentFactory","ERROR_COMPONENT","noComponentFactoryError","ComponentFactoryResolver$1","_NullComponentFactoryResolver","createElementRef","ElementRef","injectElementRef","Renderer2","nodeAtIndex","getOrCreateRenderer2","injectRenderer2","Sanitizer","full","major","minor","patch","VERSION","Version","NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR","lNode","lViewInAContainer","lViewFirstChildTNode","collectNativeNodes","nodesInSlot","_cdRefInjectingView","_appRef","_attachedToViewContainer","rootNodes","viewRefs","destroyLView","callback","storeCleanupWithContext","detach","reattach","detectChanges","detectChangesInternal","checkNoChanges","attachToViewContainerRef","detachFromAppRef","renderDetachView","attachToAppRef","appRef","ViewRef$1","detectChangesInRootView","componentDef","ComponentFactory","nonMinified","templateName","ComponentFactory$1","componentType","selectorList","stringifyCSSSelector","stringifyCSSSelectorList","isBoundToModule","toRefArray","projectableNodes","rootSelectorOrNode","rootViewInjector","createChainedInjector","RendererFactory2","hostRenderer","elementName","hostRNode","elementOrSelector","selectRootElement","rElement","locateHostElement","getNamespace","rootFlags","playerHandler","clean","createRootContext","rootTView","rootLView","tElementNode","viewRenderer","createRootComponentView","extractAttrsAndClassesFromSelector","nodesforSlot","hostFeatures","instantiateRootComponent","createRootComponent","LifecycleHooksFeature","ComponentRef","_rootLView","changeDetectorRef","RootViewRef","modules","NgModuleRef$1","_parent","_bootstrapComponents","destroyCbs","componentFactoryResolver","ComponentFactoryResolver","maybeUnwrapFn","_r3Injector","injectFlags","NgModuleFactory$1","moduleType","visited","incoming","assertSameOrNotExisting","recurse","registerNgModuleType","parentInjector","NgModuleRef","slotOffset","pureFn","getBindingRoot","updateBinding","getBinding","exp","pureFunction1Internal","pureFunction2Internal","bindingRoot","getPureFunctionReturnValue","pureFunction3Internal","exp4","bindingUpdated4","pureFunction4Internal","returnValueIndex","lastReturnValue","pipeName","getPipeDef","pipeFactory","pipeInstance","isPure","isAsync","__isAsync","nextFn","errorFn","completeFn","_wrapInTimeout","_results","_emitDistinctChangesOnly","dirty","_changesDetected","_changes","proto","QueryList","symbolIterator","filter","some","toArray","resultsTree","identityAccessor","newResultFlat","valueA","valueB","arrayEquals","notifyOnChanges","setDirty","TemplateRef","injectTemplateRef","ViewEngineTemplateRef","R3TemplateRef","_declarationLView","_declarationTContainer","elementRef","declarationViewLQueries","createTemplateRef","ViewContainerRef","injectViewContainerRef","createContainerRef","VE_ViewContainerRef","R3ViewContainerRef","_lContainer","_hostTNode","_hostLView","getViewRefs","CONTAINER_HEADER_OFFSET","insert","createComponent","componentFactoryOrType","indexOrOptions","ngModuleRef","isComponentFactory","isType","componentFactory","contextInjector","componentRef","viewAttachedToContainer","prevIdx","prevLContainer","prevVCRef","adjustedIdx","_adjustIndex","containerLength","addToArray","declaredComponentLView","insertedLContainer","trackMovedView","insertView","parentNativeNode","addViewToContainer","getOrCreateViewRefs","viewRefsArr","detachedView","wasDetached","VIEW_REFS","commentNode","nativeNextSibling","queryList","LQuery_","tQueries","noOfInheritedQueries","viewLQueries","tQuery","getByIndex","indexInDeclarationView","LQueries_","dirtyQueriesWithMatches","getTQuery","predicate","queriesForTemplateRef","childQueryIndex","tqueryClone","TQueries_","track","tquery","metadata","crossesNgTemplate","_appliesToNextNode","_declarationNodeIndex","isApplyingToNode","matchTNode","addMatch","TQuery_","declarationNodeIdx","matchTNodeWithReadOption","getIdxOfMatchingSelector","nodeMatchIdx","directiveOrProviderIdx","matchIdx","matchingIdx","createResultByTNodeType","createSpecialToken","queryIndex","lQuery","tQueryMatches","matchedNodeIdx","createResultForNode","lViewResults","materializeViewResults","collectQueryResults","embeddedLViews","getCurrentQueryIndex","unwrapElementRef","createTQuery","TQueryMetadata_","createLQuery","tViewContentQueries","saveContentQueryAndDirectiveIndex","loadQueryInternal","APP_INITIALIZER","ApplicationInitStatus","appInits","initialized","donePromise","rej","runInitializers","asyncInitPromises","initResult","observableAsPromise","all","APP_ID","_randomChar","fromCharCode","random","PLATFORM_INITIALIZER","PLATFORM_ID","APP_BOOTSTRAP_LISTENER","PACKAGE_ROOT_URL","Console","log","$localize","getGlobalLocale","MissingTranslationStrategy","Warning","Ignore","ngModuleFactory","componentFactories","Compiler","compileModuleSync","NgModuleFactory","compileModuleAsync","compileModuleAndAllComponentsSync","declaration","ModuleWithComponentFactories","compileModuleAndAllComponentsAsync","clearCache","clearCacheFor","getModuleId","COMPILER_OPTIONS","Zone","scheduleMicroTask","enableLongStackTrace","shouldCoalesceEventChangeDetection","shouldCoalesceRunChangeDetection","hasPendingMacrotasks","hasPendingMicrotasks","isStable","onUnstable","onMicrotaskEmpty","onStable","assertZonePatched","_nesting","_outer","_inner","TaskTrackingZoneSpec","fork","longStackTraceZoneSpec","lastRequestAnimationFrameId","nativeRequestAnimationFrame","nativeCancelAnimationFrame","cancelAnimationFrame","unpatchedRequestAnimationFrame","__symbol__","unpatchedCancelAnimationFrame","getNativeRequestAnimationFrame","delayChangeDetectionForEventsDelegate","isCheckStableRunning","fakeTopEventTask","root","scheduleEventTask","updateMicroTaskStatus","checkStable","invoke","delayChangeDetectionForEvents","properties","isAngularZone","onInvokeTask","task","applyThis","applyArgs","onEnter","invokeTask","onLeave","onInvoke","onHasTask","hasTaskState","hasTask","change","_hasPendingMicrotasks","microTask","macroTask","onHandleError","runOutsideAngular","forkInnerZoneWithAngularBehavior","NgZone","isInAngularZone","run","runTask","EMPTY_PAYLOAD","cancelTask","runGuarded","Testability","_ngZone","_pendingCount","_isZoneStable","_didWork","_callbacks","taskTrackingZone","_watchAngularEvents","assertNotInAngularZone","_runCallbacksIfReady","increasePendingRequestCount","decreasePendingRequestCount","timeoutId","doneCb","pending","getPendingTasks","updateCb","macroTasks","creationLocation","addCallback","whenStable","getPendingRequestCount","findProviders","using","exactMatch","TestabilityRegistry","_applications","_testabilityGetter","addToWindow","registerApplication","testability","unregisterApplication","delete","unregisterAllApplications","getTestability","elem","getAllTestabilities","getAllRootElements","findTestabilityInTree","findInAncestors","getter","_NoopGetTestability","_platformInjector","ALLOW_MULTIPLE_PLATFORMS","PLATFORM_ON_DESTROY","parentPlatformFactory","desc","extraProviders","platform","getPlatform","platformProviders","PlatformRef","inits","initFn","createPlatform","createPlatformInjector","requiredToken","assertPlatform","_injector","_modules","_destroyListeners","bootstrapModuleFactory","moduleFactory","ngZone","ngZoneOption","extra","NoopNgZone","ngZoneEventCoalescing","ngZoneRunCoalescing","getNgZone","ngZoneInjector","moduleRef","exceptionHandler","_callAndReportToErrorHandler","initStatus","assertDefined","setLocaleId","_moduleDoBootstrap","bootstrapModule","compilerOptions","optionsReducer","compileNgModuleFactory","ApplicationRef","ngDoBootstrap","module","destroyListener","objs","_zone","_exceptionHandler","_initStatus","_bootstrapListeners","_views","_runningTick","_stable","componentTypes","_onMicrotaskEmptySubscription","tick","isCurrentlyStable","stableSub","unstableSub","assertInAngularZone","merge$1","share","componentOrFactory","resolver","cf","compRef","testabilityRegistry","_loadComponent","attachView","listeners","viewCount","_devMode","_runModeLocked","ChangeDetectorRef","injectChangeDetectorRef","isPipe","createViewRef","supports","isListLikeIterable","trackByFn","DefaultIterableDiffer","trackByIdentity","_linkedRecords","_unlinkedRecords","_previousItHead","_itHead","_itTail","_additionsHead","_additionsTail","_movesHead","_movesTail","_removalsHead","_removalsTail","_identityChangesHead","_identityChangesTail","forEachItem","nextIt","nextRemove","addRemoveOffset","moveOffsets","getPreviousIndex","adjPreviousIndex","_nextRemoved","localMovePreviousIndex","localCurrentIndex","forEachPreviousItem","_nextPrevious","_nextAdded","forEachMovedItem","_nextMoved","_nextIdentityChange","collection","check","_reset","itemTrackBy","mayBeDirty","trackById","_verifyReinsertion","_addIdentityChange","_mismatch","iterateListLike","_truncate","isDirty","previousRecord","_prev","_remove","_reinsertAfter","_moveAfter","_addAfter","IterableChangeRecord_","reinsertRecord","_addToMoves","nextRecord","_addToRemovals","_unlink","prevRecord","_prevRemoved","_insertAfter","_DuplicateMap","put","toIndex","_prevDup","_nextDup","_head","_tail","atOrAfterIndex","duplicates","_DuplicateItemRecordList","recordList","isEmpty","moveOffset","DefaultKeyValueDiffer","_records","_mapHead","_appendAfter","_previousMapHead","_changesHead","_changesTail","_nextChanged","_forEach","_maybeAddToChanges","_getOrCreateRecordForKey","_insertBeforeOrAppend","KeyValueChangeRecord_","_addToAdditions","_addToChanges","IterableDiffers","DefaultIterableDifferFactory","copied","defaultIterableDiffersFactory","KeyValueDiffers","DefaultKeyValueDifferFactory","defaultKeyValueDiffersFactory","kv","platformCore","createPlatformFactory","ApplicationModule","ɵɵdefineNgModule","ɵɵdefineInjector","decl","cooked","raw","messagePart","splitBlock","placeholderName","associatedMessageId","endOfBlock","cookedIndex","rawIndex","findEndOfBlock","parsedMessage","describeMessage","meaningString","legacy","legacyIds","translations","translate","TRANSLATIONS","messageString","messageParts","placeholderNames","rawMessageParts","makeTemplateObject","parseTranslation","substitutions","expressions","messagePartLocations","expressionLocations","substitutionLocations","associatedMessageIds","meaningDescAndId","meaningAndDesc","customId","description","parseMetadata","cleanedMessageParts","computePlaceholderName","parsePlaceholder","messageId","computeMsgId","parseMessage","translation","MissingTranslationError","placeholder","translate$1","ɵDomAdapter","supportsDOMEvents","GenericBrowserDomAdapter","ɵsetRootDomAdapter","BrowserDomAdapter","onAndCancel","evt","dispatchEvent","doc","getDefaultDocument","createHtmlDocument","isElementNode","isShadowRoot","DocumentFragment","baseElement","getAttribute","getBaseElementHref","urlParsingNode","pathName","relativePath","resetBaseElement","getUserAgent","navigator","userAgent","getCookie","ɵparseCookieValue","TRANSITION_ID","SERVER_TRANSITION_PROVIDERS","transitionId","dom","ɵgetDOM","querySelectorAll","setTestabilityGetter","BrowserGetTestability","ɵglobal","testabilities","didWork","decrement","didWork_","whenAllStable","parentElement","BrowserXhr","build","XMLHttpRequest","EVENT_MANAGER_PLUGINS","EventManager","plugins","_eventNameToPlugin","manager","_plugins","plugin","_findPluginFor","addGlobalEventListener","getZone","SharedStylesHost","_stylesSet","addStyles","additions","onStylesAdded","getAllStyles","DomSharedStylesHost","_hostNodes","head","_addStylesToHost","styleNodes","styleEl","addHost","hostNode","removeHost","styleNode","NAMESPACE_URIS","svg","xhtml","xlink","xml","xmlns","math","COMPONENT_REGEX","COMPONENT_VARIABLE","HOST_ATTR","CONTENT_ATTR","compId","flattenStyles","eventHandler","event","allowDefaultBehavior","DomRendererFactory2","eventManager","sharedStylesHost","appId","rendererByCompId","defaultRenderer","DefaultDomRenderer2","EmulatedEncapsulationDomRenderer2","applyToHost","ShadowDomRenderer","newChild","refChild","oldChild","selectorOrNode","preserveContent","removeAttributeNS","decoratePreventDefault","contentAttr","componentShortId","shimContentAttribute","hostAttr","shimHostAttribute","hostEl","nodeOrShadowRoot","DomEventsPlugin","EventManagerPlugin","MODIFIER_KEYS","_keyMap","Del","Esc","Left","Right","Up","Down","Menu","Scroll","Win","_chromeNumKeyPadMap","A","B","C","D","F","G","I","J","K","M","N","O","MODIFIER_KEY_GETTERS","alt","altKey","control","ctrlKey","metaKey","shiftKey","KeyEventsPlugin","parseEventName","parsedEvent","outsideHandler","eventCallback","fullKey","domEventName","_normalizeKey","modifierName","keyIdentifier","getEventKey","Z","modifierGetter","getEventFullKey","keyName","INTERNAL_BROWSER_PLATFORM_PROVIDERS","ɵPLATFORM_BROWSER_ID","makeCurrent","ɵsetDocument","platformBrowser","BROWSER_MODULE_PROVIDERS","ɵINJECTOR_SCOPE","XhrFactory","BrowserModule","parentModule","DomSanitizer","DomSanitizerImpl","L","ɵallowSanitizationBypassAndThrow","ɵunwrapSafeValue","ɵ_sanitizeHtml","ɵgetSanitizationBypassType","ɵ_sanitizeUrl","bypassSecurityTrustHtml","ɵbypassSanitizationTrustHtml","bypassSecurityTrustStyle","ɵbypassSanitizationTrustStyle","bypassSecurityTrustScript","ɵbypassSanitizationTrustScript","bypassSecurityTrustUrl","ɵbypassSanitizationTrustUrl","bypassSecurityTrustResourceUrl","ɵbypassSanitizationTrustResourceUrl","domSanitizerImplFactory","W","ae","ce","De"],"sourceRoot":"webpack:///","sources":["./node_modules/rxjs/dist/esm/internal/Observable.js","./node_modules/rxjs/dist/esm/internal/util/ObjectUnsubscribedError.js","./node_modules/rxjs/dist/esm/internal/Subject.js","./node_modules/rxjs/dist/esm/internal/NotificationFactories.js","./node_modules/rxjs/dist/esm/internal/Subscriber.js","./node_modules/rxjs/dist/esm/internal/util/UnsubscriptionError.js","./node_modules/rxjs/dist/esm/internal/Subscription.js","./node_modules/rxjs/dist/esm/internal/config.js","./node_modules/rxjs/dist/esm/internal/observable/empty.js","./node_modules/rxjs/dist/esm/internal/operators/subscribeOn.js","./node_modules/rxjs/dist/esm/internal/scheduled/scheduleAsyncIterable.js","./node_modules/rxjs/dist/esm/internal/observable/from.js","./node_modules/rxjs/dist/esm/internal/scheduled/scheduled.js","./node_modules/rxjs/dist/esm/internal/scheduled/scheduleObservable.js","./node_modules/rxjs/dist/esm/internal/scheduled/scheduleArray.js","./node_modules/rxjs/dist/esm/internal/scheduled/schedulePromise.js","./node_modules/rxjs/dist/esm/internal/scheduled/scheduleIterable.js","./node_modules/rxjs/dist/esm/internal/scheduled/scheduleReadableStreamLike.js","./node_modules/rxjs/dist/esm/internal/observable/innerFrom.js","./node_modules/rxjs/dist/esm/internal/observable/merge.js","./node_modules/rxjs/dist/esm/internal/operators/OperatorSubscriber.js","./node_modules/rxjs/dist/esm/internal/operators/map.js","./node_modules/rxjs/dist/esm/internal/operators/mergeAll.js","./node_modules/rxjs/dist/esm/internal/operators/mergeMap.js","./node_modules/rxjs/dist/esm/internal/operators/mergeInternals.js","./node_modules/rxjs/dist/esm/internal/operators/observeOn.js","./node_modules/rxjs/dist/esm/internal/operators/share.js","./node_modules/rxjs/dist/esm/internal/scheduler/timeoutProvider.js","./node_modules/rxjs/dist/esm/internal/symbol/iterator.js","./node_modules/rxjs/dist/esm/internal/symbol/observable.js","./node_modules/rxjs/dist/esm/internal/util/args.js","./node_modules/rxjs/dist/esm/internal/util/arrRemove.js","./node_modules/rxjs/dist/esm/internal/util/createErrorClass.js","./node_modules/rxjs/dist/esm/internal/util/errorContext.js","./node_modules/rxjs/dist/esm/internal/util/executeSchedule.js","./node_modules/rxjs/dist/esm/internal/util/identity.js","./node_modules/rxjs/dist/esm/internal/util/isArrayLike.js","./node_modules/rxjs/dist/esm/internal/util/isAsyncIterable.js","./node_modules/rxjs/dist/esm/internal/util/isFunction.js","./node_modules/rxjs/dist/esm/internal/util/isInteropObservable.js","./node_modules/rxjs/dist/esm/internal/util/isIterable.js","./node_modules/rxjs/dist/esm/internal/util/isPromise.js","./node_modules/rxjs/dist/esm/internal/util/isReadableStreamLike.js","./node_modules/rxjs/dist/esm/internal/util/isScheduler.js","./node_modules/rxjs/dist/esm/internal/util/lift.js","./node_modules/rxjs/dist/esm/internal/util/noop.js","./node_modules/rxjs/dist/esm/internal/util/pipe.js","./node_modules/rxjs/dist/esm/internal/util/reportUnhandledError.js","./node_modules/rxjs/dist/esm/internal/util/throwUnobservableError.js","./node_modules/tslib/tslib.es6.js","./node_modules/@angular/common/fesm2020/common.mjs","./node_modules/@angular/compiler/fesm2020/compiler.mjs","./node_modules/@angular/core/fesm2020/core.mjs","./node_modules/@angular/localize/fesm2020/localize.mjs","./node_modules/@angular/platform-browser/fesm2020/platform-browser.mjs","./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js"],"sourcesContent":["import { SafeSubscriber, Subscriber } from './Subscriber';\nimport { isSubscription } from './Subscription';\nimport { observable as Symbol_observable } from './symbol/observable';\nimport { pipeFromArray } from './util/pipe';\nimport { config } from './config';\nimport { isFunction } from './util/isFunction';\nimport { errorContext } from './util/errorContext';\nexport class Observable {\n constructor(subscribe) {\n if (subscribe) {\n this._subscribe = subscribe;\n }\n }\n lift(operator) {\n const observable = new Observable();\n observable.source = this;\n observable.operator = operator;\n return observable;\n }\n subscribe(observerOrNext, error, complete) {\n const subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);\n errorContext(() => {\n const { operator, source } = this;\n subscriber.add(operator\n ?\n operator.call(subscriber, source)\n : source\n ?\n this._subscribe(subscriber)\n :\n this._trySubscribe(subscriber));\n });\n return subscriber;\n }\n _trySubscribe(sink) {\n try {\n return this._subscribe(sink);\n }\n catch (err) {\n sink.error(err);\n }\n }\n forEach(next, promiseCtor) {\n promiseCtor = getPromiseCtor(promiseCtor);\n return new promiseCtor((resolve, reject) => {\n const subscriber = new SafeSubscriber({\n next: (value) => {\n try {\n next(value);\n }\n catch (err) {\n reject(err);\n subscriber.unsubscribe();\n }\n },\n error: reject,\n complete: resolve,\n });\n this.subscribe(subscriber);\n });\n }\n _subscribe(subscriber) {\n var _a;\n return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);\n }\n [Symbol_observable]() {\n return this;\n }\n pipe(...operations) {\n return pipeFromArray(operations)(this);\n }\n toPromise(promiseCtor) {\n promiseCtor = getPromiseCtor(promiseCtor);\n return new promiseCtor((resolve, reject) => {\n let value;\n this.subscribe((x) => (value = x), (err) => reject(err), () => resolve(value));\n });\n }\n}\nObservable.create = (subscribe) => {\n return new Observable(subscribe);\n};\nfunction getPromiseCtor(promiseCtor) {\n var _a;\n return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;\n}\nfunction isObserver(value) {\n return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);\n}\nfunction isSubscriber(value) {\n return (value && value instanceof Subscriber) || (isObserver(value) && isSubscription(value));\n}\n","import { createErrorClass } from './createErrorClass';\nexport const ObjectUnsubscribedError = createErrorClass((_super) => function ObjectUnsubscribedErrorImpl() {\n _super(this);\n this.name = 'ObjectUnsubscribedError';\n this.message = 'object unsubscribed';\n});\n","import { Observable } from './Observable';\nimport { Subscription, EMPTY_SUBSCRIPTION } from './Subscription';\nimport { ObjectUnsubscribedError } from './util/ObjectUnsubscribedError';\nimport { arrRemove } from './util/arrRemove';\nimport { errorContext } from './util/errorContext';\nexport class Subject extends Observable {\n constructor() {\n super();\n this.closed = false;\n this.currentObservers = null;\n this.observers = [];\n this.isStopped = false;\n this.hasError = false;\n this.thrownError = null;\n }\n lift(operator) {\n const subject = new AnonymousSubject(this, this);\n subject.operator = operator;\n return subject;\n }\n _throwIfClosed() {\n if (this.closed) {\n throw new ObjectUnsubscribedError();\n }\n }\n next(value) {\n errorContext(() => {\n this._throwIfClosed();\n if (!this.isStopped) {\n if (!this.currentObservers) {\n this.currentObservers = Array.from(this.observers);\n }\n for (const observer of this.currentObservers) {\n observer.next(value);\n }\n }\n });\n }\n error(err) {\n errorContext(() => {\n this._throwIfClosed();\n if (!this.isStopped) {\n this.hasError = this.isStopped = true;\n this.thrownError = err;\n const { observers } = this;\n while (observers.length) {\n observers.shift().error(err);\n }\n }\n });\n }\n complete() {\n errorContext(() => {\n this._throwIfClosed();\n if (!this.isStopped) {\n this.isStopped = true;\n const { observers } = this;\n while (observers.length) {\n observers.shift().complete();\n }\n }\n });\n }\n unsubscribe() {\n this.isStopped = this.closed = true;\n this.observers = this.currentObservers = null;\n }\n get observed() {\n var _a;\n return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;\n }\n _trySubscribe(subscriber) {\n this._throwIfClosed();\n return super._trySubscribe(subscriber);\n }\n _subscribe(subscriber) {\n this._throwIfClosed();\n this._checkFinalizedStatuses(subscriber);\n return this._innerSubscribe(subscriber);\n }\n _innerSubscribe(subscriber) {\n const { hasError, isStopped, observers } = this;\n if (hasError || isStopped) {\n return EMPTY_SUBSCRIPTION;\n }\n this.currentObservers = null;\n observers.push(subscriber);\n return new Subscription(() => {\n this.currentObservers = null;\n arrRemove(observers, subscriber);\n });\n }\n _checkFinalizedStatuses(subscriber) {\n const { hasError, thrownError, isStopped } = this;\n if (hasError) {\n subscriber.error(thrownError);\n }\n else if (isStopped) {\n subscriber.complete();\n }\n }\n asObservable() {\n const observable = new Observable();\n observable.source = this;\n return observable;\n }\n}\nSubject.create = (destination, source) => {\n return new AnonymousSubject(destination, source);\n};\nexport class AnonymousSubject extends Subject {\n constructor(destination, source) {\n super();\n this.destination = destination;\n this.source = source;\n }\n next(value) {\n var _a, _b;\n (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);\n }\n error(err) {\n var _a, _b;\n (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);\n }\n complete() {\n var _a, _b;\n (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);\n }\n _subscribe(subscriber) {\n var _a, _b;\n return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;\n }\n}\n","export const COMPLETE_NOTIFICATION = (() => createNotification('C', undefined, undefined))();\nexport function errorNotification(error) {\n return createNotification('E', undefined, error);\n}\nexport function nextNotification(value) {\n return createNotification('N', value, undefined);\n}\nexport function createNotification(kind, value, error) {\n return {\n kind,\n value,\n error,\n };\n}\n","import { isFunction } from './util/isFunction';\nimport { isSubscription, Subscription } from './Subscription';\nimport { config } from './config';\nimport { reportUnhandledError } from './util/reportUnhandledError';\nimport { noop } from './util/noop';\nimport { nextNotification, errorNotification, COMPLETE_NOTIFICATION } from './NotificationFactories';\nimport { timeoutProvider } from './scheduler/timeoutProvider';\nimport { captureError } from './util/errorContext';\nexport class Subscriber extends Subscription {\n constructor(destination) {\n super();\n this.isStopped = false;\n if (destination) {\n this.destination = destination;\n if (isSubscription(destination)) {\n destination.add(this);\n }\n }\n else {\n this.destination = EMPTY_OBSERVER;\n }\n }\n static create(next, error, complete) {\n return new SafeSubscriber(next, error, complete);\n }\n next(value) {\n if (this.isStopped) {\n handleStoppedNotification(nextNotification(value), this);\n }\n else {\n this._next(value);\n }\n }\n error(err) {\n if (this.isStopped) {\n handleStoppedNotification(errorNotification(err), this);\n }\n else {\n this.isStopped = true;\n this._error(err);\n }\n }\n complete() {\n if (this.isStopped) {\n handleStoppedNotification(COMPLETE_NOTIFICATION, this);\n }\n else {\n this.isStopped = true;\n this._complete();\n }\n }\n unsubscribe() {\n if (!this.closed) {\n this.isStopped = true;\n super.unsubscribe();\n this.destination = null;\n }\n }\n _next(value) {\n this.destination.next(value);\n }\n _error(err) {\n try {\n this.destination.error(err);\n }\n finally {\n this.unsubscribe();\n }\n }\n _complete() {\n try {\n this.destination.complete();\n }\n finally {\n this.unsubscribe();\n }\n }\n}\nconst _bind = Function.prototype.bind;\nfunction bind(fn, thisArg) {\n return _bind.call(fn, thisArg);\n}\nclass ConsumerObserver {\n constructor(partialObserver) {\n this.partialObserver = partialObserver;\n }\n next(value) {\n const { partialObserver } = this;\n if (partialObserver.next) {\n try {\n partialObserver.next(value);\n }\n catch (error) {\n handleUnhandledError(error);\n }\n }\n }\n error(err) {\n const { partialObserver } = this;\n if (partialObserver.error) {\n try {\n partialObserver.error(err);\n }\n catch (error) {\n handleUnhandledError(error);\n }\n }\n else {\n handleUnhandledError(err);\n }\n }\n complete() {\n const { partialObserver } = this;\n if (partialObserver.complete) {\n try {\n partialObserver.complete();\n }\n catch (error) {\n handleUnhandledError(error);\n }\n }\n }\n}\nexport class SafeSubscriber extends Subscriber {\n constructor(observerOrNext, error, complete) {\n super();\n let partialObserver;\n if (isFunction(observerOrNext) || !observerOrNext) {\n partialObserver = {\n next: (observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : undefined),\n error: error !== null && error !== void 0 ? error : undefined,\n complete: complete !== null && complete !== void 0 ? complete : undefined,\n };\n }\n else {\n let context;\n if (this && config.useDeprecatedNextContext) {\n context = Object.create(observerOrNext);\n context.unsubscribe = () => this.unsubscribe();\n partialObserver = {\n next: observerOrNext.next && bind(observerOrNext.next, context),\n error: observerOrNext.error && bind(observerOrNext.error, context),\n complete: observerOrNext.complete && bind(observerOrNext.complete, context),\n };\n }\n else {\n partialObserver = observerOrNext;\n }\n }\n this.destination = new ConsumerObserver(partialObserver);\n }\n}\nfunction handleUnhandledError(error) {\n if (config.useDeprecatedSynchronousErrorHandling) {\n captureError(error);\n }\n else {\n reportUnhandledError(error);\n }\n}\nfunction defaultErrorHandler(err) {\n throw err;\n}\nfunction handleStoppedNotification(notification, subscriber) {\n const { onStoppedNotification } = config;\n onStoppedNotification && timeoutProvider.setTimeout(() => onStoppedNotification(notification, subscriber));\n}\nexport const EMPTY_OBSERVER = {\n closed: true,\n next: noop,\n error: defaultErrorHandler,\n complete: noop,\n};\n","import { createErrorClass } from './createErrorClass';\nexport const UnsubscriptionError = createErrorClass((_super) => function UnsubscriptionErrorImpl(errors) {\n _super(this);\n this.message = errors\n ? `${errors.length} errors occurred during unsubscription:\n${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\\n ')}`\n : '';\n this.name = 'UnsubscriptionError';\n this.errors = errors;\n});\n","import { isFunction } from './util/isFunction';\nimport { UnsubscriptionError } from './util/UnsubscriptionError';\nimport { arrRemove } from './util/arrRemove';\nexport class Subscription {\n constructor(initialTeardown) {\n this.initialTeardown = initialTeardown;\n this.closed = false;\n this._parentage = null;\n this._finalizers = null;\n }\n unsubscribe() {\n let errors;\n if (!this.closed) {\n this.closed = true;\n const { _parentage } = this;\n if (_parentage) {\n this._parentage = null;\n if (Array.isArray(_parentage)) {\n for (const parent of _parentage) {\n parent.remove(this);\n }\n }\n else {\n _parentage.remove(this);\n }\n }\n const { initialTeardown: initialFinalizer } = this;\n if (isFunction(initialFinalizer)) {\n try {\n initialFinalizer();\n }\n catch (e) {\n errors = e instanceof UnsubscriptionError ? e.errors : [e];\n }\n }\n const { _finalizers } = this;\n if (_finalizers) {\n this._finalizers = null;\n for (const finalizer of _finalizers) {\n try {\n execFinalizer(finalizer);\n }\n catch (err) {\n errors = errors !== null && errors !== void 0 ? errors : [];\n if (err instanceof UnsubscriptionError) {\n errors = [...errors, ...err.errors];\n }\n else {\n errors.push(err);\n }\n }\n }\n }\n if (errors) {\n throw new UnsubscriptionError(errors);\n }\n }\n }\n add(teardown) {\n var _a;\n if (teardown && teardown !== this) {\n if (this.closed) {\n execFinalizer(teardown);\n }\n else {\n if (teardown instanceof Subscription) {\n if (teardown.closed || teardown._hasParent(this)) {\n return;\n }\n teardown._addParent(this);\n }\n (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);\n }\n }\n }\n _hasParent(parent) {\n const { _parentage } = this;\n return _parentage === parent || (Array.isArray(_parentage) && _parentage.includes(parent));\n }\n _addParent(parent) {\n const { _parentage } = this;\n this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;\n }\n _removeParent(parent) {\n const { _parentage } = this;\n if (_parentage === parent) {\n this._parentage = null;\n }\n else if (Array.isArray(_parentage)) {\n arrRemove(_parentage, parent);\n }\n }\n remove(teardown) {\n const { _finalizers } = this;\n _finalizers && arrRemove(_finalizers, teardown);\n if (teardown instanceof Subscription) {\n teardown._removeParent(this);\n }\n }\n}\nSubscription.EMPTY = (() => {\n const empty = new Subscription();\n empty.closed = true;\n return empty;\n})();\nexport const EMPTY_SUBSCRIPTION = Subscription.EMPTY;\nexport function isSubscription(value) {\n return (value instanceof Subscription ||\n (value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe)));\n}\nfunction execFinalizer(finalizer) {\n if (isFunction(finalizer)) {\n finalizer();\n }\n else {\n finalizer.unsubscribe();\n }\n}\n","export const config = {\n onUnhandledError: null,\n onStoppedNotification: null,\n Promise: undefined,\n useDeprecatedSynchronousErrorHandling: false,\n useDeprecatedNextContext: false,\n};\n","import { Observable } from '../Observable';\nexport const EMPTY = new Observable((subscriber) => subscriber.complete());\nexport function empty(scheduler) {\n return scheduler ? emptyScheduled(scheduler) : EMPTY;\n}\nfunction emptyScheduled(scheduler) {\n return new Observable((subscriber) => scheduler.schedule(() => subscriber.complete()));\n}\n","import { operate } from '../util/lift';\nexport function subscribeOn(scheduler, delay = 0) {\n return operate((source, subscriber) => {\n subscriber.add(scheduler.schedule(() => source.subscribe(subscriber), delay));\n });\n}\n","import { Observable } from '../Observable';\nimport { executeSchedule } from '../util/executeSchedule';\nexport function scheduleAsyncIterable(input, scheduler) {\n if (!input) {\n throw new Error('Iterable cannot be null');\n }\n return new Observable((subscriber) => {\n executeSchedule(subscriber, scheduler, () => {\n const iterator = input[Symbol.asyncIterator]();\n executeSchedule(subscriber, scheduler, () => {\n iterator.next().then((result) => {\n if (result.done) {\n subscriber.complete();\n }\n else {\n subscriber.next(result.value);\n }\n });\n }, 0, true);\n });\n });\n}\n","import { scheduled } from '../scheduled/scheduled';\nimport { innerFrom } from './innerFrom';\nexport function from(input, scheduler) {\n return scheduler ? scheduled(input, scheduler) : innerFrom(input);\n}\n","import { scheduleObservable } from './scheduleObservable';\nimport { schedulePromise } from './schedulePromise';\nimport { scheduleArray } from './scheduleArray';\nimport { scheduleIterable } from './scheduleIterable';\nimport { scheduleAsyncIterable } from './scheduleAsyncIterable';\nimport { isInteropObservable } from '../util/isInteropObservable';\nimport { isPromise } from '../util/isPromise';\nimport { isArrayLike } from '../util/isArrayLike';\nimport { isIterable } from '../util/isIterable';\nimport { isAsyncIterable } from '../util/isAsyncIterable';\nimport { createInvalidObservableTypeError } from '../util/throwUnobservableError';\nimport { isReadableStreamLike } from '../util/isReadableStreamLike';\nimport { scheduleReadableStreamLike } from './scheduleReadableStreamLike';\nexport function scheduled(input, scheduler) {\n if (input != null) {\n if (isInteropObservable(input)) {\n return scheduleObservable(input, scheduler);\n }\n if (isArrayLike(input)) {\n return scheduleArray(input, scheduler);\n }\n if (isPromise(input)) {\n return schedulePromise(input, scheduler);\n }\n if (isAsyncIterable(input)) {\n return scheduleAsyncIterable(input, scheduler);\n }\n if (isIterable(input)) {\n return scheduleIterable(input, scheduler);\n }\n if (isReadableStreamLike(input)) {\n return scheduleReadableStreamLike(input, scheduler);\n }\n }\n throw createInvalidObservableTypeError(input);\n}\n","import { innerFrom } from '../observable/innerFrom';\nimport { observeOn } from '../operators/observeOn';\nimport { subscribeOn } from '../operators/subscribeOn';\nexport function scheduleObservable(input, scheduler) {\n return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));\n}\n","import { Observable } from '../Observable';\nexport function scheduleArray(input, scheduler) {\n return new Observable((subscriber) => {\n let i = 0;\n return scheduler.schedule(function () {\n if (i === input.length) {\n subscriber.complete();\n }\n else {\n subscriber.next(input[i++]);\n if (!subscriber.closed) {\n this.schedule();\n }\n }\n });\n });\n}\n","import { innerFrom } from '../observable/innerFrom';\nimport { observeOn } from '../operators/observeOn';\nimport { subscribeOn } from '../operators/subscribeOn';\nexport function schedulePromise(input, scheduler) {\n return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));\n}\n","import { Observable } from '../Observable';\nimport { iterator as Symbol_iterator } from '../symbol/iterator';\nimport { isFunction } from '../util/isFunction';\nimport { executeSchedule } from '../util/executeSchedule';\nexport function scheduleIterable(input, scheduler) {\n return new Observable((subscriber) => {\n let iterator;\n executeSchedule(subscriber, scheduler, () => {\n iterator = input[Symbol_iterator]();\n executeSchedule(subscriber, scheduler, () => {\n let value;\n let done;\n try {\n ({ value, done } = iterator.next());\n }\n catch (err) {\n subscriber.error(err);\n return;\n }\n if (done) {\n subscriber.complete();\n }\n else {\n subscriber.next(value);\n }\n }, 0, true);\n });\n return () => isFunction(iterator === null || iterator === void 0 ? void 0 : iterator.return) && iterator.return();\n });\n}\n","import { scheduleAsyncIterable } from './scheduleAsyncIterable';\nimport { readableStreamLikeToAsyncGenerator } from '../util/isReadableStreamLike';\nexport function scheduleReadableStreamLike(input, scheduler) {\n return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler);\n}\n","import { __asyncValues, __awaiter } from \"tslib\";\nimport { isArrayLike } from '../util/isArrayLike';\nimport { isPromise } from '../util/isPromise';\nimport { Observable } from '../Observable';\nimport { isInteropObservable } from '../util/isInteropObservable';\nimport { isAsyncIterable } from '../util/isAsyncIterable';\nimport { createInvalidObservableTypeError } from '../util/throwUnobservableError';\nimport { isIterable } from '../util/isIterable';\nimport { isReadableStreamLike, readableStreamLikeToAsyncGenerator } from '../util/isReadableStreamLike';\nimport { isFunction } from '../util/isFunction';\nimport { reportUnhandledError } from '../util/reportUnhandledError';\nimport { observable as Symbol_observable } from '../symbol/observable';\nexport function innerFrom(input) {\n if (input instanceof Observable) {\n return input;\n }\n if (input != null) {\n if (isInteropObservable(input)) {\n return fromInteropObservable(input);\n }\n if (isArrayLike(input)) {\n return fromArrayLike(input);\n }\n if (isPromise(input)) {\n return fromPromise(input);\n }\n if (isAsyncIterable(input)) {\n return fromAsyncIterable(input);\n }\n if (isIterable(input)) {\n return fromIterable(input);\n }\n if (isReadableStreamLike(input)) {\n return fromReadableStreamLike(input);\n }\n }\n throw createInvalidObservableTypeError(input);\n}\nexport function fromInteropObservable(obj) {\n return new Observable((subscriber) => {\n const obs = obj[Symbol_observable]();\n if (isFunction(obs.subscribe)) {\n return obs.subscribe(subscriber);\n }\n throw new TypeError('Provided object does not correctly implement Symbol.observable');\n });\n}\nexport function fromArrayLike(array) {\n return new Observable((subscriber) => {\n for (let i = 0; i < array.length && !subscriber.closed; i++) {\n subscriber.next(array[i]);\n }\n subscriber.complete();\n });\n}\nexport function fromPromise(promise) {\n return new Observable((subscriber) => {\n promise\n .then((value) => {\n if (!subscriber.closed) {\n subscriber.next(value);\n subscriber.complete();\n }\n }, (err) => subscriber.error(err))\n .then(null, reportUnhandledError);\n });\n}\nexport function fromIterable(iterable) {\n return new Observable((subscriber) => {\n for (const value of iterable) {\n subscriber.next(value);\n if (subscriber.closed) {\n return;\n }\n }\n subscriber.complete();\n });\n}\nexport function fromAsyncIterable(asyncIterable) {\n return new Observable((subscriber) => {\n process(asyncIterable, subscriber).catch((err) => subscriber.error(err));\n });\n}\nexport function fromReadableStreamLike(readableStream) {\n return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));\n}\nfunction process(asyncIterable, subscriber) {\n var asyncIterable_1, asyncIterable_1_1;\n var e_1, _a;\n return __awaiter(this, void 0, void 0, function* () {\n try {\n for (asyncIterable_1 = __asyncValues(asyncIterable); asyncIterable_1_1 = yield asyncIterable_1.next(), !asyncIterable_1_1.done;) {\n const value = asyncIterable_1_1.value;\n subscriber.next(value);\n if (subscriber.closed) {\n return;\n }\n }\n }\n catch (e_1_1) { e_1 = { error: e_1_1 }; }\n finally {\n try {\n if (asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return)) yield _a.call(asyncIterable_1);\n }\n finally { if (e_1) throw e_1.error; }\n }\n subscriber.complete();\n });\n}\n","import { mergeAll } from '../operators/mergeAll';\nimport { innerFrom } from './innerFrom';\nimport { EMPTY } from './empty';\nimport { popNumber, popScheduler } from '../util/args';\nimport { from } from './from';\nexport function merge(...args) {\n const scheduler = popScheduler(args);\n const concurrent = popNumber(args, Infinity);\n const sources = args;\n return !sources.length\n ?\n EMPTY\n : sources.length === 1\n ?\n innerFrom(sources[0])\n :\n mergeAll(concurrent)(from(sources, scheduler));\n}\n","import { Subscriber } from '../Subscriber';\nexport function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {\n return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);\n}\nexport class OperatorSubscriber extends Subscriber {\n constructor(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {\n super(destination);\n this.onFinalize = onFinalize;\n this.shouldUnsubscribe = shouldUnsubscribe;\n this._next = onNext\n ? function (value) {\n try {\n onNext(value);\n }\n catch (err) {\n destination.error(err);\n }\n }\n : super._next;\n this._error = onError\n ? function (err) {\n try {\n onError(err);\n }\n catch (err) {\n destination.error(err);\n }\n finally {\n this.unsubscribe();\n }\n }\n : super._error;\n this._complete = onComplete\n ? function () {\n try {\n onComplete();\n }\n catch (err) {\n destination.error(err);\n }\n finally {\n this.unsubscribe();\n }\n }\n : super._complete;\n }\n unsubscribe() {\n var _a;\n if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {\n const { closed } = this;\n super.unsubscribe();\n !closed && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));\n }\n }\n}\n","import { operate } from '../util/lift';\nimport { createOperatorSubscriber } from './OperatorSubscriber';\nexport function map(project, thisArg) {\n return operate((source, subscriber) => {\n let index = 0;\n source.subscribe(createOperatorSubscriber(subscriber, (value) => {\n subscriber.next(project.call(thisArg, value, index++));\n }));\n });\n}\n","import { mergeMap } from './mergeMap';\nimport { identity } from '../util/identity';\nexport function mergeAll(concurrent = Infinity) {\n return mergeMap(identity, concurrent);\n}\n","import { map } from './map';\nimport { innerFrom } from '../observable/innerFrom';\nimport { operate } from '../util/lift';\nimport { mergeInternals } from './mergeInternals';\nimport { isFunction } from '../util/isFunction';\nexport function mergeMap(project, resultSelector, concurrent = Infinity) {\n if (isFunction(resultSelector)) {\n return mergeMap((a, i) => map((b, ii) => resultSelector(a, b, i, ii))(innerFrom(project(a, i))), concurrent);\n }\n else if (typeof resultSelector === 'number') {\n concurrent = resultSelector;\n }\n return operate((source, subscriber) => mergeInternals(source, subscriber, project, concurrent));\n}\n","import { innerFrom } from '../observable/innerFrom';\nimport { executeSchedule } from '../util/executeSchedule';\nimport { createOperatorSubscriber } from './OperatorSubscriber';\nexport function mergeInternals(source, subscriber, project, concurrent, onBeforeNext, expand, innerSubScheduler, additionalFinalizer) {\n const buffer = [];\n let active = 0;\n let index = 0;\n let isComplete = false;\n const checkComplete = () => {\n if (isComplete && !buffer.length && !active) {\n subscriber.complete();\n }\n };\n const outerNext = (value) => (active < concurrent ? doInnerSub(value) : buffer.push(value));\n const doInnerSub = (value) => {\n expand && subscriber.next(value);\n active++;\n let innerComplete = false;\n innerFrom(project(value, index++)).subscribe(createOperatorSubscriber(subscriber, (innerValue) => {\n onBeforeNext === null || onBeforeNext === void 0 ? void 0 : onBeforeNext(innerValue);\n if (expand) {\n outerNext(innerValue);\n }\n else {\n subscriber.next(innerValue);\n }\n }, () => {\n innerComplete = true;\n }, undefined, () => {\n if (innerComplete) {\n try {\n active--;\n while (buffer.length && active < concurrent) {\n const bufferedValue = buffer.shift();\n if (innerSubScheduler) {\n executeSchedule(subscriber, innerSubScheduler, () => doInnerSub(bufferedValue));\n }\n else {\n doInnerSub(bufferedValue);\n }\n }\n checkComplete();\n }\n catch (err) {\n subscriber.error(err);\n }\n }\n }));\n };\n source.subscribe(createOperatorSubscriber(subscriber, outerNext, () => {\n isComplete = true;\n checkComplete();\n }));\n return () => {\n additionalFinalizer === null || additionalFinalizer === void 0 ? void 0 : additionalFinalizer();\n };\n}\n","import { executeSchedule } from '../util/executeSchedule';\nimport { operate } from '../util/lift';\nimport { createOperatorSubscriber } from './OperatorSubscriber';\nexport function observeOn(scheduler, delay = 0) {\n return operate((source, subscriber) => {\n source.subscribe(createOperatorSubscriber(subscriber, (value) => executeSchedule(subscriber, scheduler, () => subscriber.next(value), delay), () => executeSchedule(subscriber, scheduler, () => subscriber.complete(), delay), (err) => executeSchedule(subscriber, scheduler, () => subscriber.error(err), delay)));\n });\n}\n","import { innerFrom } from '../observable/innerFrom';\nimport { Subject } from '../Subject';\nimport { SafeSubscriber } from '../Subscriber';\nimport { operate } from '../util/lift';\nexport function share(options = {}) {\n const { connector = () => new Subject(), resetOnError = true, resetOnComplete = true, resetOnRefCountZero = true } = options;\n return (wrapperSource) => {\n let connection;\n let resetConnection;\n let subject;\n let refCount = 0;\n let hasCompleted = false;\n let hasErrored = false;\n const cancelReset = () => {\n resetConnection === null || resetConnection === void 0 ? void 0 : resetConnection.unsubscribe();\n resetConnection = undefined;\n };\n const reset = () => {\n cancelReset();\n connection = subject = undefined;\n hasCompleted = hasErrored = false;\n };\n const resetAndUnsubscribe = () => {\n const conn = connection;\n reset();\n conn === null || conn === void 0 ? void 0 : conn.unsubscribe();\n };\n return operate((source, subscriber) => {\n refCount++;\n if (!hasErrored && !hasCompleted) {\n cancelReset();\n }\n const dest = (subject = subject !== null && subject !== void 0 ? subject : connector());\n subscriber.add(() => {\n refCount--;\n if (refCount === 0 && !hasErrored && !hasCompleted) {\n resetConnection = handleReset(resetAndUnsubscribe, resetOnRefCountZero);\n }\n });\n dest.subscribe(subscriber);\n if (!connection &&\n refCount > 0) {\n connection = new SafeSubscriber({\n next: (value) => dest.next(value),\n error: (err) => {\n hasErrored = true;\n cancelReset();\n resetConnection = handleReset(reset, resetOnError, err);\n dest.error(err);\n },\n complete: () => {\n hasCompleted = true;\n cancelReset();\n resetConnection = handleReset(reset, resetOnComplete);\n dest.complete();\n },\n });\n innerFrom(source).subscribe(connection);\n }\n })(wrapperSource);\n };\n}\nfunction handleReset(reset, on, ...args) {\n if (on === true) {\n reset();\n return;\n }\n if (on === false) {\n return;\n }\n const onSubscriber = new SafeSubscriber({\n next: () => {\n onSubscriber.unsubscribe();\n reset();\n },\n });\n return on(...args).subscribe(onSubscriber);\n}\n","export const timeoutProvider = {\n setTimeout(handler, timeout, ...args) {\n const { delegate } = timeoutProvider;\n if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {\n return delegate.setTimeout(handler, timeout, ...args);\n }\n return setTimeout(handler, timeout, ...args);\n },\n clearTimeout(handle) {\n const { delegate } = timeoutProvider;\n return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);\n },\n delegate: undefined,\n};\n","export function getSymbolIterator() {\n if (typeof Symbol !== 'function' || !Symbol.iterator) {\n return '@@iterator';\n }\n return Symbol.iterator;\n}\nexport const iterator = getSymbolIterator();\n","export const observable = (() => (typeof Symbol === 'function' && Symbol.observable) || '@@observable')();\n","import { isFunction } from './isFunction';\nimport { isScheduler } from './isScheduler';\nfunction last(arr) {\n return arr[arr.length - 1];\n}\nexport function popResultSelector(args) {\n return isFunction(last(args)) ? args.pop() : undefined;\n}\nexport function popScheduler(args) {\n return isScheduler(last(args)) ? args.pop() : undefined;\n}\nexport function popNumber(args, defaultValue) {\n return typeof last(args) === 'number' ? args.pop() : defaultValue;\n}\n","export function arrRemove(arr, item) {\n if (arr) {\n const index = arr.indexOf(item);\n 0 <= index && arr.splice(index, 1);\n }\n}\n","export function createErrorClass(createImpl) {\n const _super = (instance) => {\n Error.call(instance);\n instance.stack = new Error().stack;\n };\n const ctorFunc = createImpl(_super);\n ctorFunc.prototype = Object.create(Error.prototype);\n ctorFunc.prototype.constructor = ctorFunc;\n return ctorFunc;\n}\n","import { config } from '../config';\nlet context = null;\nexport function errorContext(cb) {\n if (config.useDeprecatedSynchronousErrorHandling) {\n const isRoot = !context;\n if (isRoot) {\n context = { errorThrown: false, error: null };\n }\n cb();\n if (isRoot) {\n const { errorThrown, error } = context;\n context = null;\n if (errorThrown) {\n throw error;\n }\n }\n }\n else {\n cb();\n }\n}\nexport function captureError(err) {\n if (config.useDeprecatedSynchronousErrorHandling && context) {\n context.errorThrown = true;\n context.error = err;\n }\n}\n","export function executeSchedule(parentSubscription, scheduler, work, delay = 0, repeat = false) {\n const scheduleSubscription = scheduler.schedule(function () {\n work();\n if (repeat) {\n parentSubscription.add(this.schedule(null, delay));\n }\n else {\n this.unsubscribe();\n }\n }, delay);\n parentSubscription.add(scheduleSubscription);\n if (!repeat) {\n return scheduleSubscription;\n }\n}\n","export function identity(x) {\n return x;\n}\n","export const isArrayLike = ((x) => x && typeof x.length === 'number' && typeof x !== 'function');\n","import { isFunction } from './isFunction';\nexport function isAsyncIterable(obj) {\n return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);\n}\n","export function isFunction(value) {\n return typeof value === 'function';\n}\n","import { observable as Symbol_observable } from '../symbol/observable';\nimport { isFunction } from './isFunction';\nexport function isInteropObservable(input) {\n return isFunction(input[Symbol_observable]);\n}\n","import { iterator as Symbol_iterator } from '../symbol/iterator';\nimport { isFunction } from './isFunction';\nexport function isIterable(input) {\n return isFunction(input === null || input === void 0 ? void 0 : input[Symbol_iterator]);\n}\n","import { isFunction } from \"./isFunction\";\nexport function isPromise(value) {\n return isFunction(value === null || value === void 0 ? void 0 : value.then);\n}\n","import { __asyncGenerator, __await } from \"tslib\";\nimport { isFunction } from './isFunction';\nexport function readableStreamLikeToAsyncGenerator(readableStream) {\n return __asyncGenerator(this, arguments, function* readableStreamLikeToAsyncGenerator_1() {\n const reader = readableStream.getReader();\n try {\n while (true) {\n const { value, done } = yield __await(reader.read());\n if (done) {\n return yield __await(void 0);\n }\n yield yield __await(value);\n }\n }\n finally {\n reader.releaseLock();\n }\n });\n}\nexport function isReadableStreamLike(obj) {\n return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);\n}\n","import { isFunction } from './isFunction';\nexport function isScheduler(value) {\n return value && isFunction(value.schedule);\n}\n","import { isFunction } from './isFunction';\nexport function hasLift(source) {\n return isFunction(source === null || source === void 0 ? void 0 : source.lift);\n}\nexport function operate(init) {\n return (source) => {\n if (hasLift(source)) {\n return source.lift(function (liftedSource) {\n try {\n return init(liftedSource, this);\n }\n catch (err) {\n this.error(err);\n }\n });\n }\n throw new TypeError('Unable to lift unknown Observable type');\n };\n}\n","export function noop() { }\n","import { identity } from './identity';\nexport function pipe(...fns) {\n return pipeFromArray(fns);\n}\nexport function pipeFromArray(fns) {\n if (fns.length === 0) {\n return identity;\n }\n if (fns.length === 1) {\n return fns[0];\n }\n return function piped(input) {\n return fns.reduce((prev, fn) => fn(prev), input);\n };\n}\n","import { config } from '../config';\nimport { timeoutProvider } from '../scheduler/timeoutProvider';\nexport function reportUnhandledError(err) {\n timeoutProvider.setTimeout(() => {\n const { onUnhandledError } = config;\n if (onUnhandledError) {\n onUnhandledError(err);\n }\n else {\n throw err;\n }\n });\n}\n","export function createInvalidObservableTypeError(input) {\n return new TypeError(`You provided ${input !== null && typeof input === 'object' ? 'an invalid object' : `'${input}'`} where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.`);\n}\n","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n extendStatics = Object.setPrototypeOf ||\r\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n if (typeof b !== \"function\" && b !== null)\r\n throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n extendStatics(d, b);\r\n function __() { this.constructor = d; }\r\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n __assign = Object.assign || function __assign(t) {\r\n for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n s = arguments[i];\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n }\r\n return t;\r\n }\r\n return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n var t = {};\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n t[p] = s[p];\r\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n t[p[i]] = s[p[i]];\r\n }\r\n return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n var _, done = false;\r\n for (var i = decorators.length - 1; i >= 0; i--) {\r\n var context = {};\r\n for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n if (kind === \"accessor\") {\r\n if (result === void 0) continue;\r\n if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n if (_ = accept(result.get)) descriptor.get = _;\r\n if (_ = accept(result.set)) descriptor.set = _;\r\n if (_ = accept(result.init)) initializers.push(_);\r\n }\r\n else if (_ = accept(result)) {\r\n if (kind === \"field\") initializers.push(_);\r\n else descriptor[key] = _;\r\n }\r\n }\r\n if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n var useValue = arguments.length > 2;\r\n for (var i = 0; i < initializers.length; i++) {\r\n value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n }\r\n return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n return new (P || (P = Promise))(function (resolve, reject) {\r\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n function verb(n) { return function (v) { return step([n, v]); }; }\r\n function step(op) {\r\n if (f) throw new TypeError(\"Generator is already executing.\");\r\n while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n if (y = 0, t) op = [op[0] & 2, t.value];\r\n switch (op[0]) {\r\n case 0: case 1: t = op; break;\r\n case 4: _.label++; return { value: op[1], done: false };\r\n case 5: _.label++; y = op[1]; op = [0]; continue;\r\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n default:\r\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n if (t[2]) _.ops.pop();\r\n _.trys.pop(); continue;\r\n }\r\n op = body.call(thisArg, _);\r\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n var desc = Object.getOwnPropertyDescriptor(m, k);\r\n if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n desc = { enumerable: true, get: function() { return m[k]; } };\r\n }\r\n Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n if (m) return m.call(o);\r\n if (o && typeof o.length === \"number\") return {\r\n next: function () {\r\n if (o && i >= o.length) o = void 0;\r\n return { value: o && o[i++], done: !o };\r\n }\r\n };\r\n throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n if (!m) return o;\r\n var i = m.call(o), r, ar = [], e;\r\n try {\r\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n }\r\n catch (error) { e = { error: error }; }\r\n finally {\r\n try {\r\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n }\r\n finally { if (e) throw e.error; }\r\n }\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n for (var ar = [], i = 0; i < arguments.length; i++)\r\n ar = ar.concat(__read(arguments[i]));\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n r[k] = a[j];\r\n return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n if (ar || !(i in from)) {\r\n if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n ar[i] = from[i];\r\n }\r\n }\r\n return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n function fulfill(value) { resume(\"next\", value); }\r\n function reject(value) { resume(\"throw\", value); }\r\n function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n var i, p;\r\n return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var m = o[Symbol.asyncIterator], i;\r\n return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n if (mod && mod.__esModule) return mod;\r\n var result = {};\r\n if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n __setModuleDefault(result, mod);\r\n return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n","/**\n * @license Angular v13.3.12\n * (c) 2010-2022 Google LLC. https://angular.io/\n * License: MIT\n */\n\nimport * as i0 from '@angular/core';\nimport { InjectionToken, Injectable, ɵɵinject, Inject, Optional, EventEmitter, ɵfindLocaleData, ɵLocaleDataIndex, ɵgetLocaleCurrencyCode, ɵgetLocalePluralCase, LOCALE_ID, ɵregisterLocaleData, ɵisListLikeIterable, ɵstringify, Directive, Input, NgModuleRef, ComponentFactoryResolver, Host, ɵRuntimeError, Attribute, ɵisPromise, ɵisSubscribable, Pipe, DEFAULT_CURRENCY_CODE, NgModule, Version, ɵɵdefineInjectable } from '@angular/core';\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nlet _DOM = null;\nfunction getDOM() {\n return _DOM;\n}\nfunction setDOM(adapter) {\n _DOM = adapter;\n}\nfunction setRootDomAdapter(adapter) {\n if (!_DOM) {\n _DOM = adapter;\n }\n}\n/* tslint:disable:requireParameterType */\n/**\n * Provides DOM operations in an environment-agnostic way.\n *\n * @security Tread carefully! Interacting with the DOM directly is dangerous and\n * can introduce XSS risks.\n */\nclass DomAdapter {\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A DI Token representing the main rendering context. In a browser this is the DOM Document.\n *\n * Note: Document might not be available in the Application Context when Application and Rendering\n * Contexts are not the same (e.g. when running the application in a Web Worker).\n *\n * @publicApi\n */\nconst DOCUMENT = new InjectionToken('DocumentToken');\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * This class should not be used directly by an application developer. Instead, use\n * {@link Location}.\n *\n * `PlatformLocation` encapsulates all calls to DOM APIs, which allows the Router to be\n * platform-agnostic.\n * This means that we can have different implementation of `PlatformLocation` for the different\n * platforms that Angular supports. For example, `@angular/platform-browser` provides an\n * implementation specific to the browser environment, while `@angular/platform-server` provides\n * one suitable for use with server-side rendering.\n *\n * The `PlatformLocation` class is used directly by all implementations of {@link LocationStrategy}\n * when they need to interact with the DOM APIs like pushState, popState, etc.\n *\n * {@link LocationStrategy} in turn is used by the {@link Location} service which is used directly\n * by the {@link Router} in order to navigate between routes. Since all interactions between {@link\n * Router} /\n * {@link Location} / {@link LocationStrategy} and DOM APIs flow through the `PlatformLocation`\n * class, they are all platform-agnostic.\n *\n * @publicApi\n */\nclass PlatformLocation {\n historyGo(relativePosition) {\n throw new Error('Not implemented');\n }\n}\nPlatformLocation.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: PlatformLocation, deps: [], target: i0.ɵɵFactoryTarget.Injectable });\nPlatformLocation.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: PlatformLocation, providedIn: 'platform', useFactory: useBrowserPlatformLocation });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: PlatformLocation, decorators: [{\n type: Injectable,\n args: [{\n providedIn: 'platform',\n // See #23917\n useFactory: useBrowserPlatformLocation\n }]\n }] });\nfunction useBrowserPlatformLocation() {\n return ɵɵinject(BrowserPlatformLocation);\n}\n/**\n * @description\n * Indicates when a location is initialized.\n *\n * @publicApi\n */\nconst LOCATION_INITIALIZED = new InjectionToken('Location Initialized');\n/**\n * `PlatformLocation` encapsulates all of the direct calls to platform APIs.\n * This class should not be used directly by an application developer. Instead, use\n * {@link Location}.\n */\nclass BrowserPlatformLocation extends PlatformLocation {\n constructor(_doc) {\n super();\n this._doc = _doc;\n this._init();\n }\n // This is moved to its own method so that `MockPlatformLocationStrategy` can overwrite it\n /** @internal */\n _init() {\n this.location = window.location;\n this._history = window.history;\n }\n getBaseHrefFromDOM() {\n return getDOM().getBaseHref(this._doc);\n }\n onPopState(fn) {\n const window = getDOM().getGlobalEventTarget(this._doc, 'window');\n window.addEventListener('popstate', fn, false);\n return () => window.removeEventListener('popstate', fn);\n }\n onHashChange(fn) {\n const window = getDOM().getGlobalEventTarget(this._doc, 'window');\n window.addEventListener('hashchange', fn, false);\n return () => window.removeEventListener('hashchange', fn);\n }\n get href() {\n return this.location.href;\n }\n get protocol() {\n return this.location.protocol;\n }\n get hostname() {\n return this.location.hostname;\n }\n get port() {\n return this.location.port;\n }\n get pathname() {\n return this.location.pathname;\n }\n get search() {\n return this.location.search;\n }\n get hash() {\n return this.location.hash;\n }\n set pathname(newPath) {\n this.location.pathname = newPath;\n }\n pushState(state, title, url) {\n if (supportsState()) {\n this._history.pushState(state, title, url);\n }\n else {\n this.location.hash = url;\n }\n }\n replaceState(state, title, url) {\n if (supportsState()) {\n this._history.replaceState(state, title, url);\n }\n else {\n this.location.hash = url;\n }\n }\n forward() {\n this._history.forward();\n }\n back() {\n this._history.back();\n }\n historyGo(relativePosition = 0) {\n this._history.go(relativePosition);\n }\n getState() {\n return this._history.state;\n }\n}\nBrowserPlatformLocation.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: BrowserPlatformLocation, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });\nBrowserPlatformLocation.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: BrowserPlatformLocation, providedIn: 'platform', useFactory: createBrowserPlatformLocation });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: BrowserPlatformLocation, decorators: [{\n type: Injectable,\n args: [{\n providedIn: 'platform',\n // See #23917\n useFactory: createBrowserPlatformLocation,\n }]\n }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n type: Inject,\n args: [DOCUMENT]\n }] }]; } });\nfunction supportsState() {\n return !!window.history.pushState;\n}\nfunction createBrowserPlatformLocation() {\n return new BrowserPlatformLocation(ɵɵinject(DOCUMENT));\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Joins two parts of a URL with a slash if needed.\n *\n * @param start URL string\n * @param end URL string\n *\n *\n * @returns The joined URL string.\n */\nfunction joinWithSlash(start, end) {\n if (start.length == 0) {\n return end;\n }\n if (end.length == 0) {\n return start;\n }\n let slashes = 0;\n if (start.endsWith('/')) {\n slashes++;\n }\n if (end.startsWith('/')) {\n slashes++;\n }\n if (slashes == 2) {\n return start + end.substring(1);\n }\n if (slashes == 1) {\n return start + end;\n }\n return start + '/' + end;\n}\n/**\n * Removes a trailing slash from a URL string if needed.\n * Looks for the first occurrence of either `#`, `?`, or the end of the\n * line as `/` characters and removes the trailing slash if one exists.\n *\n * @param url URL string.\n *\n * @returns The URL string, modified if needed.\n */\nfunction stripTrailingSlash(url) {\n const match = url.match(/#|\\?|$/);\n const pathEndIdx = match && match.index || url.length;\n const droppedSlashIdx = pathEndIdx - (url[pathEndIdx - 1] === '/' ? 1 : 0);\n return url.slice(0, droppedSlashIdx) + url.slice(pathEndIdx);\n}\n/**\n * Normalizes URL parameters by prepending with `?` if needed.\n *\n * @param params String of URL parameters.\n *\n * @returns The normalized URL parameters string.\n */\nfunction normalizeQueryParams(params) {\n return params && params[0] !== '?' ? '?' + params : params;\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Enables the `Location` service to read route state from the browser's URL.\n * Angular provides two strategies:\n * `HashLocationStrategy` and `PathLocationStrategy`.\n *\n * Applications should use the `Router` or `Location` services to\n * interact with application route state.\n *\n * For instance, `HashLocationStrategy` produces URLs like\n * http://example.com#/foo,\n * and `PathLocationStrategy` produces\n * http://example.com/foo as an equivalent URL.\n *\n * See these two classes for more.\n *\n * @publicApi\n */\nclass LocationStrategy {\n historyGo(relativePosition) {\n throw new Error('Not implemented');\n }\n}\nLocationStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: LocationStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable });\nLocationStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: LocationStrategy, providedIn: 'root', useFactory: provideLocationStrategy });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: LocationStrategy, decorators: [{\n type: Injectable,\n args: [{ providedIn: 'root', useFactory: provideLocationStrategy }]\n }] });\nfunction provideLocationStrategy(platformLocation) {\n // See #23917\n const location = ɵɵinject(DOCUMENT).location;\n return new PathLocationStrategy(ɵɵinject(PlatformLocation), location && location.origin || '');\n}\n/**\n * A predefined [DI token](guide/glossary#di-token) for the base href\n * to be used with the `PathLocationStrategy`.\n * The base href is the URL prefix that should be preserved when generating\n * and recognizing URLs.\n *\n * @usageNotes\n *\n * The following example shows how to use this token to configure the root app injector\n * with a base href value, so that the DI framework can supply the dependency anywhere in the app.\n *\n * ```typescript\n * import {Component, NgModule} from '@angular/core';\n * import {APP_BASE_HREF} from '@angular/common';\n *\n * @NgModule({\n * providers: [{provide: APP_BASE_HREF, useValue: '/my/app'}]\n * })\n * class AppModule {}\n * ```\n *\n * @publicApi\n */\nconst APP_BASE_HREF = new InjectionToken('appBaseHref');\n/**\n * @description\n * A {@link LocationStrategy} used to configure the {@link Location} service to\n * represent its state in the\n * [path](https://en.wikipedia.org/wiki/Uniform_Resource_Locator#Syntax) of the\n * browser's URL.\n *\n * If you're using `PathLocationStrategy`, you must provide a {@link APP_BASE_HREF}\n * or add a `` element to the document.\n *\n * For instance, if you provide an `APP_BASE_HREF` of `'/my/app/'` and call\n * `location.go('/foo')`, the browser's URL will become\n * `example.com/my/app/foo`. To ensure all relative URIs resolve correctly,\n * the `` and/or `APP_BASE_HREF` should end with a `/`.\n *\n * Similarly, if you add `` to the document and call\n * `location.go('/foo')`, the browser's URL will become\n * `example.com/my/app/foo`.\n *\n * Note that when using `PathLocationStrategy`, neither the query nor\n * the fragment in the `` will be preserved, as outlined\n * by the [RFC](https://tools.ietf.org/html/rfc3986#section-5.2.2).\n *\n * @usageNotes\n *\n * ### Example\n *\n * {@example common/location/ts/path_location_component.ts region='LocationComponent'}\n *\n * @publicApi\n */\nclass PathLocationStrategy extends LocationStrategy {\n constructor(_platformLocation, href) {\n super();\n this._platformLocation = _platformLocation;\n this._removeListenerFns = [];\n if (href == null) {\n href = this._platformLocation.getBaseHrefFromDOM();\n }\n if (href == null) {\n throw new Error(`No base href set. Please provide a value for the APP_BASE_HREF token or add a base element to the document.`);\n }\n this._baseHref = href;\n }\n /** @nodoc */\n ngOnDestroy() {\n while (this._removeListenerFns.length) {\n this._removeListenerFns.pop()();\n }\n }\n onPopState(fn) {\n this._removeListenerFns.push(this._platformLocation.onPopState(fn), this._platformLocation.onHashChange(fn));\n }\n getBaseHref() {\n return this._baseHref;\n }\n prepareExternalUrl(internal) {\n return joinWithSlash(this._baseHref, internal);\n }\n path(includeHash = false) {\n const pathname = this._platformLocation.pathname + normalizeQueryParams(this._platformLocation.search);\n const hash = this._platformLocation.hash;\n return hash && includeHash ? `${pathname}${hash}` : pathname;\n }\n pushState(state, title, url, queryParams) {\n const externalUrl = this.prepareExternalUrl(url + normalizeQueryParams(queryParams));\n this._platformLocation.pushState(state, title, externalUrl);\n }\n replaceState(state, title, url, queryParams) {\n const externalUrl = this.prepareExternalUrl(url + normalizeQueryParams(queryParams));\n this._platformLocation.replaceState(state, title, externalUrl);\n }\n forward() {\n this._platformLocation.forward();\n }\n back() {\n this._platformLocation.back();\n }\n historyGo(relativePosition = 0) {\n this._platformLocation.historyGo?.(relativePosition);\n }\n}\nPathLocationStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: PathLocationStrategy, deps: [{ token: PlatformLocation }, { token: APP_BASE_HREF, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });\nPathLocationStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: PathLocationStrategy });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: PathLocationStrategy, decorators: [{\n type: Injectable\n }], ctorParameters: function () { return [{ type: PlatformLocation }, { type: undefined, decorators: [{\n type: Optional\n }, {\n type: Inject,\n args: [APP_BASE_HREF]\n }] }]; } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @description\n * A {@link LocationStrategy} used to configure the {@link Location} service to\n * represent its state in the\n * [hash fragment](https://en.wikipedia.org/wiki/Uniform_Resource_Locator#Syntax)\n * of the browser's URL.\n *\n * For instance, if you call `location.go('/foo')`, the browser's URL will become\n * `example.com#/foo`.\n *\n * @usageNotes\n *\n * ### Example\n *\n * {@example common/location/ts/hash_location_component.ts region='LocationComponent'}\n *\n * @publicApi\n */\nclass HashLocationStrategy extends LocationStrategy {\n constructor(_platformLocation, _baseHref) {\n super();\n this._platformLocation = _platformLocation;\n this._baseHref = '';\n this._removeListenerFns = [];\n if (_baseHref != null) {\n this._baseHref = _baseHref;\n }\n }\n /** @nodoc */\n ngOnDestroy() {\n while (this._removeListenerFns.length) {\n this._removeListenerFns.pop()();\n }\n }\n onPopState(fn) {\n this._removeListenerFns.push(this._platformLocation.onPopState(fn), this._platformLocation.onHashChange(fn));\n }\n getBaseHref() {\n return this._baseHref;\n }\n path(includeHash = false) {\n // the hash value is always prefixed with a `#`\n // and if it is empty then it will stay empty\n let path = this._platformLocation.hash;\n if (path == null)\n path = '#';\n return path.length > 0 ? path.substring(1) : path;\n }\n prepareExternalUrl(internal) {\n const url = joinWithSlash(this._baseHref, internal);\n return url.length > 0 ? ('#' + url) : url;\n }\n pushState(state, title, path, queryParams) {\n let url = this.prepareExternalUrl(path + normalizeQueryParams(queryParams));\n if (url.length == 0) {\n url = this._platformLocation.pathname;\n }\n this._platformLocation.pushState(state, title, url);\n }\n replaceState(state, title, path, queryParams) {\n let url = this.prepareExternalUrl(path + normalizeQueryParams(queryParams));\n if (url.length == 0) {\n url = this._platformLocation.pathname;\n }\n this._platformLocation.replaceState(state, title, url);\n }\n forward() {\n this._platformLocation.forward();\n }\n back() {\n this._platformLocation.back();\n }\n historyGo(relativePosition = 0) {\n this._platformLocation.historyGo?.(relativePosition);\n }\n}\nHashLocationStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: HashLocationStrategy, deps: [{ token: PlatformLocation }, { token: APP_BASE_HREF, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });\nHashLocationStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: HashLocationStrategy });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: HashLocationStrategy, decorators: [{\n type: Injectable\n }], ctorParameters: function () { return [{ type: PlatformLocation }, { type: undefined, decorators: [{\n type: Optional\n }, {\n type: Inject,\n args: [APP_BASE_HREF]\n }] }]; } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @description\n *\n * A service that applications can use to interact with a browser's URL.\n *\n * Depending on the `LocationStrategy` used, `Location` persists\n * to the URL's path or the URL's hash segment.\n *\n * @usageNotes\n *\n * It's better to use the `Router.navigate()` service to trigger route changes. Use\n * `Location` only if you need to interact with or create normalized URLs outside of\n * routing.\n *\n * `Location` is responsible for normalizing the URL against the application's base href.\n * A normalized URL is absolute from the URL host, includes the application's base href, and has no\n * trailing slash:\n * - `/my/app/user/123` is normalized\n * - `my/app/user/123` **is not** normalized\n * - `/my/app/user/123/` **is not** normalized\n *\n * ### Example\n *\n * \n *\n * @publicApi\n */\nclass Location {\n constructor(platformStrategy, platformLocation) {\n /** @internal */\n this._subject = new EventEmitter();\n /** @internal */\n this._urlChangeListeners = [];\n this._platformStrategy = platformStrategy;\n const browserBaseHref = this._platformStrategy.getBaseHref();\n this._platformLocation = platformLocation;\n this._baseHref = stripTrailingSlash(_stripIndexHtml(browserBaseHref));\n this._platformStrategy.onPopState((ev) => {\n this._subject.emit({\n 'url': this.path(true),\n 'pop': true,\n 'state': ev.state,\n 'type': ev.type,\n });\n });\n }\n /**\n * Normalizes the URL path for this location.\n *\n * @param includeHash True to include an anchor fragment in the path.\n *\n * @returns The normalized URL path.\n */\n // TODO: vsavkin. Remove the boolean flag and always include hash once the deprecated router is\n // removed.\n path(includeHash = false) {\n return this.normalize(this._platformStrategy.path(includeHash));\n }\n /**\n * Reports the current state of the location history.\n * @returns The current value of the `history.state` object.\n */\n getState() {\n return this._platformLocation.getState();\n }\n /**\n * Normalizes the given path and compares to the current normalized path.\n *\n * @param path The given URL path.\n * @param query Query parameters.\n *\n * @returns True if the given URL path is equal to the current normalized path, false\n * otherwise.\n */\n isCurrentPathEqualTo(path, query = '') {\n return this.path() == this.normalize(path + normalizeQueryParams(query));\n }\n /**\n * Normalizes a URL path by stripping any trailing slashes.\n *\n * @param url String representing a URL.\n *\n * @returns The normalized URL string.\n */\n normalize(url) {\n return Location.stripTrailingSlash(_stripBaseHref(this._baseHref, _stripIndexHtml(url)));\n }\n /**\n * Normalizes an external URL path.\n * If the given URL doesn't begin with a leading slash (`'/'`), adds one\n * before normalizing. Adds a hash if `HashLocationStrategy` is\n * in use, or the `APP_BASE_HREF` if the `PathLocationStrategy` is in use.\n *\n * @param url String representing a URL.\n *\n * @returns A normalized platform-specific URL.\n */\n prepareExternalUrl(url) {\n if (url && url[0] !== '/') {\n url = '/' + url;\n }\n return this._platformStrategy.prepareExternalUrl(url);\n }\n // TODO: rename this method to pushState\n /**\n * Changes the browser's URL to a normalized version of a given URL, and pushes a\n * new item onto the platform's history.\n *\n * @param path URL path to normalize.\n * @param query Query parameters.\n * @param state Location history state.\n *\n */\n go(path, query = '', state = null) {\n this._platformStrategy.pushState(state, '', path, query);\n this._notifyUrlChangeListeners(this.prepareExternalUrl(path + normalizeQueryParams(query)), state);\n }\n /**\n * Changes the browser's URL to a normalized version of the given URL, and replaces\n * the top item on the platform's history stack.\n *\n * @param path URL path to normalize.\n * @param query Query parameters.\n * @param state Location history state.\n */\n replaceState(path, query = '', state = null) {\n this._platformStrategy.replaceState(state, '', path, query);\n this._notifyUrlChangeListeners(this.prepareExternalUrl(path + normalizeQueryParams(query)), state);\n }\n /**\n * Navigates forward in the platform's history.\n */\n forward() {\n this._platformStrategy.forward();\n }\n /**\n * Navigates back in the platform's history.\n */\n back() {\n this._platformStrategy.back();\n }\n /**\n * Navigate to a specific page from session history, identified by its relative position to the\n * current page.\n *\n * @param relativePosition Position of the target page in the history relative to the current\n * page.\n * A negative value moves backwards, a positive value moves forwards, e.g. `location.historyGo(2)`\n * moves forward two pages and `location.historyGo(-2)` moves back two pages. When we try to go\n * beyond what's stored in the history session, we stay in the current page. Same behaviour occurs\n * when `relativePosition` equals 0.\n * @see https://developer.mozilla.org/en-US/docs/Web/API/History_API#Moving_to_a_specific_point_in_history\n */\n historyGo(relativePosition = 0) {\n this._platformStrategy.historyGo?.(relativePosition);\n }\n /**\n * Registers a URL change listener. Use to catch updates performed by the Angular\n * framework that are not detectible through \"popstate\" or \"hashchange\" events.\n *\n * @param fn The change handler function, which take a URL and a location history state.\n */\n onUrlChange(fn) {\n this._urlChangeListeners.push(fn);\n if (!this._urlChangeSubscription) {\n this._urlChangeSubscription = this.subscribe(v => {\n this._notifyUrlChangeListeners(v.url, v.state);\n });\n }\n }\n /** @internal */\n _notifyUrlChangeListeners(url = '', state) {\n this._urlChangeListeners.forEach(fn => fn(url, state));\n }\n /**\n * Subscribes to the platform's `popState` events.\n *\n * Note: `Location.go()` does not trigger the `popState` event in the browser. Use\n * `Location.onUrlChange()` to subscribe to URL changes instead.\n *\n * @param value Event that is triggered when the state history changes.\n * @param exception The exception to throw.\n *\n * @see [onpopstate](https://developer.mozilla.org/en-US/docs/Web/API/WindowEventHandlers/onpopstate)\n *\n * @returns Subscribed events.\n */\n subscribe(onNext, onThrow, onReturn) {\n return this._subject.subscribe({ next: onNext, error: onThrow, complete: onReturn });\n }\n}\n/**\n * Normalizes URL parameters by prepending with `?` if needed.\n *\n * @param params String of URL parameters.\n *\n * @returns The normalized URL parameters string.\n */\nLocation.normalizeQueryParams = normalizeQueryParams;\n/**\n * Joins two parts of a URL with a slash if needed.\n *\n * @param start URL string\n * @param end URL string\n *\n *\n * @returns The joined URL string.\n */\nLocation.joinWithSlash = joinWithSlash;\n/**\n * Removes a trailing slash from a URL string if needed.\n * Looks for the first occurrence of either `#`, `?`, or the end of the\n * line as `/` characters and removes the trailing slash if one exists.\n *\n * @param url URL string.\n *\n * @returns The URL string, modified if needed.\n */\nLocation.stripTrailingSlash = stripTrailingSlash;\nLocation.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: Location, deps: [{ token: LocationStrategy }, { token: PlatformLocation }], target: i0.ɵɵFactoryTarget.Injectable });\nLocation.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: Location, providedIn: 'root', useFactory: createLocation });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: Location, decorators: [{\n type: Injectable,\n args: [{\n providedIn: 'root',\n // See #23917\n useFactory: createLocation,\n }]\n }], ctorParameters: function () { return [{ type: LocationStrategy }, { type: PlatformLocation }]; } });\nfunction createLocation() {\n return new Location(ɵɵinject(LocationStrategy), ɵɵinject(PlatformLocation));\n}\nfunction _stripBaseHref(baseHref, url) {\n return baseHref && url.startsWith(baseHref) ? url.substring(baseHref.length) : url;\n}\nfunction _stripIndexHtml(url) {\n return url.replace(/\\/index.html$/, '');\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** @internal */\nconst CURRENCIES_EN = { \"ADP\": [undefined, undefined, 0], \"AFN\": [undefined, \"؋\", 0], \"ALL\": [undefined, undefined, 0], \"AMD\": [undefined, \"֏\", 2], \"AOA\": [undefined, \"Kz\"], \"ARS\": [undefined, \"$\"], \"AUD\": [\"A$\", \"$\"], \"AZN\": [undefined, \"₼\"], \"BAM\": [undefined, \"KM\"], \"BBD\": [undefined, \"$\"], \"BDT\": [undefined, \"৳\"], \"BHD\": [undefined, undefined, 3], \"BIF\": [undefined, undefined, 0], \"BMD\": [undefined, \"$\"], \"BND\": [undefined, \"$\"], \"BOB\": [undefined, \"Bs\"], \"BRL\": [\"R$\"], \"BSD\": [undefined, \"$\"], \"BWP\": [undefined, \"P\"], \"BYN\": [undefined, \"р.\", 2], \"BYR\": [undefined, undefined, 0], \"BZD\": [undefined, \"$\"], \"CAD\": [\"CA$\", \"$\", 2], \"CHF\": [undefined, undefined, 2], \"CLF\": [undefined, undefined, 4], \"CLP\": [undefined, \"$\", 0], \"CNY\": [\"CN¥\", \"¥\"], \"COP\": [undefined, \"$\", 2], \"CRC\": [undefined, \"₡\", 2], \"CUC\": [undefined, \"$\"], \"CUP\": [undefined, \"$\"], \"CZK\": [undefined, \"Kč\", 2], \"DJF\": [undefined, undefined, 0], \"DKK\": [undefined, \"kr\", 2], \"DOP\": [undefined, \"$\"], \"EGP\": [undefined, \"E£\"], \"ESP\": [undefined, \"₧\", 0], \"EUR\": [\"€\"], \"FJD\": [undefined, \"$\"], \"FKP\": [undefined, \"£\"], \"GBP\": [\"£\"], \"GEL\": [undefined, \"₾\"], \"GHS\": [undefined, \"GH₵\"], \"GIP\": [undefined, \"£\"], \"GNF\": [undefined, \"FG\", 0], \"GTQ\": [undefined, \"Q\"], \"GYD\": [undefined, \"$\", 2], \"HKD\": [\"HK$\", \"$\"], \"HNL\": [undefined, \"L\"], \"HRK\": [undefined, \"kn\"], \"HUF\": [undefined, \"Ft\", 2], \"IDR\": [undefined, \"Rp\", 2], \"ILS\": [\"₪\"], \"INR\": [\"₹\"], \"IQD\": [undefined, undefined, 0], \"IRR\": [undefined, undefined, 0], \"ISK\": [undefined, \"kr\", 0], \"ITL\": [undefined, undefined, 0], \"JMD\": [undefined, \"$\"], \"JOD\": [undefined, undefined, 3], \"JPY\": [\"¥\", undefined, 0], \"KHR\": [undefined, \"៛\"], \"KMF\": [undefined, \"CF\", 0], \"KPW\": [undefined, \"₩\", 0], \"KRW\": [\"₩\", undefined, 0], \"KWD\": [undefined, undefined, 3], \"KYD\": [undefined, \"$\"], \"KZT\": [undefined, \"₸\"], \"LAK\": [undefined, \"₭\", 0], \"LBP\": [undefined, \"L£\", 0], \"LKR\": [undefined, \"Rs\"], \"LRD\": [undefined, \"$\"], \"LTL\": [undefined, \"Lt\"], \"LUF\": [undefined, undefined, 0], \"LVL\": [undefined, \"Ls\"], \"LYD\": [undefined, undefined, 3], \"MGA\": [undefined, \"Ar\", 0], \"MGF\": [undefined, undefined, 0], \"MMK\": [undefined, \"K\", 0], \"MNT\": [undefined, \"₮\", 2], \"MRO\": [undefined, undefined, 0], \"MUR\": [undefined, \"Rs\", 2], \"MXN\": [\"MX$\", \"$\"], \"MYR\": [undefined, \"RM\"], \"NAD\": [undefined, \"$\"], \"NGN\": [undefined, \"₦\"], \"NIO\": [undefined, \"C$\"], \"NOK\": [undefined, \"kr\", 2], \"NPR\": [undefined, \"Rs\"], \"NZD\": [\"NZ$\", \"$\"], \"OMR\": [undefined, undefined, 3], \"PHP\": [\"₱\"], \"PKR\": [undefined, \"Rs\", 2], \"PLN\": [undefined, \"zł\"], \"PYG\": [undefined, \"₲\", 0], \"RON\": [undefined, \"lei\"], \"RSD\": [undefined, undefined, 0], \"RUB\": [undefined, \"₽\"], \"RUR\": [undefined, \"р.\"], \"RWF\": [undefined, \"RF\", 0], \"SBD\": [undefined, \"$\"], \"SEK\": [undefined, \"kr\", 2], \"SGD\": [undefined, \"$\"], \"SHP\": [undefined, \"£\"], \"SLL\": [undefined, undefined, 0], \"SOS\": [undefined, undefined, 0], \"SRD\": [undefined, \"$\"], \"SSP\": [undefined, \"£\"], \"STD\": [undefined, undefined, 0], \"STN\": [undefined, \"Db\"], \"SYP\": [undefined, \"£\", 0], \"THB\": [undefined, \"฿\"], \"TMM\": [undefined, undefined, 0], \"TND\": [undefined, undefined, 3], \"TOP\": [undefined, \"T$\"], \"TRL\": [undefined, undefined, 0], \"TRY\": [undefined, \"₺\"], \"TTD\": [undefined, \"$\"], \"TWD\": [\"NT$\", \"$\", 2], \"TZS\": [undefined, undefined, 2], \"UAH\": [undefined, \"₴\"], \"UGX\": [undefined, undefined, 0], \"USD\": [\"$\"], \"UYI\": [undefined, undefined, 0], \"UYU\": [undefined, \"$\"], \"UYW\": [undefined, undefined, 4], \"UZS\": [undefined, undefined, 2], \"VEF\": [undefined, \"Bs\", 2], \"VND\": [\"₫\", undefined, 0], \"VUV\": [undefined, undefined, 0], \"XAF\": [\"FCFA\", undefined, 0], \"XCD\": [\"EC$\", \"$\"], \"XOF\": [\"F CFA\", undefined, 0], \"XPF\": [\"CFPF\", undefined, 0], \"XXX\": [\"¤\"], \"YER\": [undefined, undefined, 0], \"ZAR\": [undefined, \"R\"], \"ZMK\": [undefined, undefined, 0], \"ZMW\": [undefined, \"ZK\"], \"ZWD\": [undefined, undefined, 0] };\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Format styles that can be used to represent numbers.\n * @see `getLocaleNumberFormat()`.\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nvar NumberFormatStyle;\n(function (NumberFormatStyle) {\n NumberFormatStyle[NumberFormatStyle[\"Decimal\"] = 0] = \"Decimal\";\n NumberFormatStyle[NumberFormatStyle[\"Percent\"] = 1] = \"Percent\";\n NumberFormatStyle[NumberFormatStyle[\"Currency\"] = 2] = \"Currency\";\n NumberFormatStyle[NumberFormatStyle[\"Scientific\"] = 3] = \"Scientific\";\n})(NumberFormatStyle || (NumberFormatStyle = {}));\n/**\n * Plurality cases used for translating plurals to different languages.\n *\n * @see `NgPlural`\n * @see `NgPluralCase`\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nvar Plural;\n(function (Plural) {\n Plural[Plural[\"Zero\"] = 0] = \"Zero\";\n Plural[Plural[\"One\"] = 1] = \"One\";\n Plural[Plural[\"Two\"] = 2] = \"Two\";\n Plural[Plural[\"Few\"] = 3] = \"Few\";\n Plural[Plural[\"Many\"] = 4] = \"Many\";\n Plural[Plural[\"Other\"] = 5] = \"Other\";\n})(Plural || (Plural = {}));\n/**\n * Context-dependant translation forms for strings.\n * Typically the standalone version is for the nominative form of the word,\n * and the format version is used for the genitive case.\n * @see [CLDR website](http://cldr.unicode.org/translation/date-time-1/date-time#TOC-Standalone-vs.-Format-Styles)\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nvar FormStyle;\n(function (FormStyle) {\n FormStyle[FormStyle[\"Format\"] = 0] = \"Format\";\n FormStyle[FormStyle[\"Standalone\"] = 1] = \"Standalone\";\n})(FormStyle || (FormStyle = {}));\n/**\n * String widths available for translations.\n * The specific character widths are locale-specific.\n * Examples are given for the word \"Sunday\" in English.\n *\n * @publicApi\n */\nvar TranslationWidth;\n(function (TranslationWidth) {\n /** 1 character for `en-US`. For example: 'S' */\n TranslationWidth[TranslationWidth[\"Narrow\"] = 0] = \"Narrow\";\n /** 3 characters for `en-US`. For example: 'Sun' */\n TranslationWidth[TranslationWidth[\"Abbreviated\"] = 1] = \"Abbreviated\";\n /** Full length for `en-US`. For example: \"Sunday\" */\n TranslationWidth[TranslationWidth[\"Wide\"] = 2] = \"Wide\";\n /** 2 characters for `en-US`, For example: \"Su\" */\n TranslationWidth[TranslationWidth[\"Short\"] = 3] = \"Short\";\n})(TranslationWidth || (TranslationWidth = {}));\n/**\n * String widths available for date-time formats.\n * The specific character widths are locale-specific.\n * Examples are given for `en-US`.\n *\n * @see `getLocaleDateFormat()`\n * @see `getLocaleTimeFormat()`\n * @see `getLocaleDateTimeFormat()`\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n * @publicApi\n */\nvar FormatWidth;\n(function (FormatWidth) {\n /**\n * For `en-US`, 'M/d/yy, h:mm a'`\n * (Example: `6/15/15, 9:03 AM`)\n */\n FormatWidth[FormatWidth[\"Short\"] = 0] = \"Short\";\n /**\n * For `en-US`, `'MMM d, y, h:mm:ss a'`\n * (Example: `Jun 15, 2015, 9:03:01 AM`)\n */\n FormatWidth[FormatWidth[\"Medium\"] = 1] = \"Medium\";\n /**\n * For `en-US`, `'MMMM d, y, h:mm:ss a z'`\n * (Example: `June 15, 2015 at 9:03:01 AM GMT+1`)\n */\n FormatWidth[FormatWidth[\"Long\"] = 2] = \"Long\";\n /**\n * For `en-US`, `'EEEE, MMMM d, y, h:mm:ss a zzzz'`\n * (Example: `Monday, June 15, 2015 at 9:03:01 AM GMT+01:00`)\n */\n FormatWidth[FormatWidth[\"Full\"] = 3] = \"Full\";\n})(FormatWidth || (FormatWidth = {}));\n/**\n * Symbols that can be used to replace placeholders in number patterns.\n * Examples are based on `en-US` values.\n *\n * @see `getLocaleNumberSymbol()`\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nvar NumberSymbol;\n(function (NumberSymbol) {\n /**\n * Decimal separator.\n * For `en-US`, the dot character.\n * Example: 2,345`.`67\n */\n NumberSymbol[NumberSymbol[\"Decimal\"] = 0] = \"Decimal\";\n /**\n * Grouping separator, typically for thousands.\n * For `en-US`, the comma character.\n * Example: 2`,`345.67\n */\n NumberSymbol[NumberSymbol[\"Group\"] = 1] = \"Group\";\n /**\n * List-item separator.\n * Example: \"one, two, and three\"\n */\n NumberSymbol[NumberSymbol[\"List\"] = 2] = \"List\";\n /**\n * Sign for percentage (out of 100).\n * Example: 23.4%\n */\n NumberSymbol[NumberSymbol[\"PercentSign\"] = 3] = \"PercentSign\";\n /**\n * Sign for positive numbers.\n * Example: +23\n */\n NumberSymbol[NumberSymbol[\"PlusSign\"] = 4] = \"PlusSign\";\n /**\n * Sign for negative numbers.\n * Example: -23\n */\n NumberSymbol[NumberSymbol[\"MinusSign\"] = 5] = \"MinusSign\";\n /**\n * Computer notation for exponential value (n times a power of 10).\n * Example: 1.2E3\n */\n NumberSymbol[NumberSymbol[\"Exponential\"] = 6] = \"Exponential\";\n /**\n * Human-readable format of exponential.\n * Example: 1.2x103\n */\n NumberSymbol[NumberSymbol[\"SuperscriptingExponent\"] = 7] = \"SuperscriptingExponent\";\n /**\n * Sign for permille (out of 1000).\n * Example: 23.4‰\n */\n NumberSymbol[NumberSymbol[\"PerMille\"] = 8] = \"PerMille\";\n /**\n * Infinity, can be used with plus and minus.\n * Example: ∞, +∞, -∞\n */\n NumberSymbol[NumberSymbol[\"Infinity\"] = 9] = \"Infinity\";\n /**\n * Not a number.\n * Example: NaN\n */\n NumberSymbol[NumberSymbol[\"NaN\"] = 10] = \"NaN\";\n /**\n * Symbol used between time units.\n * Example: 10:52\n */\n NumberSymbol[NumberSymbol[\"TimeSeparator\"] = 11] = \"TimeSeparator\";\n /**\n * Decimal separator for currency values (fallback to `Decimal`).\n * Example: $2,345.67\n */\n NumberSymbol[NumberSymbol[\"CurrencyDecimal\"] = 12] = \"CurrencyDecimal\";\n /**\n * Group separator for currency values (fallback to `Group`).\n * Example: $2,345.67\n */\n NumberSymbol[NumberSymbol[\"CurrencyGroup\"] = 13] = \"CurrencyGroup\";\n})(NumberSymbol || (NumberSymbol = {}));\n/**\n * The value for each day of the week, based on the `en-US` locale\n *\n * @publicApi\n */\nvar WeekDay;\n(function (WeekDay) {\n WeekDay[WeekDay[\"Sunday\"] = 0] = \"Sunday\";\n WeekDay[WeekDay[\"Monday\"] = 1] = \"Monday\";\n WeekDay[WeekDay[\"Tuesday\"] = 2] = \"Tuesday\";\n WeekDay[WeekDay[\"Wednesday\"] = 3] = \"Wednesday\";\n WeekDay[WeekDay[\"Thursday\"] = 4] = \"Thursday\";\n WeekDay[WeekDay[\"Friday\"] = 5] = \"Friday\";\n WeekDay[WeekDay[\"Saturday\"] = 6] = \"Saturday\";\n})(WeekDay || (WeekDay = {}));\n/**\n * Retrieves the locale ID from the currently loaded locale.\n * The loaded locale could be, for example, a global one rather than a regional one.\n * @param locale A locale code, such as `fr-FR`.\n * @returns The locale code. For example, `fr`.\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction getLocaleId(locale) {\n return ɵfindLocaleData(locale)[ɵLocaleDataIndex.LocaleId];\n}\n/**\n * Retrieves day period strings for the given locale.\n *\n * @param locale A locale code for the locale format rules to use.\n * @param formStyle The required grammatical form.\n * @param width The required character width.\n * @returns An array of localized period strings. For example, `[AM, PM]` for `en-US`.\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction getLocaleDayPeriods(locale, formStyle, width) {\n const data = ɵfindLocaleData(locale);\n const amPmData = [\n data[ɵLocaleDataIndex.DayPeriodsFormat], data[ɵLocaleDataIndex.DayPeriodsStandalone]\n ];\n const amPm = getLastDefinedValue(amPmData, formStyle);\n return getLastDefinedValue(amPm, width);\n}\n/**\n * Retrieves days of the week for the given locale, using the Gregorian calendar.\n *\n * @param locale A locale code for the locale format rules to use.\n * @param formStyle The required grammatical form.\n * @param width The required character width.\n * @returns An array of localized name strings.\n * For example,`[Sunday, Monday, ... Saturday]` for `en-US`.\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction getLocaleDayNames(locale, formStyle, width) {\n const data = ɵfindLocaleData(locale);\n const daysData = [data[ɵLocaleDataIndex.DaysFormat], data[ɵLocaleDataIndex.DaysStandalone]];\n const days = getLastDefinedValue(daysData, formStyle);\n return getLastDefinedValue(days, width);\n}\n/**\n * Retrieves months of the year for the given locale, using the Gregorian calendar.\n *\n * @param locale A locale code for the locale format rules to use.\n * @param formStyle The required grammatical form.\n * @param width The required character width.\n * @returns An array of localized name strings.\n * For example, `[January, February, ...]` for `en-US`.\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction getLocaleMonthNames(locale, formStyle, width) {\n const data = ɵfindLocaleData(locale);\n const monthsData = [data[ɵLocaleDataIndex.MonthsFormat], data[ɵLocaleDataIndex.MonthsStandalone]];\n const months = getLastDefinedValue(monthsData, formStyle);\n return getLastDefinedValue(months, width);\n}\n/**\n * Retrieves Gregorian-calendar eras for the given locale.\n * @param locale A locale code for the locale format rules to use.\n * @param width The required character width.\n\n * @returns An array of localized era strings.\n * For example, `[AD, BC]` for `en-US`.\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction getLocaleEraNames(locale, width) {\n const data = ɵfindLocaleData(locale);\n const erasData = data[ɵLocaleDataIndex.Eras];\n return getLastDefinedValue(erasData, width);\n}\n/**\n * Retrieves the first day of the week for the given locale.\n *\n * @param locale A locale code for the locale format rules to use.\n * @returns A day index number, using the 0-based week-day index for `en-US`\n * (Sunday = 0, Monday = 1, ...).\n * For example, for `fr-FR`, returns 1 to indicate that the first day is Monday.\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction getLocaleFirstDayOfWeek(locale) {\n const data = ɵfindLocaleData(locale);\n return data[ɵLocaleDataIndex.FirstDayOfWeek];\n}\n/**\n * Range of week days that are considered the week-end for the given locale.\n *\n * @param locale A locale code for the locale format rules to use.\n * @returns The range of day values, `[startDay, endDay]`.\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction getLocaleWeekEndRange(locale) {\n const data = ɵfindLocaleData(locale);\n return data[ɵLocaleDataIndex.WeekendRange];\n}\n/**\n * Retrieves a localized date-value formating string.\n *\n * @param locale A locale code for the locale format rules to use.\n * @param width The format type.\n * @returns The localized formating string.\n * @see `FormatWidth`\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction getLocaleDateFormat(locale, width) {\n const data = ɵfindLocaleData(locale);\n return getLastDefinedValue(data[ɵLocaleDataIndex.DateFormat], width);\n}\n/**\n * Retrieves a localized time-value formatting string.\n *\n * @param locale A locale code for the locale format rules to use.\n * @param width The format type.\n * @returns The localized formatting string.\n * @see `FormatWidth`\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n\n * @publicApi\n */\nfunction getLocaleTimeFormat(locale, width) {\n const data = ɵfindLocaleData(locale);\n return getLastDefinedValue(data[ɵLocaleDataIndex.TimeFormat], width);\n}\n/**\n * Retrieves a localized date-time formatting string.\n *\n * @param locale A locale code for the locale format rules to use.\n * @param width The format type.\n * @returns The localized formatting string.\n * @see `FormatWidth`\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction getLocaleDateTimeFormat(locale, width) {\n const data = ɵfindLocaleData(locale);\n const dateTimeFormatData = data[ɵLocaleDataIndex.DateTimeFormat];\n return getLastDefinedValue(dateTimeFormatData, width);\n}\n/**\n * Retrieves a localized number symbol that can be used to replace placeholders in number formats.\n * @param locale The locale code.\n * @param symbol The symbol to localize.\n * @returns The character for the localized symbol.\n * @see `NumberSymbol`\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction getLocaleNumberSymbol(locale, symbol) {\n const data = ɵfindLocaleData(locale);\n const res = data[ɵLocaleDataIndex.NumberSymbols][symbol];\n if (typeof res === 'undefined') {\n if (symbol === NumberSymbol.CurrencyDecimal) {\n return data[ɵLocaleDataIndex.NumberSymbols][NumberSymbol.Decimal];\n }\n else if (symbol === NumberSymbol.CurrencyGroup) {\n return data[ɵLocaleDataIndex.NumberSymbols][NumberSymbol.Group];\n }\n }\n return res;\n}\n/**\n * Retrieves a number format for a given locale.\n *\n * Numbers are formatted using patterns, like `#,###.00`. For example, the pattern `#,###.00`\n * when used to format the number 12345.678 could result in \"12'345,678\". That would happen if the\n * grouping separator for your language is an apostrophe, and the decimal separator is a comma.\n *\n * Important: The characters `.` `,` `0` `#` (and others below) are special placeholders\n * that stand for the decimal separator, and so on, and are NOT real characters.\n * You must NOT \"translate\" the placeholders. For example, don't change `.` to `,` even though in\n * your language the decimal point is written with a comma. The symbols should be replaced by the\n * local equivalents, using the appropriate `NumberSymbol` for your language.\n *\n * Here are the special characters used in number patterns:\n *\n * | Symbol | Meaning |\n * |--------|---------|\n * | . | Replaced automatically by the character used for the decimal point. |\n * | , | Replaced by the \"grouping\" (thousands) separator. |\n * | 0 | Replaced by a digit (or zero if there aren't enough digits). |\n * | # | Replaced by a digit (or nothing if there aren't enough). |\n * | ¤ | Replaced by a currency symbol, such as $ or USD. |\n * | % | Marks a percent format. The % symbol may change position, but must be retained. |\n * | E | Marks a scientific format. The E symbol may change position, but must be retained. |\n * | ' | Special characters used as literal characters are quoted with ASCII single quotes. |\n *\n * @param locale A locale code for the locale format rules to use.\n * @param type The type of numeric value to be formatted (such as `Decimal` or `Currency`.)\n * @returns The localized format string.\n * @see `NumberFormatStyle`\n * @see [CLDR website](http://cldr.unicode.org/translation/number-patterns)\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction getLocaleNumberFormat(locale, type) {\n const data = ɵfindLocaleData(locale);\n return data[ɵLocaleDataIndex.NumberFormats][type];\n}\n/**\n * Retrieves the symbol used to represent the currency for the main country\n * corresponding to a given locale. For example, '$' for `en-US`.\n *\n * @param locale A locale code for the locale format rules to use.\n * @returns The localized symbol character,\n * or `null` if the main country cannot be determined.\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction getLocaleCurrencySymbol(locale) {\n const data = ɵfindLocaleData(locale);\n return data[ɵLocaleDataIndex.CurrencySymbol] || null;\n}\n/**\n * Retrieves the name of the currency for the main country corresponding\n * to a given locale. For example, 'US Dollar' for `en-US`.\n * @param locale A locale code for the locale format rules to use.\n * @returns The currency name,\n * or `null` if the main country cannot be determined.\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction getLocaleCurrencyName(locale) {\n const data = ɵfindLocaleData(locale);\n return data[ɵLocaleDataIndex.CurrencyName] || null;\n}\n/**\n * Retrieves the default currency code for the given locale.\n *\n * The default is defined as the first currency which is still in use.\n *\n * @param locale The code of the locale whose currency code we want.\n * @returns The code of the default currency for the given locale.\n *\n * @publicApi\n */\nfunction getLocaleCurrencyCode(locale) {\n return ɵgetLocaleCurrencyCode(locale);\n}\n/**\n * Retrieves the currency values for a given locale.\n * @param locale A locale code for the locale format rules to use.\n * @returns The currency values.\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n */\nfunction getLocaleCurrencies(locale) {\n const data = ɵfindLocaleData(locale);\n return data[ɵLocaleDataIndex.Currencies];\n}\n/**\n * @alias core/ɵgetLocalePluralCase\n * @publicApi\n */\nconst getLocalePluralCase = ɵgetLocalePluralCase;\nfunction checkFullData(data) {\n if (!data[ɵLocaleDataIndex.ExtraData]) {\n throw new Error(`Missing extra locale data for the locale \"${data[ɵLocaleDataIndex\n .LocaleId]}\". Use \"registerLocaleData\" to load new data. See the \"I18n guide\" on angular.io to know more.`);\n }\n}\n/**\n * Retrieves locale-specific rules used to determine which day period to use\n * when more than one period is defined for a locale.\n *\n * There is a rule for each defined day period. The\n * first rule is applied to the first day period and so on.\n * Fall back to AM/PM when no rules are available.\n *\n * A rule can specify a period as time range, or as a single time value.\n *\n * This functionality is only available when you have loaded the full locale data.\n * See the [\"I18n guide\"](guide/i18n-common-format-data-locale).\n *\n * @param locale A locale code for the locale format rules to use.\n * @returns The rules for the locale, a single time value or array of *from-time, to-time*,\n * or null if no periods are available.\n *\n * @see `getLocaleExtraDayPeriods()`\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction getLocaleExtraDayPeriodRules(locale) {\n const data = ɵfindLocaleData(locale);\n checkFullData(data);\n const rules = data[ɵLocaleDataIndex.ExtraData][2 /* ExtraDayPeriodsRules */] || [];\n return rules.map((rule) => {\n if (typeof rule === 'string') {\n return extractTime(rule);\n }\n return [extractTime(rule[0]), extractTime(rule[1])];\n });\n}\n/**\n * Retrieves locale-specific day periods, which indicate roughly how a day is broken up\n * in different languages.\n * For example, for `en-US`, periods are morning, noon, afternoon, evening, and midnight.\n *\n * This functionality is only available when you have loaded the full locale data.\n * See the [\"I18n guide\"](guide/i18n-common-format-data-locale).\n *\n * @param locale A locale code for the locale format rules to use.\n * @param formStyle The required grammatical form.\n * @param width The required character width.\n * @returns The translated day-period strings.\n * @see `getLocaleExtraDayPeriodRules()`\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction getLocaleExtraDayPeriods(locale, formStyle, width) {\n const data = ɵfindLocaleData(locale);\n checkFullData(data);\n const dayPeriodsData = [\n data[ɵLocaleDataIndex.ExtraData][0 /* ExtraDayPeriodFormats */],\n data[ɵLocaleDataIndex.ExtraData][1 /* ExtraDayPeriodStandalone */]\n ];\n const dayPeriods = getLastDefinedValue(dayPeriodsData, formStyle) || [];\n return getLastDefinedValue(dayPeriods, width) || [];\n}\n/**\n * Retrieves the writing direction of a specified locale\n * @param locale A locale code for the locale format rules to use.\n * @publicApi\n * @returns 'rtl' or 'ltr'\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n */\nfunction getLocaleDirection(locale) {\n const data = ɵfindLocaleData(locale);\n return data[ɵLocaleDataIndex.Directionality];\n}\n/**\n * Retrieves the first value that is defined in an array, going backwards from an index position.\n *\n * To avoid repeating the same data (as when the \"format\" and \"standalone\" forms are the same)\n * add the first value to the locale data arrays, and add other values only if they are different.\n *\n * @param data The data array to retrieve from.\n * @param index A 0-based index into the array to start from.\n * @returns The value immediately before the given index position.\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction getLastDefinedValue(data, index) {\n for (let i = index; i > -1; i--) {\n if (typeof data[i] !== 'undefined') {\n return data[i];\n }\n }\n throw new Error('Locale data API: locale data undefined');\n}\n/**\n * Extracts the hours and minutes from a string like \"15:45\"\n */\nfunction extractTime(time) {\n const [h, m] = time.split(':');\n return { hours: +h, minutes: +m };\n}\n/**\n * Retrieves the currency symbol for a given currency code.\n *\n * For example, for the default `en-US` locale, the code `USD` can\n * be represented by the narrow symbol `$` or the wide symbol `US$`.\n *\n * @param code The currency code.\n * @param format The format, `wide` or `narrow`.\n * @param locale A locale code for the locale format rules to use.\n *\n * @returns The symbol, or the currency code if no symbol is available.\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction getCurrencySymbol(code, format, locale = 'en') {\n const currency = getLocaleCurrencies(locale)[code] || CURRENCIES_EN[code] || [];\n const symbolNarrow = currency[1 /* SymbolNarrow */];\n if (format === 'narrow' && typeof symbolNarrow === 'string') {\n return symbolNarrow;\n }\n return currency[0 /* Symbol */] || code;\n}\n// Most currencies have cents, that's why the default is 2\nconst DEFAULT_NB_OF_CURRENCY_DIGITS = 2;\n/**\n * Reports the number of decimal digits for a given currency.\n * The value depends upon the presence of cents in that particular currency.\n *\n * @param code The currency code.\n * @returns The number of decimal digits, typically 0 or 2.\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction getNumberOfCurrencyDigits(code) {\n let digits;\n const currency = CURRENCIES_EN[code];\n if (currency) {\n digits = currency[2 /* NbOfDigits */];\n }\n return typeof digits === 'number' ? digits : DEFAULT_NB_OF_CURRENCY_DIGITS;\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst ISO8601_DATE_REGEX = /^(\\d{4})-?(\\d\\d)-?(\\d\\d)(?:T(\\d\\d)(?::?(\\d\\d)(?::?(\\d\\d)(?:\\.(\\d+))?)?)?(Z|([+-])(\\d\\d):?(\\d\\d))?)?$/;\n// 1 2 3 4 5 6 7 8 9 10 11\nconst NAMED_FORMATS = {};\nconst DATE_FORMATS_SPLIT = /((?:[^BEGHLMOSWYZabcdhmswyz']+)|(?:'(?:[^']|'')*')|(?:G{1,5}|y{1,4}|Y{1,4}|M{1,5}|L{1,5}|w{1,2}|W{1}|d{1,2}|E{1,6}|c{1,6}|a{1,5}|b{1,5}|B{1,5}|h{1,2}|H{1,2}|m{1,2}|s{1,2}|S{1,3}|z{1,4}|Z{1,5}|O{1,4}))([\\s\\S]*)/;\nvar ZoneWidth;\n(function (ZoneWidth) {\n ZoneWidth[ZoneWidth[\"Short\"] = 0] = \"Short\";\n ZoneWidth[ZoneWidth[\"ShortGMT\"] = 1] = \"ShortGMT\";\n ZoneWidth[ZoneWidth[\"Long\"] = 2] = \"Long\";\n ZoneWidth[ZoneWidth[\"Extended\"] = 3] = \"Extended\";\n})(ZoneWidth || (ZoneWidth = {}));\nvar DateType;\n(function (DateType) {\n DateType[DateType[\"FullYear\"] = 0] = \"FullYear\";\n DateType[DateType[\"Month\"] = 1] = \"Month\";\n DateType[DateType[\"Date\"] = 2] = \"Date\";\n DateType[DateType[\"Hours\"] = 3] = \"Hours\";\n DateType[DateType[\"Minutes\"] = 4] = \"Minutes\";\n DateType[DateType[\"Seconds\"] = 5] = \"Seconds\";\n DateType[DateType[\"FractionalSeconds\"] = 6] = \"FractionalSeconds\";\n DateType[DateType[\"Day\"] = 7] = \"Day\";\n})(DateType || (DateType = {}));\nvar TranslationType;\n(function (TranslationType) {\n TranslationType[TranslationType[\"DayPeriods\"] = 0] = \"DayPeriods\";\n TranslationType[TranslationType[\"Days\"] = 1] = \"Days\";\n TranslationType[TranslationType[\"Months\"] = 2] = \"Months\";\n TranslationType[TranslationType[\"Eras\"] = 3] = \"Eras\";\n})(TranslationType || (TranslationType = {}));\n/**\n * @ngModule CommonModule\n * @description\n *\n * Formats a date according to locale rules.\n *\n * @param value The date to format, as a Date, or a number (milliseconds since UTC epoch)\n * or an [ISO date-time string](https://www.w3.org/TR/NOTE-datetime).\n * @param format The date-time components to include. See `DatePipe` for details.\n * @param locale A locale code for the locale format rules to use.\n * @param timezone The time zone. A time zone offset from GMT (such as `'+0430'`),\n * or a standard UTC/GMT or continental US time zone abbreviation.\n * If not specified, uses host system settings.\n *\n * @returns The formatted date string.\n *\n * @see `DatePipe`\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction formatDate(value, format, locale, timezone) {\n let date = toDate(value);\n const namedFormat = getNamedFormat(locale, format);\n format = namedFormat || format;\n let parts = [];\n let match;\n while (format) {\n match = DATE_FORMATS_SPLIT.exec(format);\n if (match) {\n parts = parts.concat(match.slice(1));\n const part = parts.pop();\n if (!part) {\n break;\n }\n format = part;\n }\n else {\n parts.push(format);\n break;\n }\n }\n let dateTimezoneOffset = date.getTimezoneOffset();\n if (timezone) {\n dateTimezoneOffset = timezoneToOffset(timezone, dateTimezoneOffset);\n date = convertTimezoneToLocal(date, timezone, true);\n }\n let text = '';\n parts.forEach(value => {\n const dateFormatter = getDateFormatter(value);\n text += dateFormatter ? dateFormatter(date, locale, dateTimezoneOffset) :\n value === '\\'\\'' ? '\\'' :\n value.replace(/(^'|'$)/g, '').replace(/''/g, '\\'');\n });\n return text;\n}\n/**\n * Create a new Date object with the given date value, and the time set to midnight.\n *\n * We cannot use `new Date(year, month, date)` because it maps years between 0 and 99 to 1900-1999.\n * See: https://github.com/angular/angular/issues/40377\n *\n * Note that this function returns a Date object whose time is midnight in the current locale's\n * timezone. In the future we might want to change this to be midnight in UTC, but this would be a\n * considerable breaking change.\n */\nfunction createDate(year, month, date) {\n // The `newDate` is set to midnight (UTC) on January 1st 1970.\n // - In PST this will be December 31st 1969 at 4pm.\n // - In GMT this will be January 1st 1970 at 1am.\n // Note that they even have different years, dates and months!\n const newDate = new Date(0);\n // `setFullYear()` allows years like 0001 to be set correctly. This function does not\n // change the internal time of the date.\n // Consider calling `setFullYear(2019, 8, 20)` (September 20, 2019).\n // - In PST this will now be September 20, 2019 at 4pm\n // - In GMT this will now be September 20, 2019 at 1am\n newDate.setFullYear(year, month, date);\n // We want the final date to be at local midnight, so we reset the time.\n // - In PST this will now be September 20, 2019 at 12am\n // - In GMT this will now be September 20, 2019 at 12am\n newDate.setHours(0, 0, 0);\n return newDate;\n}\nfunction getNamedFormat(locale, format) {\n const localeId = getLocaleId(locale);\n NAMED_FORMATS[localeId] = NAMED_FORMATS[localeId] || {};\n if (NAMED_FORMATS[localeId][format]) {\n return NAMED_FORMATS[localeId][format];\n }\n let formatValue = '';\n switch (format) {\n case 'shortDate':\n formatValue = getLocaleDateFormat(locale, FormatWidth.Short);\n break;\n case 'mediumDate':\n formatValue = getLocaleDateFormat(locale, FormatWidth.Medium);\n break;\n case 'longDate':\n formatValue = getLocaleDateFormat(locale, FormatWidth.Long);\n break;\n case 'fullDate':\n formatValue = getLocaleDateFormat(locale, FormatWidth.Full);\n break;\n case 'shortTime':\n formatValue = getLocaleTimeFormat(locale, FormatWidth.Short);\n break;\n case 'mediumTime':\n formatValue = getLocaleTimeFormat(locale, FormatWidth.Medium);\n break;\n case 'longTime':\n formatValue = getLocaleTimeFormat(locale, FormatWidth.Long);\n break;\n case 'fullTime':\n formatValue = getLocaleTimeFormat(locale, FormatWidth.Full);\n break;\n case 'short':\n const shortTime = getNamedFormat(locale, 'shortTime');\n const shortDate = getNamedFormat(locale, 'shortDate');\n formatValue = formatDateTime(getLocaleDateTimeFormat(locale, FormatWidth.Short), [shortTime, shortDate]);\n break;\n case 'medium':\n const mediumTime = getNamedFormat(locale, 'mediumTime');\n const mediumDate = getNamedFormat(locale, 'mediumDate');\n formatValue = formatDateTime(getLocaleDateTimeFormat(locale, FormatWidth.Medium), [mediumTime, mediumDate]);\n break;\n case 'long':\n const longTime = getNamedFormat(locale, 'longTime');\n const longDate = getNamedFormat(locale, 'longDate');\n formatValue =\n formatDateTime(getLocaleDateTimeFormat(locale, FormatWidth.Long), [longTime, longDate]);\n break;\n case 'full':\n const fullTime = getNamedFormat(locale, 'fullTime');\n const fullDate = getNamedFormat(locale, 'fullDate');\n formatValue =\n formatDateTime(getLocaleDateTimeFormat(locale, FormatWidth.Full), [fullTime, fullDate]);\n break;\n }\n if (formatValue) {\n NAMED_FORMATS[localeId][format] = formatValue;\n }\n return formatValue;\n}\nfunction formatDateTime(str, opt_values) {\n if (opt_values) {\n str = str.replace(/\\{([^}]+)}/g, function (match, key) {\n return (opt_values != null && key in opt_values) ? opt_values[key] : match;\n });\n }\n return str;\n}\nfunction padNumber(num, digits, minusSign = '-', trim, negWrap) {\n let neg = '';\n if (num < 0 || (negWrap && num <= 0)) {\n if (negWrap) {\n num = -num + 1;\n }\n else {\n num = -num;\n neg = minusSign;\n }\n }\n let strNum = String(num);\n while (strNum.length < digits) {\n strNum = '0' + strNum;\n }\n if (trim) {\n strNum = strNum.substr(strNum.length - digits);\n }\n return neg + strNum;\n}\nfunction formatFractionalSeconds(milliseconds, digits) {\n const strMs = padNumber(milliseconds, 3);\n return strMs.substr(0, digits);\n}\n/**\n * Returns a date formatter that transforms a date into its locale digit representation\n */\nfunction dateGetter(name, size, offset = 0, trim = false, negWrap = false) {\n return function (date, locale) {\n let part = getDatePart(name, date);\n if (offset > 0 || part > -offset) {\n part += offset;\n }\n if (name === DateType.Hours) {\n if (part === 0 && offset === -12) {\n part = 12;\n }\n }\n else if (name === DateType.FractionalSeconds) {\n return formatFractionalSeconds(part, size);\n }\n const localeMinus = getLocaleNumberSymbol(locale, NumberSymbol.MinusSign);\n return padNumber(part, size, localeMinus, trim, negWrap);\n };\n}\nfunction getDatePart(part, date) {\n switch (part) {\n case DateType.FullYear:\n return date.getFullYear();\n case DateType.Month:\n return date.getMonth();\n case DateType.Date:\n return date.getDate();\n case DateType.Hours:\n return date.getHours();\n case DateType.Minutes:\n return date.getMinutes();\n case DateType.Seconds:\n return date.getSeconds();\n case DateType.FractionalSeconds:\n return date.getMilliseconds();\n case DateType.Day:\n return date.getDay();\n default:\n throw new Error(`Unknown DateType value \"${part}\".`);\n }\n}\n/**\n * Returns a date formatter that transforms a date into its locale string representation\n */\nfunction dateStrGetter(name, width, form = FormStyle.Format, extended = false) {\n return function (date, locale) {\n return getDateTranslation(date, locale, name, width, form, extended);\n };\n}\n/**\n * Returns the locale translation of a date for a given form, type and width\n */\nfunction getDateTranslation(date, locale, name, width, form, extended) {\n switch (name) {\n case TranslationType.Months:\n return getLocaleMonthNames(locale, form, width)[date.getMonth()];\n case TranslationType.Days:\n return getLocaleDayNames(locale, form, width)[date.getDay()];\n case TranslationType.DayPeriods:\n const currentHours = date.getHours();\n const currentMinutes = date.getMinutes();\n if (extended) {\n const rules = getLocaleExtraDayPeriodRules(locale);\n const dayPeriods = getLocaleExtraDayPeriods(locale, form, width);\n const index = rules.findIndex(rule => {\n if (Array.isArray(rule)) {\n // morning, afternoon, evening, night\n const [from, to] = rule;\n const afterFrom = currentHours >= from.hours && currentMinutes >= from.minutes;\n const beforeTo = (currentHours < to.hours ||\n (currentHours === to.hours && currentMinutes < to.minutes));\n // We must account for normal rules that span a period during the day (e.g. 6am-9am)\n // where `from` is less (earlier) than `to`. But also rules that span midnight (e.g.\n // 10pm - 5am) where `from` is greater (later!) than `to`.\n //\n // In the first case the current time must be BOTH after `from` AND before `to`\n // (e.g. 8am is after 6am AND before 10am).\n //\n // In the second case the current time must be EITHER after `from` OR before `to`\n // (e.g. 4am is before 5am but not after 10pm; and 11pm is not before 5am but it is\n // after 10pm).\n if (from.hours < to.hours) {\n if (afterFrom && beforeTo) {\n return true;\n }\n }\n else if (afterFrom || beforeTo) {\n return true;\n }\n }\n else { // noon or midnight\n if (rule.hours === currentHours && rule.minutes === currentMinutes) {\n return true;\n }\n }\n return false;\n });\n if (index !== -1) {\n return dayPeriods[index];\n }\n }\n // if no rules for the day periods, we use am/pm by default\n return getLocaleDayPeriods(locale, form, width)[currentHours < 12 ? 0 : 1];\n case TranslationType.Eras:\n return getLocaleEraNames(locale, width)[date.getFullYear() <= 0 ? 0 : 1];\n default:\n // This default case is not needed by TypeScript compiler, as the switch is exhaustive.\n // However Closure Compiler does not understand that and reports an error in typed mode.\n // The `throw new Error` below works around the problem, and the unexpected: never variable\n // makes sure tsc still checks this code is unreachable.\n const unexpected = name;\n throw new Error(`unexpected translation type ${unexpected}`);\n }\n}\n/**\n * Returns a date formatter that transforms a date and an offset into a timezone with ISO8601 or\n * GMT format depending on the width (eg: short = +0430, short:GMT = GMT+4, long = GMT+04:30,\n * extended = +04:30)\n */\nfunction timeZoneGetter(width) {\n return function (date, locale, offset) {\n const zone = -1 * offset;\n const minusSign = getLocaleNumberSymbol(locale, NumberSymbol.MinusSign);\n const hours = zone > 0 ? Math.floor(zone / 60) : Math.ceil(zone / 60);\n switch (width) {\n case ZoneWidth.Short:\n return ((zone >= 0) ? '+' : '') + padNumber(hours, 2, minusSign) +\n padNumber(Math.abs(zone % 60), 2, minusSign);\n case ZoneWidth.ShortGMT:\n return 'GMT' + ((zone >= 0) ? '+' : '') + padNumber(hours, 1, minusSign);\n case ZoneWidth.Long:\n return 'GMT' + ((zone >= 0) ? '+' : '') + padNumber(hours, 2, minusSign) + ':' +\n padNumber(Math.abs(zone % 60), 2, minusSign);\n case ZoneWidth.Extended:\n if (offset === 0) {\n return 'Z';\n }\n else {\n return ((zone >= 0) ? '+' : '') + padNumber(hours, 2, minusSign) + ':' +\n padNumber(Math.abs(zone % 60), 2, minusSign);\n }\n default:\n throw new Error(`Unknown zone width \"${width}\"`);\n }\n };\n}\nconst JANUARY = 0;\nconst THURSDAY = 4;\nfunction getFirstThursdayOfYear(year) {\n const firstDayOfYear = createDate(year, JANUARY, 1).getDay();\n return createDate(year, 0, 1 + ((firstDayOfYear <= THURSDAY) ? THURSDAY : THURSDAY + 7) - firstDayOfYear);\n}\nfunction getThursdayThisWeek(datetime) {\n return createDate(datetime.getFullYear(), datetime.getMonth(), datetime.getDate() + (THURSDAY - datetime.getDay()));\n}\nfunction weekGetter(size, monthBased = false) {\n return function (date, locale) {\n let result;\n if (monthBased) {\n const nbDaysBefore1stDayOfMonth = new Date(date.getFullYear(), date.getMonth(), 1).getDay() - 1;\n const today = date.getDate();\n result = 1 + Math.floor((today + nbDaysBefore1stDayOfMonth) / 7);\n }\n else {\n const thisThurs = getThursdayThisWeek(date);\n // Some days of a year are part of next year according to ISO 8601.\n // Compute the firstThurs from the year of this week's Thursday\n const firstThurs = getFirstThursdayOfYear(thisThurs.getFullYear());\n const diff = thisThurs.getTime() - firstThurs.getTime();\n result = 1 + Math.round(diff / 6.048e8); // 6.048e8 ms per week\n }\n return padNumber(result, size, getLocaleNumberSymbol(locale, NumberSymbol.MinusSign));\n };\n}\n/**\n * Returns a date formatter that provides the week-numbering year for the input date.\n */\nfunction weekNumberingYearGetter(size, trim = false) {\n return function (date, locale) {\n const thisThurs = getThursdayThisWeek(date);\n const weekNumberingYear = thisThurs.getFullYear();\n return padNumber(weekNumberingYear, size, getLocaleNumberSymbol(locale, NumberSymbol.MinusSign), trim);\n };\n}\nconst DATE_FORMATS = {};\n// Based on CLDR formats:\n// See complete list: http://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table\n// See also explanations: http://cldr.unicode.org/translation/date-time\n// TODO(ocombe): support all missing cldr formats: U, Q, D, F, e, j, J, C, A, v, V, X, x\nfunction getDateFormatter(format) {\n if (DATE_FORMATS[format]) {\n return DATE_FORMATS[format];\n }\n let formatter;\n switch (format) {\n // Era name (AD/BC)\n case 'G':\n case 'GG':\n case 'GGG':\n formatter = dateStrGetter(TranslationType.Eras, TranslationWidth.Abbreviated);\n break;\n case 'GGGG':\n formatter = dateStrGetter(TranslationType.Eras, TranslationWidth.Wide);\n break;\n case 'GGGGG':\n formatter = dateStrGetter(TranslationType.Eras, TranslationWidth.Narrow);\n break;\n // 1 digit representation of the year, e.g. (AD 1 => 1, AD 199 => 199)\n case 'y':\n formatter = dateGetter(DateType.FullYear, 1, 0, false, true);\n break;\n // 2 digit representation of the year, padded (00-99). (e.g. AD 2001 => 01, AD 2010 => 10)\n case 'yy':\n formatter = dateGetter(DateType.FullYear, 2, 0, true, true);\n break;\n // 3 digit representation of the year, padded (000-999). (e.g. AD 2001 => 01, AD 2010 => 10)\n case 'yyy':\n formatter = dateGetter(DateType.FullYear, 3, 0, false, true);\n break;\n // 4 digit representation of the year (e.g. AD 1 => 0001, AD 2010 => 2010)\n case 'yyyy':\n formatter = dateGetter(DateType.FullYear, 4, 0, false, true);\n break;\n // 1 digit representation of the week-numbering year, e.g. (AD 1 => 1, AD 199 => 199)\n case 'Y':\n formatter = weekNumberingYearGetter(1);\n break;\n // 2 digit representation of the week-numbering year, padded (00-99). (e.g. AD 2001 => 01, AD\n // 2010 => 10)\n case 'YY':\n formatter = weekNumberingYearGetter(2, true);\n break;\n // 3 digit representation of the week-numbering year, padded (000-999). (e.g. AD 1 => 001, AD\n // 2010 => 2010)\n case 'YYY':\n formatter = weekNumberingYearGetter(3);\n break;\n // 4 digit representation of the week-numbering year (e.g. AD 1 => 0001, AD 2010 => 2010)\n case 'YYYY':\n formatter = weekNumberingYearGetter(4);\n break;\n // Month of the year (1-12), numeric\n case 'M':\n case 'L':\n formatter = dateGetter(DateType.Month, 1, 1);\n break;\n case 'MM':\n case 'LL':\n formatter = dateGetter(DateType.Month, 2, 1);\n break;\n // Month of the year (January, ...), string, format\n case 'MMM':\n formatter = dateStrGetter(TranslationType.Months, TranslationWidth.Abbreviated);\n break;\n case 'MMMM':\n formatter = dateStrGetter(TranslationType.Months, TranslationWidth.Wide);\n break;\n case 'MMMMM':\n formatter = dateStrGetter(TranslationType.Months, TranslationWidth.Narrow);\n break;\n // Month of the year (January, ...), string, standalone\n case 'LLL':\n formatter =\n dateStrGetter(TranslationType.Months, TranslationWidth.Abbreviated, FormStyle.Standalone);\n break;\n case 'LLLL':\n formatter =\n dateStrGetter(TranslationType.Months, TranslationWidth.Wide, FormStyle.Standalone);\n break;\n case 'LLLLL':\n formatter =\n dateStrGetter(TranslationType.Months, TranslationWidth.Narrow, FormStyle.Standalone);\n break;\n // Week of the year (1, ... 52)\n case 'w':\n formatter = weekGetter(1);\n break;\n case 'ww':\n formatter = weekGetter(2);\n break;\n // Week of the month (1, ...)\n case 'W':\n formatter = weekGetter(1, true);\n break;\n // Day of the month (1-31)\n case 'd':\n formatter = dateGetter(DateType.Date, 1);\n break;\n case 'dd':\n formatter = dateGetter(DateType.Date, 2);\n break;\n // Day of the Week StandAlone (1, 1, Mon, Monday, M, Mo)\n case 'c':\n case 'cc':\n formatter = dateGetter(DateType.Day, 1);\n break;\n case 'ccc':\n formatter =\n dateStrGetter(TranslationType.Days, TranslationWidth.Abbreviated, FormStyle.Standalone);\n break;\n case 'cccc':\n formatter = dateStrGetter(TranslationType.Days, TranslationWidth.Wide, FormStyle.Standalone);\n break;\n case 'ccccc':\n formatter =\n dateStrGetter(TranslationType.Days, TranslationWidth.Narrow, FormStyle.Standalone);\n break;\n case 'cccccc':\n formatter = dateStrGetter(TranslationType.Days, TranslationWidth.Short, FormStyle.Standalone);\n break;\n // Day of the Week\n case 'E':\n case 'EE':\n case 'EEE':\n formatter = dateStrGetter(TranslationType.Days, TranslationWidth.Abbreviated);\n break;\n case 'EEEE':\n formatter = dateStrGetter(TranslationType.Days, TranslationWidth.Wide);\n break;\n case 'EEEEE':\n formatter = dateStrGetter(TranslationType.Days, TranslationWidth.Narrow);\n break;\n case 'EEEEEE':\n formatter = dateStrGetter(TranslationType.Days, TranslationWidth.Short);\n break;\n // Generic period of the day (am-pm)\n case 'a':\n case 'aa':\n case 'aaa':\n formatter = dateStrGetter(TranslationType.DayPeriods, TranslationWidth.Abbreviated);\n break;\n case 'aaaa':\n formatter = dateStrGetter(TranslationType.DayPeriods, TranslationWidth.Wide);\n break;\n case 'aaaaa':\n formatter = dateStrGetter(TranslationType.DayPeriods, TranslationWidth.Narrow);\n break;\n // Extended period of the day (midnight, at night, ...), standalone\n case 'b':\n case 'bb':\n case 'bbb':\n formatter = dateStrGetter(TranslationType.DayPeriods, TranslationWidth.Abbreviated, FormStyle.Standalone, true);\n break;\n case 'bbbb':\n formatter = dateStrGetter(TranslationType.DayPeriods, TranslationWidth.Wide, FormStyle.Standalone, true);\n break;\n case 'bbbbb':\n formatter = dateStrGetter(TranslationType.DayPeriods, TranslationWidth.Narrow, FormStyle.Standalone, true);\n break;\n // Extended period of the day (midnight, night, ...), standalone\n case 'B':\n case 'BB':\n case 'BBB':\n formatter = dateStrGetter(TranslationType.DayPeriods, TranslationWidth.Abbreviated, FormStyle.Format, true);\n break;\n case 'BBBB':\n formatter =\n dateStrGetter(TranslationType.DayPeriods, TranslationWidth.Wide, FormStyle.Format, true);\n break;\n case 'BBBBB':\n formatter = dateStrGetter(TranslationType.DayPeriods, TranslationWidth.Narrow, FormStyle.Format, true);\n break;\n // Hour in AM/PM, (1-12)\n case 'h':\n formatter = dateGetter(DateType.Hours, 1, -12);\n break;\n case 'hh':\n formatter = dateGetter(DateType.Hours, 2, -12);\n break;\n // Hour of the day (0-23)\n case 'H':\n formatter = dateGetter(DateType.Hours, 1);\n break;\n // Hour in day, padded (00-23)\n case 'HH':\n formatter = dateGetter(DateType.Hours, 2);\n break;\n // Minute of the hour (0-59)\n case 'm':\n formatter = dateGetter(DateType.Minutes, 1);\n break;\n case 'mm':\n formatter = dateGetter(DateType.Minutes, 2);\n break;\n // Second of the minute (0-59)\n case 's':\n formatter = dateGetter(DateType.Seconds, 1);\n break;\n case 'ss':\n formatter = dateGetter(DateType.Seconds, 2);\n break;\n // Fractional second\n case 'S':\n formatter = dateGetter(DateType.FractionalSeconds, 1);\n break;\n case 'SS':\n formatter = dateGetter(DateType.FractionalSeconds, 2);\n break;\n case 'SSS':\n formatter = dateGetter(DateType.FractionalSeconds, 3);\n break;\n // Timezone ISO8601 short format (-0430)\n case 'Z':\n case 'ZZ':\n case 'ZZZ':\n formatter = timeZoneGetter(ZoneWidth.Short);\n break;\n // Timezone ISO8601 extended format (-04:30)\n case 'ZZZZZ':\n formatter = timeZoneGetter(ZoneWidth.Extended);\n break;\n // Timezone GMT short format (GMT+4)\n case 'O':\n case 'OO':\n case 'OOO':\n // Should be location, but fallback to format O instead because we don't have the data yet\n case 'z':\n case 'zz':\n case 'zzz':\n formatter = timeZoneGetter(ZoneWidth.ShortGMT);\n break;\n // Timezone GMT long format (GMT+0430)\n case 'OOOO':\n case 'ZZZZ':\n // Should be location, but fallback to format O instead because we don't have the data yet\n case 'zzzz':\n formatter = timeZoneGetter(ZoneWidth.Long);\n break;\n default:\n return null;\n }\n DATE_FORMATS[format] = formatter;\n return formatter;\n}\nfunction timezoneToOffset(timezone, fallback) {\n // Support: IE 11 only, Edge 13-15+\n // IE/Edge do not \"understand\" colon (`:`) in timezone\n timezone = timezone.replace(/:/g, '');\n const requestedTimezoneOffset = Date.parse('Jan 01, 1970 00:00:00 ' + timezone) / 60000;\n return isNaN(requestedTimezoneOffset) ? fallback : requestedTimezoneOffset;\n}\nfunction addDateMinutes(date, minutes) {\n date = new Date(date.getTime());\n date.setMinutes(date.getMinutes() + minutes);\n return date;\n}\nfunction convertTimezoneToLocal(date, timezone, reverse) {\n const reverseValue = reverse ? -1 : 1;\n const dateTimezoneOffset = date.getTimezoneOffset();\n const timezoneOffset = timezoneToOffset(timezone, dateTimezoneOffset);\n return addDateMinutes(date, reverseValue * (timezoneOffset - dateTimezoneOffset));\n}\n/**\n * Converts a value to date.\n *\n * Supported input formats:\n * - `Date`\n * - number: timestamp\n * - string: numeric (e.g. \"1234\"), ISO and date strings in a format supported by\n * [Date.parse()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/parse).\n * Note: ISO strings without time return a date without timeoffset.\n *\n * Throws if unable to convert to a date.\n */\nfunction toDate(value) {\n if (isDate(value)) {\n return value;\n }\n if (typeof value === 'number' && !isNaN(value)) {\n return new Date(value);\n }\n if (typeof value === 'string') {\n value = value.trim();\n if (/^(\\d{4}(-\\d{1,2}(-\\d{1,2})?)?)$/.test(value)) {\n /* For ISO Strings without time the day, month and year must be extracted from the ISO String\n before Date creation to avoid time offset and errors in the new Date.\n If we only replace '-' with ',' in the ISO String (\"2015,01,01\"), and try to create a new\n date, some browsers (e.g. IE 9) will throw an invalid Date error.\n If we leave the '-' (\"2015-01-01\") and try to create a new Date(\"2015-01-01\") the timeoffset\n is applied.\n Note: ISO months are 0 for January, 1 for February, ... */\n const [y, m = 1, d = 1] = value.split('-').map((val) => +val);\n return createDate(y, m - 1, d);\n }\n const parsedNb = parseFloat(value);\n // any string that only contains numbers, like \"1234\" but not like \"1234hello\"\n if (!isNaN(value - parsedNb)) {\n return new Date(parsedNb);\n }\n let match;\n if (match = value.match(ISO8601_DATE_REGEX)) {\n return isoStringToDate(match);\n }\n }\n const date = new Date(value);\n if (!isDate(date)) {\n throw new Error(`Unable to convert \"${value}\" into a date`);\n }\n return date;\n}\n/**\n * Converts a date in ISO8601 to a Date.\n * Used instead of `Date.parse` because of browser discrepancies.\n */\nfunction isoStringToDate(match) {\n const date = new Date(0);\n let tzHour = 0;\n let tzMin = 0;\n // match[8] means that the string contains \"Z\" (UTC) or a timezone like \"+01:00\" or \"+0100\"\n const dateSetter = match[8] ? date.setUTCFullYear : date.setFullYear;\n const timeSetter = match[8] ? date.setUTCHours : date.setHours;\n // if there is a timezone defined like \"+01:00\" or \"+0100\"\n if (match[9]) {\n tzHour = Number(match[9] + match[10]);\n tzMin = Number(match[9] + match[11]);\n }\n dateSetter.call(date, Number(match[1]), Number(match[2]) - 1, Number(match[3]));\n const h = Number(match[4] || 0) - tzHour;\n const m = Number(match[5] || 0) - tzMin;\n const s = Number(match[6] || 0);\n // The ECMAScript specification (https://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.11)\n // defines that `DateTime` milliseconds should always be rounded down, so that `999.9ms`\n // becomes `999ms`.\n const ms = Math.floor(parseFloat('0.' + (match[7] || 0)) * 1000);\n timeSetter.call(date, h, m, s, ms);\n return date;\n}\nfunction isDate(value) {\n return value instanceof Date && !isNaN(value.valueOf());\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst NUMBER_FORMAT_REGEXP = /^(\\d+)?\\.((\\d+)(-(\\d+))?)?$/;\nconst MAX_DIGITS = 22;\nconst DECIMAL_SEP = '.';\nconst ZERO_CHAR = '0';\nconst PATTERN_SEP = ';';\nconst GROUP_SEP = ',';\nconst DIGIT_CHAR = '#';\nconst CURRENCY_CHAR = '¤';\nconst PERCENT_CHAR = '%';\n/**\n * Transforms a number to a locale string based on a style and a format.\n */\nfunction formatNumberToLocaleString(value, pattern, locale, groupSymbol, decimalSymbol, digitsInfo, isPercent = false) {\n let formattedText = '';\n let isZero = false;\n if (!isFinite(value)) {\n formattedText = getLocaleNumberSymbol(locale, NumberSymbol.Infinity);\n }\n else {\n let parsedNumber = parseNumber(value);\n if (isPercent) {\n parsedNumber = toPercent(parsedNumber);\n }\n let minInt = pattern.minInt;\n let minFraction = pattern.minFrac;\n let maxFraction = pattern.maxFrac;\n if (digitsInfo) {\n const parts = digitsInfo.match(NUMBER_FORMAT_REGEXP);\n if (parts === null) {\n throw new Error(`${digitsInfo} is not a valid digit info`);\n }\n const minIntPart = parts[1];\n const minFractionPart = parts[3];\n const maxFractionPart = parts[5];\n if (minIntPart != null) {\n minInt = parseIntAutoRadix(minIntPart);\n }\n if (minFractionPart != null) {\n minFraction = parseIntAutoRadix(minFractionPart);\n }\n if (maxFractionPart != null) {\n maxFraction = parseIntAutoRadix(maxFractionPart);\n }\n else if (minFractionPart != null && minFraction > maxFraction) {\n maxFraction = minFraction;\n }\n }\n roundNumber(parsedNumber, minFraction, maxFraction);\n let digits = parsedNumber.digits;\n let integerLen = parsedNumber.integerLen;\n const exponent = parsedNumber.exponent;\n let decimals = [];\n isZero = digits.every(d => !d);\n // pad zeros for small numbers\n for (; integerLen < minInt; integerLen++) {\n digits.unshift(0);\n }\n // pad zeros for small numbers\n for (; integerLen < 0; integerLen++) {\n digits.unshift(0);\n }\n // extract decimals digits\n if (integerLen > 0) {\n decimals = digits.splice(integerLen, digits.length);\n }\n else {\n decimals = digits;\n digits = [0];\n }\n // format the integer digits with grouping separators\n const groups = [];\n if (digits.length >= pattern.lgSize) {\n groups.unshift(digits.splice(-pattern.lgSize, digits.length).join(''));\n }\n while (digits.length > pattern.gSize) {\n groups.unshift(digits.splice(-pattern.gSize, digits.length).join(''));\n }\n if (digits.length) {\n groups.unshift(digits.join(''));\n }\n formattedText = groups.join(getLocaleNumberSymbol(locale, groupSymbol));\n // append the decimal digits\n if (decimals.length) {\n formattedText += getLocaleNumberSymbol(locale, decimalSymbol) + decimals.join('');\n }\n if (exponent) {\n formattedText += getLocaleNumberSymbol(locale, NumberSymbol.Exponential) + '+' + exponent;\n }\n }\n if (value < 0 && !isZero) {\n formattedText = pattern.negPre + formattedText + pattern.negSuf;\n }\n else {\n formattedText = pattern.posPre + formattedText + pattern.posSuf;\n }\n return formattedText;\n}\n/**\n * @ngModule CommonModule\n * @description\n *\n * Formats a number as currency using locale rules.\n *\n * @param value The number to format.\n * @param locale A locale code for the locale format rules to use.\n * @param currency A string containing the currency symbol or its name,\n * such as \"$\" or \"Canadian Dollar\". Used in output string, but does not affect the operation\n * of the function.\n * @param currencyCode The [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217)\n * currency code, such as `USD` for the US dollar and `EUR` for the euro.\n * Used to determine the number of digits in the decimal part.\n * @param digitsInfo Decimal representation options, specified by a string in the following format:\n * `{minIntegerDigits}.{minFractionDigits}-{maxFractionDigits}`. See `DecimalPipe` for more details.\n *\n * @returns The formatted currency value.\n *\n * @see `formatNumber()`\n * @see `DecimalPipe`\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction formatCurrency(value, locale, currency, currencyCode, digitsInfo) {\n const format = getLocaleNumberFormat(locale, NumberFormatStyle.Currency);\n const pattern = parseNumberFormat(format, getLocaleNumberSymbol(locale, NumberSymbol.MinusSign));\n pattern.minFrac = getNumberOfCurrencyDigits(currencyCode);\n pattern.maxFrac = pattern.minFrac;\n const res = formatNumberToLocaleString(value, pattern, locale, NumberSymbol.CurrencyGroup, NumberSymbol.CurrencyDecimal, digitsInfo);\n return res\n .replace(CURRENCY_CHAR, currency)\n // if we have 2 time the currency character, the second one is ignored\n .replace(CURRENCY_CHAR, '')\n // If there is a spacing between currency character and the value and\n // the currency character is supressed by passing an empty string, the\n // spacing character would remain as part of the string. Then we\n // should remove it.\n .trim();\n}\n/**\n * @ngModule CommonModule\n * @description\n *\n * Formats a number as a percentage according to locale rules.\n *\n * @param value The number to format.\n * @param locale A locale code for the locale format rules to use.\n * @param digitsInfo Decimal representation options, specified by a string in the following format:\n * `{minIntegerDigits}.{minFractionDigits}-{maxFractionDigits}`. See `DecimalPipe` for more details.\n *\n * @returns The formatted percentage value.\n *\n * @see `formatNumber()`\n * @see `DecimalPipe`\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n * @publicApi\n *\n */\nfunction formatPercent(value, locale, digitsInfo) {\n const format = getLocaleNumberFormat(locale, NumberFormatStyle.Percent);\n const pattern = parseNumberFormat(format, getLocaleNumberSymbol(locale, NumberSymbol.MinusSign));\n const res = formatNumberToLocaleString(value, pattern, locale, NumberSymbol.Group, NumberSymbol.Decimal, digitsInfo, true);\n return res.replace(new RegExp(PERCENT_CHAR, 'g'), getLocaleNumberSymbol(locale, NumberSymbol.PercentSign));\n}\n/**\n * @ngModule CommonModule\n * @description\n *\n * Formats a number as text, with group sizing, separator, and other\n * parameters based on the locale.\n *\n * @param value The number to format.\n * @param locale A locale code for the locale format rules to use.\n * @param digitsInfo Decimal representation options, specified by a string in the following format:\n * `{minIntegerDigits}.{minFractionDigits}-{maxFractionDigits}`. See `DecimalPipe` for more details.\n *\n * @returns The formatted text string.\n * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n-overview)\n *\n * @publicApi\n */\nfunction formatNumber(value, locale, digitsInfo) {\n const format = getLocaleNumberFormat(locale, NumberFormatStyle.Decimal);\n const pattern = parseNumberFormat(format, getLocaleNumberSymbol(locale, NumberSymbol.MinusSign));\n return formatNumberToLocaleString(value, pattern, locale, NumberSymbol.Group, NumberSymbol.Decimal, digitsInfo);\n}\nfunction parseNumberFormat(format, minusSign = '-') {\n const p = {\n minInt: 1,\n minFrac: 0,\n maxFrac: 0,\n posPre: '',\n posSuf: '',\n negPre: '',\n negSuf: '',\n gSize: 0,\n lgSize: 0\n };\n const patternParts = format.split(PATTERN_SEP);\n const positive = patternParts[0];\n const negative = patternParts[1];\n const positiveParts = positive.indexOf(DECIMAL_SEP) !== -1 ?\n positive.split(DECIMAL_SEP) :\n [\n positive.substring(0, positive.lastIndexOf(ZERO_CHAR) + 1),\n positive.substring(positive.lastIndexOf(ZERO_CHAR) + 1)\n ], integer = positiveParts[0], fraction = positiveParts[1] || '';\n p.posPre = integer.substr(0, integer.indexOf(DIGIT_CHAR));\n for (let i = 0; i < fraction.length; i++) {\n const ch = fraction.charAt(i);\n if (ch === ZERO_CHAR) {\n p.minFrac = p.maxFrac = i + 1;\n }\n else if (ch === DIGIT_CHAR) {\n p.maxFrac = i + 1;\n }\n else {\n p.posSuf += ch;\n }\n }\n const groups = integer.split(GROUP_SEP);\n p.gSize = groups[1] ? groups[1].length : 0;\n p.lgSize = (groups[2] || groups[1]) ? (groups[2] || groups[1]).length : 0;\n if (negative) {\n const trunkLen = positive.length - p.posPre.length - p.posSuf.length, pos = negative.indexOf(DIGIT_CHAR);\n p.negPre = negative.substr(0, pos).replace(/'/g, '');\n p.negSuf = negative.substr(pos + trunkLen).replace(/'/g, '');\n }\n else {\n p.negPre = minusSign + p.posPre;\n p.negSuf = p.posSuf;\n }\n return p;\n}\n// Transforms a parsed number into a percentage by multiplying it by 100\nfunction toPercent(parsedNumber) {\n // if the number is 0, don't do anything\n if (parsedNumber.digits[0] === 0) {\n return parsedNumber;\n }\n // Getting the current number of decimals\n const fractionLen = parsedNumber.digits.length - parsedNumber.integerLen;\n if (parsedNumber.exponent) {\n parsedNumber.exponent += 2;\n }\n else {\n if (fractionLen === 0) {\n parsedNumber.digits.push(0, 0);\n }\n else if (fractionLen === 1) {\n parsedNumber.digits.push(0);\n }\n parsedNumber.integerLen += 2;\n }\n return parsedNumber;\n}\n/**\n * Parses a number.\n * Significant bits of this parse algorithm came from https://github.com/MikeMcl/big.js/\n */\nfunction parseNumber(num) {\n let numStr = Math.abs(num) + '';\n let exponent = 0, digits, integerLen;\n let i, j, zeros;\n // Decimal point?\n if ((integerLen = numStr.indexOf(DECIMAL_SEP)) > -1) {\n numStr = numStr.replace(DECIMAL_SEP, '');\n }\n // Exponential form?\n if ((i = numStr.search(/e/i)) > 0) {\n // Work out the exponent.\n if (integerLen < 0)\n integerLen = i;\n integerLen += +numStr.slice(i + 1);\n numStr = numStr.substring(0, i);\n }\n else if (integerLen < 0) {\n // There was no decimal point or exponent so it is an integer.\n integerLen = numStr.length;\n }\n // Count the number of leading zeros.\n for (i = 0; numStr.charAt(i) === ZERO_CHAR; i++) { /* empty */\n }\n if (i === (zeros = numStr.length)) {\n // The digits are all zero.\n digits = [0];\n integerLen = 1;\n }\n else {\n // Count the number of trailing zeros\n zeros--;\n while (numStr.charAt(zeros) === ZERO_CHAR)\n zeros--;\n // Trailing zeros are insignificant so ignore them\n integerLen -= i;\n digits = [];\n // Convert string to array of digits without leading/trailing zeros.\n for (j = 0; i <= zeros; i++, j++) {\n digits[j] = Number(numStr.charAt(i));\n }\n }\n // If the number overflows the maximum allowed digits then use an exponent.\n if (integerLen > MAX_DIGITS) {\n digits = digits.splice(0, MAX_DIGITS - 1);\n exponent = integerLen - 1;\n integerLen = 1;\n }\n return { digits, exponent, integerLen };\n}\n/**\n * Round the parsed number to the specified number of decimal places\n * This function changes the parsedNumber in-place\n */\nfunction roundNumber(parsedNumber, minFrac, maxFrac) {\n if (minFrac > maxFrac) {\n throw new Error(`The minimum number of digits after fraction (${minFrac}) is higher than the maximum (${maxFrac}).`);\n }\n let digits = parsedNumber.digits;\n let fractionLen = digits.length - parsedNumber.integerLen;\n const fractionSize = Math.min(Math.max(minFrac, fractionLen), maxFrac);\n // The index of the digit to where rounding is to occur\n let roundAt = fractionSize + parsedNumber.integerLen;\n let digit = digits[roundAt];\n if (roundAt > 0) {\n // Drop fractional digits beyond `roundAt`\n digits.splice(Math.max(parsedNumber.integerLen, roundAt));\n // Set non-fractional digits beyond `roundAt` to 0\n for (let j = roundAt; j < digits.length; j++) {\n digits[j] = 0;\n }\n }\n else {\n // We rounded to zero so reset the parsedNumber\n fractionLen = Math.max(0, fractionLen);\n parsedNumber.integerLen = 1;\n digits.length = Math.max(1, roundAt = fractionSize + 1);\n digits[0] = 0;\n for (let i = 1; i < roundAt; i++)\n digits[i] = 0;\n }\n if (digit >= 5) {\n if (roundAt - 1 < 0) {\n for (let k = 0; k > roundAt; k--) {\n digits.unshift(0);\n parsedNumber.integerLen++;\n }\n digits.unshift(1);\n parsedNumber.integerLen++;\n }\n else {\n digits[roundAt - 1]++;\n }\n }\n // Pad out with zeros to get the required fraction length\n for (; fractionLen < Math.max(0, fractionSize); fractionLen++)\n digits.push(0);\n let dropTrailingZeros = fractionSize !== 0;\n // Minimal length = nb of decimals required + current nb of integers\n // Any number besides that is optional and can be removed if it's a trailing 0\n const minLen = minFrac + parsedNumber.integerLen;\n // Do any carrying, e.g. a digit was rounded up to 10\n const carry = digits.reduceRight(function (carry, d, i, digits) {\n d = d + carry;\n digits[i] = d < 10 ? d : d - 10; // d % 10\n if (dropTrailingZeros) {\n // Do not keep meaningless fractional trailing zeros (e.g. 15.52000 --> 15.52)\n if (digits[i] === 0 && i >= minLen) {\n digits.pop();\n }\n else {\n dropTrailingZeros = false;\n }\n }\n return d >= 10 ? 1 : 0; // Math.floor(d / 10);\n }, 0);\n if (carry) {\n digits.unshift(carry);\n parsedNumber.integerLen++;\n }\n}\nfunction parseIntAutoRadix(text) {\n const result = parseInt(text);\n if (isNaN(result)) {\n throw new Error('Invalid integer literal when parsing ' + text);\n }\n return result;\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @publicApi\n */\nclass NgLocalization {\n}\nNgLocalization.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgLocalization, deps: [], target: i0.ɵɵFactoryTarget.Injectable });\nNgLocalization.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgLocalization, providedIn: 'root', useFactory: (locale) => new NgLocaleLocalization(locale), deps: [{ token: LOCALE_ID }] });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgLocalization, decorators: [{\n type: Injectable,\n args: [{\n providedIn: 'root',\n useFactory: (locale) => new NgLocaleLocalization(locale),\n deps: [LOCALE_ID],\n }]\n }] });\n/**\n * Returns the plural category for a given value.\n * - \"=value\" when the case exists,\n * - the plural category otherwise\n */\nfunction getPluralCategory(value, cases, ngLocalization, locale) {\n let key = `=${value}`;\n if (cases.indexOf(key) > -1) {\n return key;\n }\n key = ngLocalization.getPluralCategory(value, locale);\n if (cases.indexOf(key) > -1) {\n return key;\n }\n if (cases.indexOf('other') > -1) {\n return 'other';\n }\n throw new Error(`No plural message found for value \"${value}\"`);\n}\n/**\n * Returns the plural case based on the locale\n *\n * @publicApi\n */\nclass NgLocaleLocalization extends NgLocalization {\n constructor(locale) {\n super();\n this.locale = locale;\n }\n getPluralCategory(value, locale) {\n const plural = getLocalePluralCase(locale || this.locale)(value);\n switch (plural) {\n case Plural.Zero:\n return 'zero';\n case Plural.One:\n return 'one';\n case Plural.Two:\n return 'two';\n case Plural.Few:\n return 'few';\n case Plural.Many:\n return 'many';\n default:\n return 'other';\n }\n }\n}\nNgLocaleLocalization.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgLocaleLocalization, deps: [{ token: LOCALE_ID }], target: i0.ɵɵFactoryTarget.Injectable });\nNgLocaleLocalization.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgLocaleLocalization });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgLocaleLocalization, decorators: [{\n type: Injectable\n }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n type: Inject,\n args: [LOCALE_ID]\n }] }]; } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Register global data to be used internally by Angular. See the\n * [\"I18n guide\"](guide/i18n-common-format-data-locale) to know how to import additional locale\n * data.\n *\n * The signature registerLocaleData(data: any, extraData?: any) is deprecated since v5.1\n *\n * @publicApi\n */\nfunction registerLocaleData(data, localeId, extraData) {\n return ɵregisterLocaleData(data, localeId, extraData);\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction parseCookieValue(cookieStr, name) {\n name = encodeURIComponent(name);\n for (const cookie of cookieStr.split(';')) {\n const eqIndex = cookie.indexOf('=');\n const [cookieName, cookieValue] = eqIndex == -1 ? [cookie, ''] : [cookie.slice(0, eqIndex), cookie.slice(eqIndex + 1)];\n if (cookieName.trim() === name) {\n return decodeURIComponent(cookieValue);\n }\n }\n return null;\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @ngModule CommonModule\n *\n * @usageNotes\n * ```\n * ...\n *\n * ...\n *\n * ...\n *\n * ...\n *\n * ...\n * ```\n *\n * @description\n *\n * Adds and removes CSS classes on an HTML element.\n *\n * The CSS classes are updated as follows, depending on the type of the expression evaluation:\n * - `string` - the CSS classes listed in the string (space delimited) are added,\n * - `Array` - the CSS classes declared as Array elements are added,\n * - `Object` - keys are CSS classes that get added when the expression given in the value\n * evaluates to a truthy value, otherwise they are removed.\n *\n * @publicApi\n */\nclass NgClass {\n constructor(_iterableDiffers, _keyValueDiffers, _ngEl, _renderer) {\n this._iterableDiffers = _iterableDiffers;\n this._keyValueDiffers = _keyValueDiffers;\n this._ngEl = _ngEl;\n this._renderer = _renderer;\n this._iterableDiffer = null;\n this._keyValueDiffer = null;\n this._initialClasses = [];\n this._rawClass = null;\n }\n set klass(value) {\n this._removeClasses(this._initialClasses);\n this._initialClasses = typeof value === 'string' ? value.split(/\\s+/) : [];\n this._applyClasses(this._initialClasses);\n this._applyClasses(this._rawClass);\n }\n set ngClass(value) {\n this._removeClasses(this._rawClass);\n this._applyClasses(this._initialClasses);\n this._iterableDiffer = null;\n this._keyValueDiffer = null;\n this._rawClass = typeof value === 'string' ? value.split(/\\s+/) : value;\n if (this._rawClass) {\n if (ɵisListLikeIterable(this._rawClass)) {\n this._iterableDiffer = this._iterableDiffers.find(this._rawClass).create();\n }\n else {\n this._keyValueDiffer = this._keyValueDiffers.find(this._rawClass).create();\n }\n }\n }\n ngDoCheck() {\n if (this._iterableDiffer) {\n const iterableChanges = this._iterableDiffer.diff(this._rawClass);\n if (iterableChanges) {\n this._applyIterableChanges(iterableChanges);\n }\n }\n else if (this._keyValueDiffer) {\n const keyValueChanges = this._keyValueDiffer.diff(this._rawClass);\n if (keyValueChanges) {\n this._applyKeyValueChanges(keyValueChanges);\n }\n }\n }\n _applyKeyValueChanges(changes) {\n changes.forEachAddedItem((record) => this._toggleClass(record.key, record.currentValue));\n changes.forEachChangedItem((record) => this._toggleClass(record.key, record.currentValue));\n changes.forEachRemovedItem((record) => {\n if (record.previousValue) {\n this._toggleClass(record.key, false);\n }\n });\n }\n _applyIterableChanges(changes) {\n changes.forEachAddedItem((record) => {\n if (typeof record.item === 'string') {\n this._toggleClass(record.item, true);\n }\n else {\n throw new Error(`NgClass can only toggle CSS classes expressed as strings, got ${ɵstringify(record.item)}`);\n }\n });\n changes.forEachRemovedItem((record) => this._toggleClass(record.item, false));\n }\n /**\n * Applies a collection of CSS classes to the DOM element.\n *\n * For argument of type Set and Array CSS class names contained in those collections are always\n * added.\n * For argument of type Map CSS class name in the map's key is toggled based on the value (added\n * for truthy and removed for falsy).\n */\n _applyClasses(rawClassVal) {\n if (rawClassVal) {\n if (Array.isArray(rawClassVal) || rawClassVal instanceof Set) {\n rawClassVal.forEach((klass) => this._toggleClass(klass, true));\n }\n else {\n Object.keys(rawClassVal).forEach(klass => this._toggleClass(klass, !!rawClassVal[klass]));\n }\n }\n }\n /**\n * Removes a collection of CSS classes from the DOM element. This is mostly useful for cleanup\n * purposes.\n */\n _removeClasses(rawClassVal) {\n if (rawClassVal) {\n if (Array.isArray(rawClassVal) || rawClassVal instanceof Set) {\n rawClassVal.forEach((klass) => this._toggleClass(klass, false));\n }\n else {\n Object.keys(rawClassVal).forEach(klass => this._toggleClass(klass, false));\n }\n }\n }\n _toggleClass(klass, enabled) {\n klass = klass.trim();\n if (klass) {\n klass.split(/\\s+/g).forEach(klass => {\n if (enabled) {\n this._renderer.addClass(this._ngEl.nativeElement, klass);\n }\n else {\n this._renderer.removeClass(this._ngEl.nativeElement, klass);\n }\n });\n }\n }\n}\nNgClass.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgClass, deps: [{ token: i0.IterableDiffers }, { token: i0.KeyValueDiffers }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });\nNgClass.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.12\", type: NgClass, selector: \"[ngClass]\", inputs: { klass: [\"class\", \"klass\"], ngClass: \"ngClass\" }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgClass, decorators: [{\n type: Directive,\n args: [{ selector: '[ngClass]' }]\n }], ctorParameters: function () { return [{ type: i0.IterableDiffers }, { type: i0.KeyValueDiffers }, { type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { klass: [{\n type: Input,\n args: ['class']\n }], ngClass: [{\n type: Input,\n args: ['ngClass']\n }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Instantiates a {@link Component} type and inserts its Host View into the current View.\n * `NgComponentOutlet` provides a declarative approach for dynamic component creation.\n *\n * `NgComponentOutlet` requires a component type, if a falsy value is set the view will clear and\n * any existing component will be destroyed.\n *\n * @usageNotes\n *\n * ### Fine tune control\n *\n * You can control the component creation process by using the following optional attributes:\n *\n * * `ngComponentOutletInjector`: Optional custom {@link Injector} that will be used as parent for\n * the Component. Defaults to the injector of the current view container.\n *\n * * `ngComponentOutletContent`: Optional list of projectable nodes to insert into the content\n * section of the component, if it exists.\n *\n * * `ngComponentOutletNgModuleFactory`: Optional module factory to allow loading another\n * module dynamically, then loading a component from that module.\n *\n * ### Syntax\n *\n * Simple\n * ```\n * \n * ```\n *\n * Customized injector/content\n * ```\n * \n * \n * ```\n *\n * Customized ngModuleFactory\n * ```\n * \n * \n * ```\n *\n * ### A simple example\n *\n * {@example common/ngComponentOutlet/ts/module.ts region='SimpleExample'}\n *\n * A more complete example with additional options:\n *\n * {@example common/ngComponentOutlet/ts/module.ts region='CompleteExample'}\n *\n * @publicApi\n * @ngModule CommonModule\n */\nclass NgComponentOutlet {\n constructor(_viewContainerRef) {\n this._viewContainerRef = _viewContainerRef;\n this._componentRef = null;\n this._moduleRef = null;\n }\n /** @nodoc */\n ngOnChanges(changes) {\n this._viewContainerRef.clear();\n this._componentRef = null;\n if (this.ngComponentOutlet) {\n const elInjector = this.ngComponentOutletInjector || this._viewContainerRef.parentInjector;\n if (changes['ngComponentOutletNgModuleFactory']) {\n if (this._moduleRef)\n this._moduleRef.destroy();\n if (this.ngComponentOutletNgModuleFactory) {\n const parentModule = elInjector.get(NgModuleRef);\n this._moduleRef = this.ngComponentOutletNgModuleFactory.create(parentModule.injector);\n }\n else {\n this._moduleRef = null;\n }\n }\n const componentFactoryResolver = this._moduleRef ? this._moduleRef.componentFactoryResolver :\n elInjector.get(ComponentFactoryResolver);\n const componentFactory = componentFactoryResolver.resolveComponentFactory(this.ngComponentOutlet);\n this._componentRef = this._viewContainerRef.createComponent(componentFactory, this._viewContainerRef.length, elInjector, this.ngComponentOutletContent);\n }\n }\n /** @nodoc */\n ngOnDestroy() {\n if (this._moduleRef)\n this._moduleRef.destroy();\n }\n}\nNgComponentOutlet.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgComponentOutlet, deps: [{ token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });\nNgComponentOutlet.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.12\", type: NgComponentOutlet, selector: \"[ngComponentOutlet]\", inputs: { ngComponentOutlet: \"ngComponentOutlet\", ngComponentOutletInjector: \"ngComponentOutletInjector\", ngComponentOutletContent: \"ngComponentOutletContent\", ngComponentOutletNgModuleFactory: \"ngComponentOutletNgModuleFactory\" }, usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgComponentOutlet, decorators: [{\n type: Directive,\n args: [{ selector: '[ngComponentOutlet]' }]\n }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }]; }, propDecorators: { ngComponentOutlet: [{\n type: Input\n }], ngComponentOutletInjector: [{\n type: Input\n }], ngComponentOutletContent: [{\n type: Input\n }], ngComponentOutletNgModuleFactory: [{\n type: Input\n }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @publicApi\n */\nclass NgForOfContext {\n constructor($implicit, ngForOf, index, count) {\n this.$implicit = $implicit;\n this.ngForOf = ngForOf;\n this.index = index;\n this.count = count;\n }\n get first() {\n return this.index === 0;\n }\n get last() {\n return this.index === this.count - 1;\n }\n get even() {\n return this.index % 2 === 0;\n }\n get odd() {\n return !this.even;\n }\n}\n/**\n * A [structural directive](guide/structural-directives) that renders\n * a template for each item in a collection.\n * The directive is placed on an element, which becomes the parent\n * of the cloned templates.\n *\n * The `ngForOf` directive is generally used in the\n * [shorthand form](guide/structural-directives#asterisk) `*ngFor`.\n * In this form, the template to be rendered for each iteration is the content\n * of an anchor element containing the directive.\n *\n * The following example shows the shorthand syntax with some options,\n * contained in an `
  • ` element.\n *\n * ```\n *
  • ...
  • \n * ```\n *\n * The shorthand form expands into a long form that uses the `ngForOf` selector\n * on an `` element.\n * The content of the `` element is the `
  • ` element that held the\n * short-form directive.\n *\n * Here is the expanded version of the short-form example.\n *\n * ```\n * \n *
  • ...
  • \n *
    \n * ```\n *\n * Angular automatically expands the shorthand syntax as it compiles the template.\n * The context for each embedded view is logically merged to the current component\n * context according to its lexical position.\n *\n * When using the shorthand syntax, Angular allows only [one structural directive\n * on an element](guide/structural-directives#one-per-element).\n * If you want to iterate conditionally, for example,\n * put the `*ngIf` on a container element that wraps the `*ngFor` element.\n * For futher discussion, see\n * [Structural Directives](guide/structural-directives#one-per-element).\n *\n * @usageNotes\n *\n * ### Local variables\n *\n * `NgForOf` provides exported values that can be aliased to local variables.\n * For example:\n *\n * ```\n *
  • \n * {{i}}/{{users.length}}. {{user}} default\n *
  • \n * ```\n *\n * The following exported values can be aliased to local variables:\n *\n * - `$implicit: T`: The value of the individual items in the iterable (`ngForOf`).\n * - `ngForOf: NgIterable`: The value of the iterable expression. Useful when the expression is\n * more complex then a property access, for example when using the async pipe (`userStreams |\n * async`).\n * - `index: number`: The index of the current item in the iterable.\n * - `count: number`: The length of the iterable.\n * - `first: boolean`: True when the item is the first item in the iterable.\n * - `last: boolean`: True when the item is the last item in the iterable.\n * - `even: boolean`: True when the item has an even index in the iterable.\n * - `odd: boolean`: True when the item has an odd index in the iterable.\n *\n * ### Change propagation\n *\n * When the contents of the iterator changes, `NgForOf` makes the corresponding changes to the DOM:\n *\n * * When an item is added, a new instance of the template is added to the DOM.\n * * When an item is removed, its template instance is removed from the DOM.\n * * When items are reordered, their respective templates are reordered in the DOM.\n *\n * Angular uses object identity to track insertions and deletions within the iterator and reproduce\n * those changes in the DOM. This has important implications for animations and any stateful\n * controls that are present, such as `` elements that accept user input. Inserted rows can\n * be animated in, deleted rows can be animated out, and unchanged rows retain any unsaved state\n * such as user input.\n * For more on animations, see [Transitions and Triggers](guide/transition-and-triggers).\n *\n * The identities of elements in the iterator can change while the data does not.\n * This can happen, for example, if the iterator is produced from an RPC to the server, and that\n * RPC is re-run. Even if the data hasn't changed, the second response produces objects with\n * different identities, and Angular must tear down the entire DOM and rebuild it (as if all old\n * elements were deleted and all new elements inserted).\n *\n * To avoid this expensive operation, you can customize the default tracking algorithm.\n * by supplying the `trackBy` option to `NgForOf`.\n * `trackBy` takes a function that has two arguments: `index` and `item`.\n * If `trackBy` is given, Angular tracks changes by the return value of the function.\n *\n * @see [Structural Directives](guide/structural-directives)\n * @ngModule CommonModule\n * @publicApi\n */\nclass NgForOf {\n constructor(_viewContainer, _template, _differs) {\n this._viewContainer = _viewContainer;\n this._template = _template;\n this._differs = _differs;\n this._ngForOf = null;\n this._ngForOfDirty = true;\n this._differ = null;\n }\n /**\n * The value of the iterable expression, which can be used as a\n * [template input variable](guide/structural-directives#shorthand).\n */\n set ngForOf(ngForOf) {\n this._ngForOf = ngForOf;\n this._ngForOfDirty = true;\n }\n /**\n * Specifies a custom `TrackByFunction` to compute the identity of items in an iterable.\n *\n * If a custom `TrackByFunction` is not provided, `NgForOf` will use the item's [object\n * identity](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is)\n * as the key.\n *\n * `NgForOf` uses the computed key to associate items in an iterable with DOM elements\n * it produces for these items.\n *\n * A custom `TrackByFunction` is useful to provide good user experience in cases when items in an\n * iterable rendered using `NgForOf` have a natural identifier (for example, custom ID or a\n * primary key), and this iterable could be updated with new object instances that still\n * represent the same underlying entity (for example, when data is re-fetched from the server,\n * and the iterable is recreated and re-rendered, but most of the data is still the same).\n *\n * @see `TrackByFunction`\n */\n set ngForTrackBy(fn) {\n if ((typeof ngDevMode === 'undefined' || ngDevMode) && fn != null && typeof fn !== 'function') {\n // TODO(vicb): use a log service once there is a public one available\n if (console && console.warn) {\n console.warn(`trackBy must be a function, but received ${JSON.stringify(fn)}. ` +\n `See https://angular.io/api/common/NgForOf#change-propagation for more information.`);\n }\n }\n this._trackByFn = fn;\n }\n get ngForTrackBy() {\n return this._trackByFn;\n }\n /**\n * A reference to the template that is stamped out for each item in the iterable.\n * @see [template reference variable](guide/template-reference-variables)\n */\n set ngForTemplate(value) {\n // TODO(TS2.1): make TemplateRef>> once we move to TS v2.1\n // The current type is too restrictive; a template that just uses index, for example,\n // should be acceptable.\n if (value) {\n this._template = value;\n }\n }\n /**\n * Applies the changes when needed.\n * @nodoc\n */\n ngDoCheck() {\n if (this._ngForOfDirty) {\n this._ngForOfDirty = false;\n // React on ngForOf changes only once all inputs have been initialized\n const value = this._ngForOf;\n if (!this._differ && value) {\n if (typeof ngDevMode === 'undefined' || ngDevMode) {\n try {\n // CAUTION: this logic is duplicated for production mode below, as the try-catch\n // is only present in development builds.\n this._differ = this._differs.find(value).create(this.ngForTrackBy);\n }\n catch {\n throw new Error(`Cannot find a differ supporting object '${value}' of type '${getTypeName(value)}'. NgFor only supports binding to Iterables such as Arrays.`);\n }\n }\n else {\n // CAUTION: this logic is duplicated for development mode above, as the try-catch\n // is only present in development builds.\n this._differ = this._differs.find(value).create(this.ngForTrackBy);\n }\n }\n }\n if (this._differ) {\n const changes = this._differ.diff(this._ngForOf);\n if (changes)\n this._applyChanges(changes);\n }\n }\n _applyChanges(changes) {\n const viewContainer = this._viewContainer;\n changes.forEachOperation((item, adjustedPreviousIndex, currentIndex) => {\n if (item.previousIndex == null) {\n // NgForOf is never \"null\" or \"undefined\" here because the differ detected\n // that a new item needs to be inserted from the iterable. This implies that\n // there is an iterable value for \"_ngForOf\".\n viewContainer.createEmbeddedView(this._template, new NgForOfContext(item.item, this._ngForOf, -1, -1), currentIndex === null ? undefined : currentIndex);\n }\n else if (currentIndex == null) {\n viewContainer.remove(adjustedPreviousIndex === null ? undefined : adjustedPreviousIndex);\n }\n else if (adjustedPreviousIndex !== null) {\n const view = viewContainer.get(adjustedPreviousIndex);\n viewContainer.move(view, currentIndex);\n applyViewChange(view, item);\n }\n });\n for (let i = 0, ilen = viewContainer.length; i < ilen; i++) {\n const viewRef = viewContainer.get(i);\n const context = viewRef.context;\n context.index = i;\n context.count = ilen;\n context.ngForOf = this._ngForOf;\n }\n changes.forEachIdentityChange((record) => {\n const viewRef = viewContainer.get(record.currentIndex);\n applyViewChange(viewRef, record);\n });\n }\n /**\n * Asserts the correct type of the context for the template that `NgForOf` will render.\n *\n * The presence of this method is a signal to the Ivy template type-check compiler that the\n * `NgForOf` structural directive renders its template with a specific context type.\n */\n static ngTemplateContextGuard(dir, ctx) {\n return true;\n }\n}\nNgForOf.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgForOf, deps: [{ token: i0.ViewContainerRef }, { token: i0.TemplateRef }, { token: i0.IterableDiffers }], target: i0.ɵɵFactoryTarget.Directive });\nNgForOf.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.12\", type: NgForOf, selector: \"[ngFor][ngForOf]\", inputs: { ngForOf: \"ngForOf\", ngForTrackBy: \"ngForTrackBy\", ngForTemplate: \"ngForTemplate\" }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgForOf, decorators: [{\n type: Directive,\n args: [{ selector: '[ngFor][ngForOf]' }]\n }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.TemplateRef }, { type: i0.IterableDiffers }]; }, propDecorators: { ngForOf: [{\n type: Input\n }], ngForTrackBy: [{\n type: Input\n }], ngForTemplate: [{\n type: Input\n }] } });\nfunction applyViewChange(view, record) {\n view.context.$implicit = record.item;\n}\nfunction getTypeName(type) {\n return type['name'] || typeof type;\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A structural directive that conditionally includes a template based on the value of\n * an expression coerced to Boolean.\n * When the expression evaluates to true, Angular renders the template\n * provided in a `then` clause, and when false or null,\n * Angular renders the template provided in an optional `else` clause. The default\n * template for the `else` clause is blank.\n *\n * A [shorthand form](guide/structural-directives#asterisk) of the directive,\n * `*ngIf=\"condition\"`, is generally used, provided\n * as an attribute of the anchor element for the inserted template.\n * Angular expands this into a more explicit version, in which the anchor element\n * is contained in an `` element.\n *\n * Simple form with shorthand syntax:\n *\n * ```\n *
    Content to render when condition is true.
    \n * ```\n *\n * Simple form with expanded syntax:\n *\n * ```\n *
    Content to render when condition is\n * true.
    \n * ```\n *\n * Form with an \"else\" block:\n *\n * ```\n *
    Content to render when condition is true.
    \n * Content to render when condition is false.\n * ```\n *\n * Shorthand form with \"then\" and \"else\" blocks:\n *\n * ```\n *
    \n * Content to render when condition is true.\n * Content to render when condition is false.\n * ```\n *\n * Form with storing the value locally:\n *\n * ```\n *
    {{value}}
    \n * Content to render when value is null.\n * ```\n *\n * @usageNotes\n *\n * The `*ngIf` directive is most commonly used to conditionally show an inline template,\n * as seen in the following example.\n * The default `else` template is blank.\n *\n * {@example common/ngIf/ts/module.ts region='NgIfSimple'}\n *\n * ### Showing an alternative template using `else`\n *\n * To display a template when `expression` evaluates to false, use an `else` template\n * binding as shown in the following example.\n * The `else` binding points to an `` element labeled `#elseBlock`.\n * The template can be defined anywhere in the component view, but is typically placed right after\n * `ngIf` for readability.\n *\n * {@example common/ngIf/ts/module.ts region='NgIfElse'}\n *\n * ### Using an external `then` template\n *\n * In the previous example, the then-clause template is specified inline, as the content of the\n * tag that contains the `ngIf` directive. You can also specify a template that is defined\n * externally, by referencing a labeled `` element. When you do this, you can\n * change which template to use at runtime, as shown in the following example.\n *\n * {@example common/ngIf/ts/module.ts region='NgIfThenElse'}\n *\n * ### Storing a conditional result in a variable\n *\n * You might want to show a set of properties from the same object. If you are waiting\n * for asynchronous data, the object can be undefined.\n * In this case, you can use `ngIf` and store the result of the condition in a local\n * variable as shown in the following example.\n *\n * {@example common/ngIf/ts/module.ts region='NgIfAs'}\n *\n * This code uses only one `AsyncPipe`, so only one subscription is created.\n * The conditional statement stores the result of `userStream|async` in the local variable `user`.\n * You can then bind the local `user` repeatedly.\n *\n * The conditional displays the data only if `userStream` returns a value,\n * so you don't need to use the\n * safe-navigation-operator (`?.`)\n * to guard against null values when accessing properties.\n * You can display an alternative template while waiting for the data.\n *\n * ### Shorthand syntax\n *\n * The shorthand syntax `*ngIf` expands into two separate template specifications\n * for the \"then\" and \"else\" clauses. For example, consider the following shorthand statement,\n * that is meant to show a loading page while waiting for data to be loaded.\n *\n * ```\n *
    \n * ...\n *
    \n *\n * \n *
    Loading...
    \n *
    \n * ```\n *\n * You can see that the \"else\" clause references the ``\n * with the `#loading` label, and the template for the \"then\" clause\n * is provided as the content of the anchor element.\n *\n * However, when Angular expands the shorthand syntax, it creates\n * another `` tag, with `ngIf` and `ngIfElse` directives.\n * The anchor element containing the template for the \"then\" clause becomes\n * the content of this unlabeled `` tag.\n *\n * ```\n * \n *
    \n * ...\n *
    \n *
    \n *\n * \n *
    Loading...
    \n *
    \n * ```\n *\n * The presence of the implicit template object has implications for the nesting of\n * structural directives. For more on this subject, see\n * [Structural Directives](guide/structural-directives#one-per-element).\n *\n * @ngModule CommonModule\n * @publicApi\n */\nclass NgIf {\n constructor(_viewContainer, templateRef) {\n this._viewContainer = _viewContainer;\n this._context = new NgIfContext();\n this._thenTemplateRef = null;\n this._elseTemplateRef = null;\n this._thenViewRef = null;\n this._elseViewRef = null;\n this._thenTemplateRef = templateRef;\n }\n /**\n * The Boolean expression to evaluate as the condition for showing a template.\n */\n set ngIf(condition) {\n this._context.$implicit = this._context.ngIf = condition;\n this._updateView();\n }\n /**\n * A template to show if the condition expression evaluates to true.\n */\n set ngIfThen(templateRef) {\n assertTemplate('ngIfThen', templateRef);\n this._thenTemplateRef = templateRef;\n this._thenViewRef = null; // clear previous view if any.\n this._updateView();\n }\n /**\n * A template to show if the condition expression evaluates to false.\n */\n set ngIfElse(templateRef) {\n assertTemplate('ngIfElse', templateRef);\n this._elseTemplateRef = templateRef;\n this._elseViewRef = null; // clear previous view if any.\n this._updateView();\n }\n _updateView() {\n if (this._context.$implicit) {\n if (!this._thenViewRef) {\n this._viewContainer.clear();\n this._elseViewRef = null;\n if (this._thenTemplateRef) {\n this._thenViewRef =\n this._viewContainer.createEmbeddedView(this._thenTemplateRef, this._context);\n }\n }\n }\n else {\n if (!this._elseViewRef) {\n this._viewContainer.clear();\n this._thenViewRef = null;\n if (this._elseTemplateRef) {\n this._elseViewRef =\n this._viewContainer.createEmbeddedView(this._elseTemplateRef, this._context);\n }\n }\n }\n }\n /**\n * Asserts the correct type of the context for the template that `NgIf` will render.\n *\n * The presence of this method is a signal to the Ivy template type-check compiler that the\n * `NgIf` structural directive renders its template with a specific context type.\n */\n static ngTemplateContextGuard(dir, ctx) {\n return true;\n }\n}\nNgIf.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgIf, deps: [{ token: i0.ViewContainerRef }, { token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });\nNgIf.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.12\", type: NgIf, selector: \"[ngIf]\", inputs: { ngIf: \"ngIf\", ngIfThen: \"ngIfThen\", ngIfElse: \"ngIfElse\" }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgIf, decorators: [{\n type: Directive,\n args: [{ selector: '[ngIf]' }]\n }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.TemplateRef }]; }, propDecorators: { ngIf: [{\n type: Input\n }], ngIfThen: [{\n type: Input\n }], ngIfElse: [{\n type: Input\n }] } });\n/**\n * @publicApi\n */\nclass NgIfContext {\n constructor() {\n this.$implicit = null;\n this.ngIf = null;\n }\n}\nfunction assertTemplate(property, templateRef) {\n const isTemplateRefOrNull = !!(!templateRef || templateRef.createEmbeddedView);\n if (!isTemplateRefOrNull) {\n throw new Error(`${property} must be a TemplateRef, but received '${ɵstringify(templateRef)}'.`);\n }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass SwitchView {\n constructor(_viewContainerRef, _templateRef) {\n this._viewContainerRef = _viewContainerRef;\n this._templateRef = _templateRef;\n this._created = false;\n }\n create() {\n this._created = true;\n this._viewContainerRef.createEmbeddedView(this._templateRef);\n }\n destroy() {\n this._created = false;\n this._viewContainerRef.clear();\n }\n enforceState(created) {\n if (created && !this._created) {\n this.create();\n }\n else if (!created && this._created) {\n this.destroy();\n }\n }\n}\n/**\n * @ngModule CommonModule\n *\n * @description\n * The `[ngSwitch]` directive on a container specifies an expression to match against.\n * The expressions to match are provided by `ngSwitchCase` directives on views within the container.\n * - Every view that matches is rendered.\n * - If there are no matches, a view with the `ngSwitchDefault` directive is rendered.\n * - Elements within the `[NgSwitch]` statement but outside of any `NgSwitchCase`\n * or `ngSwitchDefault` directive are preserved at the location.\n *\n * @usageNotes\n * Define a container element for the directive, and specify the switch expression\n * to match against as an attribute:\n *\n * ```\n * \n * ```\n *\n * Within the container, `*ngSwitchCase` statements specify the match expressions\n * as attributes. Include `*ngSwitchDefault` as the final case.\n *\n * ```\n * \n * ...\n * ...\n * ...\n * \n * ```\n *\n * ### Usage Examples\n *\n * The following example shows how to use more than one case to display the same view:\n *\n * ```\n * \n * \n * ...\n * ...\n * ...\n * \n * ...\n * \n * ```\n *\n * The following example shows how cases can be nested:\n * ```\n * \n * ...\n * ...\n * ...\n * \n * \n * \n * \n * \n * ...\n * \n * ```\n *\n * @publicApi\n * @see `NgSwitchCase`\n * @see `NgSwitchDefault`\n * @see [Structural Directives](guide/structural-directives)\n *\n */\nclass NgSwitch {\n constructor() {\n this._defaultUsed = false;\n this._caseCount = 0;\n this._lastCaseCheckIndex = 0;\n this._lastCasesMatched = false;\n }\n set ngSwitch(newValue) {\n this._ngSwitch = newValue;\n if (this._caseCount === 0) {\n this._updateDefaultCases(true);\n }\n }\n /** @internal */\n _addCase() {\n return this._caseCount++;\n }\n /** @internal */\n _addDefault(view) {\n if (!this._defaultViews) {\n this._defaultViews = [];\n }\n this._defaultViews.push(view);\n }\n /** @internal */\n _matchCase(value) {\n const matched = value == this._ngSwitch;\n this._lastCasesMatched = this._lastCasesMatched || matched;\n this._lastCaseCheckIndex++;\n if (this._lastCaseCheckIndex === this._caseCount) {\n this._updateDefaultCases(!this._lastCasesMatched);\n this._lastCaseCheckIndex = 0;\n this._lastCasesMatched = false;\n }\n return matched;\n }\n _updateDefaultCases(useDefault) {\n if (this._defaultViews && useDefault !== this._defaultUsed) {\n this._defaultUsed = useDefault;\n for (let i = 0; i < this._defaultViews.length; i++) {\n const defaultView = this._defaultViews[i];\n defaultView.enforceState(useDefault);\n }\n }\n }\n}\nNgSwitch.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgSwitch, deps: [], target: i0.ɵɵFactoryTarget.Directive });\nNgSwitch.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.12\", type: NgSwitch, selector: \"[ngSwitch]\", inputs: { ngSwitch: \"ngSwitch\" }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgSwitch, decorators: [{\n type: Directive,\n args: [{ selector: '[ngSwitch]' }]\n }], propDecorators: { ngSwitch: [{\n type: Input\n }] } });\n/**\n * @ngModule CommonModule\n *\n * @description\n * Provides a switch case expression to match against an enclosing `ngSwitch` expression.\n * When the expressions match, the given `NgSwitchCase` template is rendered.\n * If multiple match expressions match the switch expression value, all of them are displayed.\n *\n * @usageNotes\n *\n * Within a switch container, `*ngSwitchCase` statements specify the match expressions\n * as attributes. Include `*ngSwitchDefault` as the final case.\n *\n * ```\n * \n * ...\n * ...\n * ...\n * \n * ```\n *\n * Each switch-case statement contains an in-line HTML template or template reference\n * that defines the subtree to be selected if the value of the match expression\n * matches the value of the switch expression.\n *\n * Unlike JavaScript, which uses strict equality, Angular uses loose equality.\n * This means that the empty string, `\"\"` matches 0.\n *\n * @publicApi\n * @see `NgSwitch`\n * @see `NgSwitchDefault`\n *\n */\nclass NgSwitchCase {\n constructor(viewContainer, templateRef, ngSwitch) {\n this.ngSwitch = ngSwitch;\n if ((typeof ngDevMode === 'undefined' || ngDevMode) && !ngSwitch) {\n throwNgSwitchProviderNotFoundError('ngSwitchCase', 'NgSwitchCase');\n }\n ngSwitch._addCase();\n this._view = new SwitchView(viewContainer, templateRef);\n }\n /**\n * Performs case matching. For internal use only.\n * @nodoc\n */\n ngDoCheck() {\n this._view.enforceState(this.ngSwitch._matchCase(this.ngSwitchCase));\n }\n}\nNgSwitchCase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgSwitchCase, deps: [{ token: i0.ViewContainerRef }, { token: i0.TemplateRef }, { token: NgSwitch, host: true, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nNgSwitchCase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.12\", type: NgSwitchCase, selector: \"[ngSwitchCase]\", inputs: { ngSwitchCase: \"ngSwitchCase\" }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgSwitchCase, decorators: [{\n type: Directive,\n args: [{ selector: '[ngSwitchCase]' }]\n }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.TemplateRef }, { type: NgSwitch, decorators: [{\n type: Optional\n }, {\n type: Host\n }] }]; }, propDecorators: { ngSwitchCase: [{\n type: Input\n }] } });\n/**\n * @ngModule CommonModule\n *\n * @description\n *\n * Creates a view that is rendered when no `NgSwitchCase` expressions\n * match the `NgSwitch` expression.\n * This statement should be the final case in an `NgSwitch`.\n *\n * @publicApi\n * @see `NgSwitch`\n * @see `NgSwitchCase`\n *\n */\nclass NgSwitchDefault {\n constructor(viewContainer, templateRef, ngSwitch) {\n if ((typeof ngDevMode === 'undefined' || ngDevMode) && !ngSwitch) {\n throwNgSwitchProviderNotFoundError('ngSwitchDefault', 'NgSwitchDefault');\n }\n ngSwitch._addDefault(new SwitchView(viewContainer, templateRef));\n }\n}\nNgSwitchDefault.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgSwitchDefault, deps: [{ token: i0.ViewContainerRef }, { token: i0.TemplateRef }, { token: NgSwitch, host: true, optional: true }], target: i0.ɵɵFactoryTarget.Directive });\nNgSwitchDefault.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.12\", type: NgSwitchDefault, selector: \"[ngSwitchDefault]\", ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgSwitchDefault, decorators: [{\n type: Directive,\n args: [{ selector: '[ngSwitchDefault]' }]\n }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.TemplateRef }, { type: NgSwitch, decorators: [{\n type: Optional\n }, {\n type: Host\n }] }]; } });\nfunction throwNgSwitchProviderNotFoundError(attrName, directiveName) {\n throw new ɵRuntimeError(2000 /* PARENT_NG_SWITCH_NOT_FOUND */, `An element with the \"${attrName}\" attribute ` +\n `(matching the \"${directiveName}\" directive) must be located inside an element with the \"ngSwitch\" attribute ` +\n `(matching \"NgSwitch\" directive)`);\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @ngModule CommonModule\n *\n * @usageNotes\n * ```\n * \n * there is nothing\n * there is one\n * there are a few\n * \n * ```\n *\n * @description\n *\n * Adds / removes DOM sub-trees based on a numeric value. Tailored for pluralization.\n *\n * Displays DOM sub-trees that match the switch expression value, or failing that, DOM sub-trees\n * that match the switch expression's pluralization category.\n *\n * To use this directive you must provide a container element that sets the `[ngPlural]` attribute\n * to a switch expression. Inner elements with a `[ngPluralCase]` will display based on their\n * expression:\n * - if `[ngPluralCase]` is set to a value starting with `=`, it will only display if the value\n * matches the switch expression exactly,\n * - otherwise, the view will be treated as a \"category match\", and will only display if exact\n * value matches aren't found and the value maps to its category for the defined locale.\n *\n * See http://cldr.unicode.org/index/cldr-spec/plural-rules\n *\n * @publicApi\n */\nclass NgPlural {\n constructor(_localization) {\n this._localization = _localization;\n this._caseViews = {};\n }\n set ngPlural(value) {\n this._switchValue = value;\n this._updateView();\n }\n addCase(value, switchView) {\n this._caseViews[value] = switchView;\n }\n _updateView() {\n this._clearViews();\n const cases = Object.keys(this._caseViews);\n const key = getPluralCategory(this._switchValue, cases, this._localization);\n this._activateView(this._caseViews[key]);\n }\n _clearViews() {\n if (this._activeView)\n this._activeView.destroy();\n }\n _activateView(view) {\n if (view) {\n this._activeView = view;\n this._activeView.create();\n }\n }\n}\nNgPlural.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgPlural, deps: [{ token: NgLocalization }], target: i0.ɵɵFactoryTarget.Directive });\nNgPlural.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.12\", type: NgPlural, selector: \"[ngPlural]\", inputs: { ngPlural: \"ngPlural\" }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgPlural, decorators: [{\n type: Directive,\n args: [{ selector: '[ngPlural]' }]\n }], ctorParameters: function () { return [{ type: NgLocalization }]; }, propDecorators: { ngPlural: [{\n type: Input\n }] } });\n/**\n * @ngModule CommonModule\n *\n * @description\n *\n * Creates a view that will be added/removed from the parent {@link NgPlural} when the\n * given expression matches the plural expression according to CLDR rules.\n *\n * @usageNotes\n * ```\n * \n * ...\n * ...\n * \n *```\n *\n * See {@link NgPlural} for more details and example.\n *\n * @publicApi\n */\nclass NgPluralCase {\n constructor(value, template, viewContainer, ngPlural) {\n this.value = value;\n const isANumber = !isNaN(Number(value));\n ngPlural.addCase(isANumber ? `=${value}` : value, new SwitchView(viewContainer, template));\n }\n}\nNgPluralCase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgPluralCase, deps: [{ token: 'ngPluralCase', attribute: true }, { token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: NgPlural, host: true }], target: i0.ɵɵFactoryTarget.Directive });\nNgPluralCase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.12\", type: NgPluralCase, selector: \"[ngPluralCase]\", ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgPluralCase, decorators: [{\n type: Directive,\n args: [{ selector: '[ngPluralCase]' }]\n }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n type: Attribute,\n args: ['ngPluralCase']\n }] }, { type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: NgPlural, decorators: [{\n type: Host\n }] }]; } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @ngModule CommonModule\n *\n * @usageNotes\n *\n * Set the font of the containing element to the result of an expression.\n *\n * ```\n * ...\n * ```\n *\n * Set the width of the containing element to a pixel value returned by an expression.\n *\n * ```\n * ...\n * ```\n *\n * Set a collection of style values using an expression that returns key-value pairs.\n *\n * ```\n * ...\n * ```\n *\n * @description\n *\n * An attribute directive that updates styles for the containing HTML element.\n * Sets one or more style properties, specified as colon-separated key-value pairs.\n * The key is a style name, with an optional `.` suffix\n * (such as 'top.px', 'font-style.em').\n * The value is an expression to be evaluated.\n * The resulting non-null value, expressed in the given unit,\n * is assigned to the given style property.\n * If the result of evaluation is null, the corresponding style is removed.\n *\n * @publicApi\n */\nclass NgStyle {\n constructor(_ngEl, _differs, _renderer) {\n this._ngEl = _ngEl;\n this._differs = _differs;\n this._renderer = _renderer;\n this._ngStyle = null;\n this._differ = null;\n }\n set ngStyle(values) {\n this._ngStyle = values;\n if (!this._differ && values) {\n this._differ = this._differs.find(values).create();\n }\n }\n ngDoCheck() {\n if (this._differ) {\n const changes = this._differ.diff(this._ngStyle);\n if (changes) {\n this._applyChanges(changes);\n }\n }\n }\n _setStyle(nameAndUnit, value) {\n const [name, unit] = nameAndUnit.split('.');\n value = value != null && unit ? `${value}${unit}` : value;\n if (value != null) {\n this._renderer.setStyle(this._ngEl.nativeElement, name, value);\n }\n else {\n this._renderer.removeStyle(this._ngEl.nativeElement, name);\n }\n }\n _applyChanges(changes) {\n changes.forEachRemovedItem((record) => this._setStyle(record.key, null));\n changes.forEachAddedItem((record) => this._setStyle(record.key, record.currentValue));\n changes.forEachChangedItem((record) => this._setStyle(record.key, record.currentValue));\n }\n}\nNgStyle.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgStyle, deps: [{ token: i0.ElementRef }, { token: i0.KeyValueDiffers }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });\nNgStyle.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.12\", type: NgStyle, selector: \"[ngStyle]\", inputs: { ngStyle: \"ngStyle\" }, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgStyle, decorators: [{\n type: Directive,\n args: [{ selector: '[ngStyle]' }]\n }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.KeyValueDiffers }, { type: i0.Renderer2 }]; }, propDecorators: { ngStyle: [{\n type: Input,\n args: ['ngStyle']\n }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @ngModule CommonModule\n *\n * @description\n *\n * Inserts an embedded view from a prepared `TemplateRef`.\n *\n * You can attach a context object to the `EmbeddedViewRef` by setting `[ngTemplateOutletContext]`.\n * `[ngTemplateOutletContext]` should be an object, the object's keys will be available for binding\n * by the local template `let` declarations.\n *\n * @usageNotes\n * ```\n * \n * ```\n *\n * Using the key `$implicit` in the context object will set its value as default.\n *\n * ### Example\n *\n * {@example common/ngTemplateOutlet/ts/module.ts region='NgTemplateOutlet'}\n *\n * @publicApi\n */\nclass NgTemplateOutlet {\n constructor(_viewContainerRef) {\n this._viewContainerRef = _viewContainerRef;\n this._viewRef = null;\n /**\n * A context object to attach to the {@link EmbeddedViewRef}. This should be an\n * object, the object's keys will be available for binding by the local template `let`\n * declarations.\n * Using the key `$implicit` in the context object will set its value as default.\n */\n this.ngTemplateOutletContext = null;\n /**\n * A string defining the template reference and optionally the context object for the template.\n */\n this.ngTemplateOutlet = null;\n }\n /** @nodoc */\n ngOnChanges(changes) {\n if (changes['ngTemplateOutlet']) {\n const viewContainerRef = this._viewContainerRef;\n if (this._viewRef) {\n viewContainerRef.remove(viewContainerRef.indexOf(this._viewRef));\n }\n this._viewRef = this.ngTemplateOutlet ?\n viewContainerRef.createEmbeddedView(this.ngTemplateOutlet, this.ngTemplateOutletContext) :\n null;\n }\n else if (this._viewRef && changes['ngTemplateOutletContext'] && this.ngTemplateOutletContext) {\n this._viewRef.context = this.ngTemplateOutletContext;\n }\n }\n}\nNgTemplateOutlet.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgTemplateOutlet, deps: [{ token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });\nNgTemplateOutlet.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: \"12.0.0\", version: \"13.3.12\", type: NgTemplateOutlet, selector: \"[ngTemplateOutlet]\", inputs: { ngTemplateOutletContext: \"ngTemplateOutletContext\", ngTemplateOutlet: \"ngTemplateOutlet\" }, usesOnChanges: true, ngImport: i0 });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: NgTemplateOutlet, decorators: [{\n type: Directive,\n args: [{ selector: '[ngTemplateOutlet]' }]\n }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }]; }, propDecorators: { ngTemplateOutletContext: [{\n type: Input\n }], ngTemplateOutlet: [{\n type: Input\n }] } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A collection of Angular directives that are likely to be used in each and every Angular\n * application.\n */\nconst COMMON_DIRECTIVES = [\n NgClass,\n NgComponentOutlet,\n NgForOf,\n NgIf,\n NgTemplateOutlet,\n NgStyle,\n NgSwitch,\n NgSwitchCase,\n NgSwitchDefault,\n NgPlural,\n NgPluralCase,\n];\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction invalidPipeArgumentError(type, value) {\n const errorMessage = (typeof ngDevMode === 'undefined' || ngDevMode) ?\n `InvalidPipeArgument: '${value}' for pipe '${ɵstringify(type)}'` :\n '';\n return new ɵRuntimeError(2100 /* INVALID_PIPE_ARGUMENT */, errorMessage);\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass SubscribableStrategy {\n createSubscription(async, updateLatestValue) {\n return async.subscribe({\n next: updateLatestValue,\n error: (e) => {\n throw e;\n }\n });\n }\n dispose(subscription) {\n subscription.unsubscribe();\n }\n onDestroy(subscription) {\n subscription.unsubscribe();\n }\n}\nclass PromiseStrategy {\n createSubscription(async, updateLatestValue) {\n return async.then(updateLatestValue, e => {\n throw e;\n });\n }\n dispose(subscription) { }\n onDestroy(subscription) { }\n}\nconst _promiseStrategy = new PromiseStrategy();\nconst _subscribableStrategy = new SubscribableStrategy();\n/**\n * @ngModule CommonModule\n * @description\n *\n * Unwraps a value from an asynchronous primitive.\n *\n * The `async` pipe subscribes to an `Observable` or `Promise` and returns the latest value it has\n * emitted. When a new value is emitted, the `async` pipe marks the component to be checked for\n * changes. When the component gets destroyed, the `async` pipe unsubscribes automatically to avoid\n * potential memory leaks. When the reference of the expression changes, the `async` pipe\n * automatically unsubscribes from the old `Observable` or `Promise` and subscribes to the new one.\n *\n * @usageNotes\n *\n * ### Examples\n *\n * This example binds a `Promise` to the view. Clicking the `Resolve` button resolves the\n * promise.\n *\n * {@example common/pipes/ts/async_pipe.ts region='AsyncPipePromise'}\n *\n * It's also possible to use `async` with Observables. The example below binds the `time` Observable\n * to the view. The Observable continuously updates the view with the current time.\n *\n * {@example common/pipes/ts/async_pipe.ts region='AsyncPipeObservable'}\n *\n * @publicApi\n */\nclass AsyncPipe {\n constructor(_ref) {\n this._ref = _ref;\n this._latestValue = null;\n this._subscription = null;\n this._obj = null;\n this._strategy = null;\n }\n ngOnDestroy() {\n if (this._subscription) {\n this._dispose();\n }\n }\n transform(obj) {\n if (!this._obj) {\n if (obj) {\n this._subscribe(obj);\n }\n return this._latestValue;\n }\n if (obj !== this._obj) {\n this._dispose();\n return this.transform(obj);\n }\n return this._latestValue;\n }\n _subscribe(obj) {\n this._obj = obj;\n this._strategy = this._selectStrategy(obj);\n this._subscription = this._strategy.createSubscription(obj, (value) => this._updateLatestValue(obj, value));\n }\n _selectStrategy(obj) {\n if (ɵisPromise(obj)) {\n return _promiseStrategy;\n }\n if (ɵisSubscribable(obj)) {\n return _subscribableStrategy;\n }\n throw invalidPipeArgumentError(AsyncPipe, obj);\n }\n _dispose() {\n this._strategy.dispose(this._subscription);\n this._latestValue = null;\n this._subscription = null;\n this._obj = null;\n }\n _updateLatestValue(async, value) {\n if (async === this._obj) {\n this._latestValue = value;\n this._ref.markForCheck();\n }\n }\n}\nAsyncPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: AsyncPipe, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Pipe });\nAsyncPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: AsyncPipe, name: \"async\", pure: false });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: AsyncPipe, decorators: [{\n type: Pipe,\n args: [{ name: 'async', pure: false }]\n }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Transforms text to all lower case.\n *\n * @see `UpperCasePipe`\n * @see `TitleCasePipe`\n * @usageNotes\n *\n * The following example defines a view that allows the user to enter\n * text, and then uses the pipe to convert the input text to all lower case.\n *\n * \n *\n * @ngModule CommonModule\n * @publicApi\n */\nclass LowerCasePipe {\n transform(value) {\n if (value == null)\n return null;\n if (typeof value !== 'string') {\n throw invalidPipeArgumentError(LowerCasePipe, value);\n }\n return value.toLowerCase();\n }\n}\nLowerCasePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: LowerCasePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });\nLowerCasePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: LowerCasePipe, name: \"lowercase\" });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: LowerCasePipe, decorators: [{\n type: Pipe,\n args: [{ name: 'lowercase' }]\n }] });\n//\n// Regex below matches any Unicode word and number compatible with ES5. In ES2018 the same result\n// can be achieved by using /[0-9\\p{L}]\\S*/gu and also known as Unicode Property Escapes\n// (https://2ality.com/2017/07/regexp-unicode-property-escapes.html). Since there is no\n// transpilation of this functionality down to ES5 without external tool, the only solution is\n// to use already transpiled form. Example can be found here -\n// https://mothereff.in/regexpu#input=var+regex+%3D+%2F%5B0-9%5Cp%7BL%7D%5D%5CS*%2Fgu%3B%0A%0A&unicodePropertyEscape=1\n//\nconst unicodeWordMatch = /(?:[0-9A-Za-z\\xAA\\xB5\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0560-\\u0588\\u05D0-\\u05EA\\u05EF-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u0860-\\u086A\\u0870-\\u0887\\u0889-\\u088E\\u08A0-\\u08C9\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u09FC\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0AF9\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58-\\u0C5A\\u0C5D\\u0C60\\u0C61\\u0C80\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D04-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D54-\\u0D56\\u0D5F-\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E86-\\u0E8A\\u0E8C-\\u0EA3\\u0EA5\\u0EA7-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16F1-\\u16F8\\u1700-\\u1711\\u171F-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1878\\u1880-\\u1884\\u1887-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4C\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1C80-\\u1C88\\u1C90-\\u1CBA\\u1CBD-\\u1CBF\\u1CE9-\\u1CEC\\u1CEE-\\u1CF3\\u1CF5\\u1CF6\\u1CFA\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2183\\u2184\\u2C00-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005\\u3006\\u3031-\\u3035\\u303B\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312F\\u3131-\\u318E\\u31A0-\\u31BF\\u31F0-\\u31FF\\u3400-\\u4DBF\\u4E00-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA69D\\uA6A0-\\uA6E5\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7CA\\uA7D0\\uA7D1\\uA7D3\\uA7D5-\\uA7D9\\uA7F2-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA8FD\\uA8FE\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uA9E0-\\uA9E4\\uA9E6-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB69\\uAB70-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]|\\uD800[\\uDC00-\\uDC0B\\uDC0D-\\uDC26\\uDC28-\\uDC3A\\uDC3C\\uDC3D\\uDC3F-\\uDC4D\\uDC50-\\uDC5D\\uDC80-\\uDCFA\\uDE80-\\uDE9C\\uDEA0-\\uDED0\\uDF00-\\uDF1F\\uDF2D-\\uDF40\\uDF42-\\uDF49\\uDF50-\\uDF75\\uDF80-\\uDF9D\\uDFA0-\\uDFC3\\uDFC8-\\uDFCF]|\\uD801[\\uDC00-\\uDC9D\\uDCB0-\\uDCD3\\uDCD8-\\uDCFB\\uDD00-\\uDD27\\uDD30-\\uDD63\\uDD70-\\uDD7A\\uDD7C-\\uDD8A\\uDD8C-\\uDD92\\uDD94\\uDD95\\uDD97-\\uDDA1\\uDDA3-\\uDDB1\\uDDB3-\\uDDB9\\uDDBB\\uDDBC\\uDE00-\\uDF36\\uDF40-\\uDF55\\uDF60-\\uDF67\\uDF80-\\uDF85\\uDF87-\\uDFB0\\uDFB2-\\uDFBA]|\\uD802[\\uDC00-\\uDC05\\uDC08\\uDC0A-\\uDC35\\uDC37\\uDC38\\uDC3C\\uDC3F-\\uDC55\\uDC60-\\uDC76\\uDC80-\\uDC9E\\uDCE0-\\uDCF2\\uDCF4\\uDCF5\\uDD00-\\uDD15\\uDD20-\\uDD39\\uDD80-\\uDDB7\\uDDBE\\uDDBF\\uDE00\\uDE10-\\uDE13\\uDE15-\\uDE17\\uDE19-\\uDE35\\uDE60-\\uDE7C\\uDE80-\\uDE9C\\uDEC0-\\uDEC7\\uDEC9-\\uDEE4\\uDF00-\\uDF35\\uDF40-\\uDF55\\uDF60-\\uDF72\\uDF80-\\uDF91]|\\uD803[\\uDC00-\\uDC48\\uDC80-\\uDCB2\\uDCC0-\\uDCF2\\uDD00-\\uDD23\\uDE80-\\uDEA9\\uDEB0\\uDEB1\\uDF00-\\uDF1C\\uDF27\\uDF30-\\uDF45\\uDF70-\\uDF81\\uDFB0-\\uDFC4\\uDFE0-\\uDFF6]|\\uD804[\\uDC03-\\uDC37\\uDC71\\uDC72\\uDC75\\uDC83-\\uDCAF\\uDCD0-\\uDCE8\\uDD03-\\uDD26\\uDD44\\uDD47\\uDD50-\\uDD72\\uDD76\\uDD83-\\uDDB2\\uDDC1-\\uDDC4\\uDDDA\\uDDDC\\uDE00-\\uDE11\\uDE13-\\uDE2B\\uDE80-\\uDE86\\uDE88\\uDE8A-\\uDE8D\\uDE8F-\\uDE9D\\uDE9F-\\uDEA8\\uDEB0-\\uDEDE\\uDF05-\\uDF0C\\uDF0F\\uDF10\\uDF13-\\uDF28\\uDF2A-\\uDF30\\uDF32\\uDF33\\uDF35-\\uDF39\\uDF3D\\uDF50\\uDF5D-\\uDF61]|\\uD805[\\uDC00-\\uDC34\\uDC47-\\uDC4A\\uDC5F-\\uDC61\\uDC80-\\uDCAF\\uDCC4\\uDCC5\\uDCC7\\uDD80-\\uDDAE\\uDDD8-\\uDDDB\\uDE00-\\uDE2F\\uDE44\\uDE80-\\uDEAA\\uDEB8\\uDF00-\\uDF1A\\uDF40-\\uDF46]|\\uD806[\\uDC00-\\uDC2B\\uDCA0-\\uDCDF\\uDCFF-\\uDD06\\uDD09\\uDD0C-\\uDD13\\uDD15\\uDD16\\uDD18-\\uDD2F\\uDD3F\\uDD41\\uDDA0-\\uDDA7\\uDDAA-\\uDDD0\\uDDE1\\uDDE3\\uDE00\\uDE0B-\\uDE32\\uDE3A\\uDE50\\uDE5C-\\uDE89\\uDE9D\\uDEB0-\\uDEF8]|\\uD807[\\uDC00-\\uDC08\\uDC0A-\\uDC2E\\uDC40\\uDC72-\\uDC8F\\uDD00-\\uDD06\\uDD08\\uDD09\\uDD0B-\\uDD30\\uDD46\\uDD60-\\uDD65\\uDD67\\uDD68\\uDD6A-\\uDD89\\uDD98\\uDEE0-\\uDEF2\\uDFB0]|\\uD808[\\uDC00-\\uDF99]|\\uD809[\\uDC80-\\uDD43]|\\uD80B[\\uDF90-\\uDFF0]|[\\uD80C\\uD81C-\\uD820\\uD822\\uD840-\\uD868\\uD86A-\\uD86C\\uD86F-\\uD872\\uD874-\\uD879\\uD880-\\uD883][\\uDC00-\\uDFFF]|\\uD80D[\\uDC00-\\uDC2E]|\\uD811[\\uDC00-\\uDE46]|\\uD81A[\\uDC00-\\uDE38\\uDE40-\\uDE5E\\uDE70-\\uDEBE\\uDED0-\\uDEED\\uDF00-\\uDF2F\\uDF40-\\uDF43\\uDF63-\\uDF77\\uDF7D-\\uDF8F]|\\uD81B[\\uDE40-\\uDE7F\\uDF00-\\uDF4A\\uDF50\\uDF93-\\uDF9F\\uDFE0\\uDFE1\\uDFE3]|\\uD821[\\uDC00-\\uDFF7]|\\uD823[\\uDC00-\\uDCD5\\uDD00-\\uDD08]|\\uD82B[\\uDFF0-\\uDFF3\\uDFF5-\\uDFFB\\uDFFD\\uDFFE]|\\uD82C[\\uDC00-\\uDD22\\uDD50-\\uDD52\\uDD64-\\uDD67\\uDD70-\\uDEFB]|\\uD82F[\\uDC00-\\uDC6A\\uDC70-\\uDC7C\\uDC80-\\uDC88\\uDC90-\\uDC99]|\\uD835[\\uDC00-\\uDC54\\uDC56-\\uDC9C\\uDC9E\\uDC9F\\uDCA2\\uDCA5\\uDCA6\\uDCA9-\\uDCAC\\uDCAE-\\uDCB9\\uDCBB\\uDCBD-\\uDCC3\\uDCC5-\\uDD05\\uDD07-\\uDD0A\\uDD0D-\\uDD14\\uDD16-\\uDD1C\\uDD1E-\\uDD39\\uDD3B-\\uDD3E\\uDD40-\\uDD44\\uDD46\\uDD4A-\\uDD50\\uDD52-\\uDEA5\\uDEA8-\\uDEC0\\uDEC2-\\uDEDA\\uDEDC-\\uDEFA\\uDEFC-\\uDF14\\uDF16-\\uDF34\\uDF36-\\uDF4E\\uDF50-\\uDF6E\\uDF70-\\uDF88\\uDF8A-\\uDFA8\\uDFAA-\\uDFC2\\uDFC4-\\uDFCB]|\\uD837[\\uDF00-\\uDF1E]|\\uD838[\\uDD00-\\uDD2C\\uDD37-\\uDD3D\\uDD4E\\uDE90-\\uDEAD\\uDEC0-\\uDEEB]|\\uD839[\\uDFE0-\\uDFE6\\uDFE8-\\uDFEB\\uDFED\\uDFEE\\uDFF0-\\uDFFE]|\\uD83A[\\uDC00-\\uDCC4\\uDD00-\\uDD43\\uDD4B]|\\uD83B[\\uDE00-\\uDE03\\uDE05-\\uDE1F\\uDE21\\uDE22\\uDE24\\uDE27\\uDE29-\\uDE32\\uDE34-\\uDE37\\uDE39\\uDE3B\\uDE42\\uDE47\\uDE49\\uDE4B\\uDE4D-\\uDE4F\\uDE51\\uDE52\\uDE54\\uDE57\\uDE59\\uDE5B\\uDE5D\\uDE5F\\uDE61\\uDE62\\uDE64\\uDE67-\\uDE6A\\uDE6C-\\uDE72\\uDE74-\\uDE77\\uDE79-\\uDE7C\\uDE7E\\uDE80-\\uDE89\\uDE8B-\\uDE9B\\uDEA1-\\uDEA3\\uDEA5-\\uDEA9\\uDEAB-\\uDEBB]|\\uD869[\\uDC00-\\uDEDF\\uDF00-\\uDFFF]|\\uD86D[\\uDC00-\\uDF38\\uDF40-\\uDFFF]|\\uD86E[\\uDC00-\\uDC1D\\uDC20-\\uDFFF]|\\uD873[\\uDC00-\\uDEA1\\uDEB0-\\uDFFF]|\\uD87A[\\uDC00-\\uDFE0]|\\uD87E[\\uDC00-\\uDE1D]|\\uD884[\\uDC00-\\uDF4A])\\S*/g;\n/**\n * Transforms text to title case.\n * Capitalizes the first letter of each word and transforms the\n * rest of the word to lower case.\n * Words are delimited by any whitespace character, such as a space, tab, or line-feed character.\n *\n * @see `LowerCasePipe`\n * @see `UpperCasePipe`\n *\n * @usageNotes\n * The following example shows the result of transforming various strings into title case.\n *\n * \n *\n * @ngModule CommonModule\n * @publicApi\n */\nclass TitleCasePipe {\n transform(value) {\n if (value == null)\n return null;\n if (typeof value !== 'string') {\n throw invalidPipeArgumentError(TitleCasePipe, value);\n }\n return value.replace(unicodeWordMatch, (txt => txt[0].toUpperCase() + txt.substr(1).toLowerCase()));\n }\n}\nTitleCasePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: TitleCasePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });\nTitleCasePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: TitleCasePipe, name: \"titlecase\" });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: TitleCasePipe, decorators: [{\n type: Pipe,\n args: [{ name: 'titlecase' }]\n }] });\n/**\n * Transforms text to all upper case.\n * @see `LowerCasePipe`\n * @see `TitleCasePipe`\n *\n * @ngModule CommonModule\n * @publicApi\n */\nclass UpperCasePipe {\n transform(value) {\n if (value == null)\n return null;\n if (typeof value !== 'string') {\n throw invalidPipeArgumentError(UpperCasePipe, value);\n }\n return value.toUpperCase();\n }\n}\nUpperCasePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: UpperCasePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });\nUpperCasePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: UpperCasePipe, name: \"uppercase\" });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: UpperCasePipe, decorators: [{\n type: Pipe,\n args: [{ name: 'uppercase' }]\n }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Optionally-provided default timezone to use for all instances of `DatePipe` (such as `'+0430'`).\n * If the value isn't provided, the `DatePipe` will use the end-user's local system timezone.\n */\nconst DATE_PIPE_DEFAULT_TIMEZONE = new InjectionToken('DATE_PIPE_DEFAULT_TIMEZONE');\n// clang-format off\n/**\n * @ngModule CommonModule\n * @description\n *\n * Formats a date value according to locale rules.\n *\n * `DatePipe` is executed only when it detects a pure change to the input value.\n * A pure change is either a change to a primitive input value\n * (such as `String`, `Number`, `Boolean`, or `Symbol`),\n * or a changed object reference (such as `Date`, `Array`, `Function`, or `Object`).\n *\n * Note that mutating a `Date` object does not cause the pipe to be rendered again.\n * To ensure that the pipe is executed, you must create a new `Date` object.\n *\n * Only the `en-US` locale data comes with Angular. To localize dates\n * in another language, you must import the corresponding locale data.\n * See the [I18n guide](guide/i18n-common-format-data-locale) for more information.\n *\n * The time zone of the formatted value can be specified either by passing it in as the second\n * parameter of the pipe, or by setting the default through the `DATE_PIPE_DEFAULT_TIMEZONE`\n * injection token. The value that is passed in as the second parameter takes precedence over\n * the one defined using the injection token.\n *\n * @see `formatDate()`\n *\n *\n * @usageNotes\n *\n * The result of this pipe is not reevaluated when the input is mutated. To avoid the need to\n * reformat the date on every change-detection cycle, treat the date as an immutable object\n * and change the reference when the pipe needs to run again.\n *\n * ### Pre-defined format options\n *\n * | Option | Equivalent to | Examples (given in `en-US` locale) |\n * |---------------|-------------------------------------|-------------------------------------------------|\n * | `'short'` | `'M/d/yy, h:mm a'` | `6/15/15, 9:03 AM` |\n * | `'medium'` | `'MMM d, y, h:mm:ss a'` | `Jun 15, 2015, 9:03:01 AM` |\n * | `'long'` | `'MMMM d, y, h:mm:ss a z'` | `June 15, 2015 at 9:03:01 AM GMT+1` |\n * | `'full'` | `'EEEE, MMMM d, y, h:mm:ss a zzzz'` | `Monday, June 15, 2015 at 9:03:01 AM GMT+01:00` |\n * | `'shortDate'` | `'M/d/yy'` | `6/15/15` |\n * | `'mediumDate'`| `'MMM d, y'` | `Jun 15, 2015` |\n * | `'longDate'` | `'MMMM d, y'` | `June 15, 2015` |\n * | `'fullDate'` | `'EEEE, MMMM d, y'` | `Monday, June 15, 2015` |\n * | `'shortTime'` | `'h:mm a'` | `9:03 AM` |\n * | `'mediumTime'`| `'h:mm:ss a'` | `9:03:01 AM` |\n * | `'longTime'` | `'h:mm:ss a z'` | `9:03:01 AM GMT+1` |\n * | `'fullTime'` | `'h:mm:ss a zzzz'` | `9:03:01 AM GMT+01:00` |\n *\n * ### Custom format options\n *\n * You can construct a format string using symbols to specify the components\n * of a date-time value, as described in the following table.\n * Format details depend on the locale.\n * Fields marked with (*) are only available in the extra data set for the given locale.\n *\n * | Field type | Format | Description | Example Value |\n * |-------------------- |-------------|---------------------------------------------------------------|------------------------------------------------------------|\n * | Era | G, GG & GGG | Abbreviated | AD |\n * | | GGGG | Wide | Anno Domini |\n * | | GGGGG | Narrow | A |\n * | Year | y | Numeric: minimum digits | 2, 20, 201, 2017, 20173 |\n * | | yy | Numeric: 2 digits + zero padded | 02, 20, 01, 17, 73 |\n * | | yyy | Numeric: 3 digits + zero padded | 002, 020, 201, 2017, 20173 |\n * | | yyyy | Numeric: 4 digits or more + zero padded | 0002, 0020, 0201, 2017, 20173 |\n * | Week-numbering year | Y | Numeric: minimum digits | 2, 20, 201, 2017, 20173 |\n * | | YY | Numeric: 2 digits + zero padded | 02, 20, 01, 17, 73 |\n * | | YYY | Numeric: 3 digits + zero padded | 002, 020, 201, 2017, 20173 |\n * | | YYYY | Numeric: 4 digits or more + zero padded | 0002, 0020, 0201, 2017, 20173 |\n * | Month | M | Numeric: 1 digit | 9, 12 |\n * | | MM | Numeric: 2 digits + zero padded | 09, 12 |\n * | | MMM | Abbreviated | Sep |\n * | | MMMM | Wide | September |\n * | | MMMMM | Narrow | S |\n * | Month standalone | L | Numeric: 1 digit | 9, 12 |\n * | | LL | Numeric: 2 digits + zero padded | 09, 12 |\n * | | LLL | Abbreviated | Sep |\n * | | LLLL | Wide | September |\n * | | LLLLL | Narrow | S |\n * | Week of year | w | Numeric: minimum digits | 1... 53 |\n * | | ww | Numeric: 2 digits + zero padded | 01... 53 |\n * | Week of month | W | Numeric: 1 digit | 1... 5 |\n * | Day of month | d | Numeric: minimum digits | 1 |\n * | | dd | Numeric: 2 digits + zero padded | 01 |\n * | Week day | E, EE & EEE | Abbreviated | Tue |\n * | | EEEE | Wide | Tuesday |\n * | | EEEEE | Narrow | T |\n * | | EEEEEE | Short | Tu |\n * | Week day standalone | c, cc | Numeric: 1 digit | 2 |\n * | | ccc | Abbreviated | Tue |\n * | | cccc | Wide | Tuesday |\n * | | ccccc | Narrow | T |\n * | | cccccc | Short | Tu |\n * | Period | a, aa & aaa | Abbreviated | am/pm or AM/PM |\n * | | aaaa | Wide (fallback to `a` when missing) | ante meridiem/post meridiem |\n * | | aaaaa | Narrow | a/p |\n * | Period* | B, BB & BBB | Abbreviated | mid. |\n * | | BBBB | Wide | am, pm, midnight, noon, morning, afternoon, evening, night |\n * | | BBBBB | Narrow | md |\n * | Period standalone* | b, bb & bbb | Abbreviated | mid. |\n * | | bbbb | Wide | am, pm, midnight, noon, morning, afternoon, evening, night |\n * | | bbbbb | Narrow | md |\n * | Hour 1-12 | h | Numeric: minimum digits | 1, 12 |\n * | | hh | Numeric: 2 digits + zero padded | 01, 12 |\n * | Hour 0-23 | H | Numeric: minimum digits | 0, 23 |\n * | | HH | Numeric: 2 digits + zero padded | 00, 23 |\n * | Minute | m | Numeric: minimum digits | 8, 59 |\n * | | mm | Numeric: 2 digits + zero padded | 08, 59 |\n * | Second | s | Numeric: minimum digits | 0... 59 |\n * | | ss | Numeric: 2 digits + zero padded | 00... 59 |\n * | Fractional seconds | S | Numeric: 1 digit | 0... 9 |\n * | | SS | Numeric: 2 digits + zero padded | 00... 99 |\n * | | SSS | Numeric: 3 digits + zero padded (= milliseconds) | 000... 999 |\n * | Zone | z, zz & zzz | Short specific non location format (fallback to O) | GMT-8 |\n * | | zzzz | Long specific non location format (fallback to OOOO) | GMT-08:00 |\n * | | Z, ZZ & ZZZ | ISO8601 basic format | -0800 |\n * | | ZZZZ | Long localized GMT format | GMT-8:00 |\n * | | ZZZZZ | ISO8601 extended format + Z indicator for offset 0 (= XXXXX) | -08:00 |\n * | | O, OO & OOO | Short localized GMT format | GMT-8 |\n * | | OOOO | Long localized GMT format | GMT-08:00 |\n *\n *\n * ### Format examples\n *\n * These examples transform a date into various formats,\n * assuming that `dateObj` is a JavaScript `Date` object for\n * year: 2015, month: 6, day: 15, hour: 21, minute: 43, second: 11,\n * given in the local time for the `en-US` locale.\n *\n * ```\n * {{ dateObj | date }} // output is 'Jun 15, 2015'\n * {{ dateObj | date:'medium' }} // output is 'Jun 15, 2015, 9:43:11 PM'\n * {{ dateObj | date:'shortTime' }} // output is '9:43 PM'\n * {{ dateObj | date:'mm:ss' }} // output is '43:11'\n * ```\n *\n * ### Usage example\n *\n * The following component uses a date pipe to display the current date in different formats.\n *\n * ```\n * @Component({\n * selector: 'date-pipe',\n * template: `
    \n *

    Today is {{today | date}}

    \n *

    Or if you prefer, {{today | date:'fullDate'}}

    \n *

    The time is {{today | date:'h:mm a z'}}

    \n *
    `\n * })\n * // Get the current date and time as a date-time value.\n * export class DatePipeComponent {\n * today: number = Date.now();\n * }\n * ```\n *\n * @publicApi\n */\n// clang-format on\nclass DatePipe {\n constructor(locale, defaultTimezone) {\n this.locale = locale;\n this.defaultTimezone = defaultTimezone;\n }\n transform(value, format = 'mediumDate', timezone, locale) {\n if (value == null || value === '' || value !== value)\n return null;\n try {\n return formatDate(value, format, locale || this.locale, timezone ?? this.defaultTimezone ?? undefined);\n }\n catch (error) {\n throw invalidPipeArgumentError(DatePipe, error.message);\n }\n }\n}\nDatePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: DatePipe, deps: [{ token: LOCALE_ID }, { token: DATE_PIPE_DEFAULT_TIMEZONE, optional: true }], target: i0.ɵɵFactoryTarget.Pipe });\nDatePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: DatePipe, name: \"date\" });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: DatePipe, decorators: [{\n type: Pipe,\n args: [{ name: 'date', pure: true }]\n }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n type: Inject,\n args: [LOCALE_ID]\n }] }, { type: undefined, decorators: [{\n type: Inject,\n args: [DATE_PIPE_DEFAULT_TIMEZONE]\n }, {\n type: Optional\n }] }]; } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst _INTERPOLATION_REGEXP = /#/g;\n/**\n * @ngModule CommonModule\n * @description\n *\n * Maps a value to a string that pluralizes the value according to locale rules.\n *\n * @usageNotes\n *\n * ### Example\n *\n * {@example common/pipes/ts/i18n_pipe.ts region='I18nPluralPipeComponent'}\n *\n * @publicApi\n */\nclass I18nPluralPipe {\n constructor(_localization) {\n this._localization = _localization;\n }\n /**\n * @param value the number to be formatted\n * @param pluralMap an object that mimics the ICU format, see\n * http://userguide.icu-project.org/formatparse/messages.\n * @param locale a `string` defining the locale to use (uses the current {@link LOCALE_ID} by\n * default).\n */\n transform(value, pluralMap, locale) {\n if (value == null)\n return '';\n if (typeof pluralMap !== 'object' || pluralMap === null) {\n throw invalidPipeArgumentError(I18nPluralPipe, pluralMap);\n }\n const key = getPluralCategory(value, Object.keys(pluralMap), this._localization, locale);\n return pluralMap[key].replace(_INTERPOLATION_REGEXP, value.toString());\n }\n}\nI18nPluralPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: I18nPluralPipe, deps: [{ token: NgLocalization }], target: i0.ɵɵFactoryTarget.Pipe });\nI18nPluralPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: I18nPluralPipe, name: \"i18nPlural\" });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: I18nPluralPipe, decorators: [{\n type: Pipe,\n args: [{ name: 'i18nPlural', pure: true }]\n }], ctorParameters: function () { return [{ type: NgLocalization }]; } });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @ngModule CommonModule\n * @description\n *\n * Generic selector that displays the string that matches the current value.\n *\n * If none of the keys of the `mapping` match the `value`, then the content\n * of the `other` key is returned when present, otherwise an empty string is returned.\n *\n * @usageNotes\n *\n * ### Example\n *\n * {@example common/pipes/ts/i18n_pipe.ts region='I18nSelectPipeComponent'}\n *\n * @publicApi\n */\nclass I18nSelectPipe {\n /**\n * @param value a string to be internationalized.\n * @param mapping an object that indicates the text that should be displayed\n * for different values of the provided `value`.\n */\n transform(value, mapping) {\n if (value == null)\n return '';\n if (typeof mapping !== 'object' || typeof value !== 'string') {\n throw invalidPipeArgumentError(I18nSelectPipe, mapping);\n }\n if (mapping.hasOwnProperty(value)) {\n return mapping[value];\n }\n if (mapping.hasOwnProperty('other')) {\n return mapping['other'];\n }\n return '';\n }\n}\nI18nSelectPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: I18nSelectPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });\nI18nSelectPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: I18nSelectPipe, name: \"i18nSelect\" });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: I18nSelectPipe, decorators: [{\n type: Pipe,\n args: [{ name: 'i18nSelect', pure: true }]\n }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @ngModule CommonModule\n * @description\n *\n * Converts a value into its JSON-format representation. Useful for debugging.\n *\n * @usageNotes\n *\n * The following component uses a JSON pipe to convert an object\n * to JSON format, and displays the string in both formats for comparison.\n *\n * {@example common/pipes/ts/json_pipe.ts region='JsonPipe'}\n *\n * @publicApi\n */\nclass JsonPipe {\n /**\n * @param value A value of any type to convert into a JSON-format string.\n */\n transform(value) {\n return JSON.stringify(value, null, 2);\n }\n}\nJsonPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: JsonPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });\nJsonPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: JsonPipe, name: \"json\", pure: false });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: JsonPipe, decorators: [{\n type: Pipe,\n args: [{ name: 'json', pure: false }]\n }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction makeKeyValuePair(key, value) {\n return { key: key, value: value };\n}\n/**\n * @ngModule CommonModule\n * @description\n *\n * Transforms Object or Map into an array of key value pairs.\n *\n * The output array will be ordered by keys.\n * By default the comparator will be by Unicode point value.\n * You can optionally pass a compareFn if your keys are complex types.\n *\n * @usageNotes\n * ### Examples\n *\n * This examples show how an Object or a Map can be iterated by ngFor with the use of this\n * keyvalue pipe.\n *\n * {@example common/pipes/ts/keyvalue_pipe.ts region='KeyValuePipe'}\n *\n * @publicApi\n */\nclass KeyValuePipe {\n constructor(differs) {\n this.differs = differs;\n this.keyValues = [];\n this.compareFn = defaultComparator;\n }\n transform(input, compareFn = defaultComparator) {\n if (!input || (!(input instanceof Map) && typeof input !== 'object')) {\n return null;\n }\n if (!this.differ) {\n // make a differ for whatever type we've been passed in\n this.differ = this.differs.find(input).create();\n }\n const differChanges = this.differ.diff(input);\n const compareFnChanged = compareFn !== this.compareFn;\n if (differChanges) {\n this.keyValues = [];\n differChanges.forEachItem((r) => {\n this.keyValues.push(makeKeyValuePair(r.key, r.currentValue));\n });\n }\n if (differChanges || compareFnChanged) {\n this.keyValues.sort(compareFn);\n this.compareFn = compareFn;\n }\n return this.keyValues;\n }\n}\nKeyValuePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: KeyValuePipe, deps: [{ token: i0.KeyValueDiffers }], target: i0.ɵɵFactoryTarget.Pipe });\nKeyValuePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: KeyValuePipe, name: \"keyvalue\", pure: false });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: KeyValuePipe, decorators: [{\n type: Pipe,\n args: [{ name: 'keyvalue', pure: false }]\n }], ctorParameters: function () { return [{ type: i0.KeyValueDiffers }]; } });\nfunction defaultComparator(keyValueA, keyValueB) {\n const a = keyValueA.key;\n const b = keyValueB.key;\n // if same exit with 0;\n if (a === b)\n return 0;\n // make sure that undefined are at the end of the sort.\n if (a === undefined)\n return 1;\n if (b === undefined)\n return -1;\n // make sure that nulls are at the end of the sort.\n if (a === null)\n return 1;\n if (b === null)\n return -1;\n if (typeof a == 'string' && typeof b == 'string') {\n return a < b ? -1 : 1;\n }\n if (typeof a == 'number' && typeof b == 'number') {\n return a - b;\n }\n if (typeof a == 'boolean' && typeof b == 'boolean') {\n return a < b ? -1 : 1;\n }\n // `a` and `b` are of different types. Compare their string values.\n const aString = String(a);\n const bString = String(b);\n return aString == bString ? 0 : aString < bString ? -1 : 1;\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @ngModule CommonModule\n * @description\n *\n * Formats a value according to digit options and locale rules.\n * Locale determines group sizing and separator,\n * decimal point character, and other locale-specific configurations.\n *\n * @see `formatNumber()`\n *\n * @usageNotes\n *\n * ### digitsInfo\n *\n * The value's decimal representation is specified by the `digitsInfo`\n * parameter, written in the following format:
    \n *\n * ```\n * {minIntegerDigits}.{minFractionDigits}-{maxFractionDigits}\n * ```\n *\n * - `minIntegerDigits`:\n * The minimum number of integer digits before the decimal point.\n * Default is 1.\n *\n * - `minFractionDigits`:\n * The minimum number of digits after the decimal point.\n * Default is 0.\n *\n * - `maxFractionDigits`:\n * The maximum number of digits after the decimal point.\n * Default is 3.\n *\n * If the formatted value is truncated it will be rounded using the \"to-nearest\" method:\n *\n * ```\n * {{3.6 | number: '1.0-0'}}\n * \n *\n * {{-3.6 | number:'1.0-0'}}\n * \n * ```\n *\n * ### locale\n *\n * `locale` will format a value according to locale rules.\n * Locale determines group sizing and separator,\n * decimal point character, and other locale-specific configurations.\n *\n * When not supplied, uses the value of `LOCALE_ID`, which is `en-US` by default.\n *\n * See [Setting your app locale](guide/i18n-common-locale-id).\n *\n * ### Example\n *\n * The following code shows how the pipe transforms values\n * according to various format specifications,\n * where the caller's default locale is `en-US`.\n *\n * \n *\n * @publicApi\n */\nclass DecimalPipe {\n constructor(_locale) {\n this._locale = _locale;\n }\n /**\n * @param value The value to be formatted.\n * @param digitsInfo Sets digit and decimal representation.\n * [See more](#digitsinfo).\n * @param locale Specifies what locale format rules to use.\n * [See more](#locale).\n */\n transform(value, digitsInfo, locale) {\n if (!isValue(value))\n return null;\n locale = locale || this._locale;\n try {\n const num = strToNumber(value);\n return formatNumber(num, locale, digitsInfo);\n }\n catch (error) {\n throw invalidPipeArgumentError(DecimalPipe, error.message);\n }\n }\n}\nDecimalPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: DecimalPipe, deps: [{ token: LOCALE_ID }], target: i0.ɵɵFactoryTarget.Pipe });\nDecimalPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: DecimalPipe, name: \"number\" });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: DecimalPipe, decorators: [{\n type: Pipe,\n args: [{ name: 'number' }]\n }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n type: Inject,\n args: [LOCALE_ID]\n }] }]; } });\n/**\n * @ngModule CommonModule\n * @description\n *\n * Transforms a number to a percentage\n * string, formatted according to locale rules that determine group sizing and\n * separator, decimal-point character, and other locale-specific\n * configurations.\n *\n * @see `formatPercent()`\n *\n * @usageNotes\n * The following code shows how the pipe transforms numbers\n * into text strings, according to various format specifications,\n * where the caller's default locale is `en-US`.\n *\n * \n *\n * @publicApi\n */\nclass PercentPipe {\n constructor(_locale) {\n this._locale = _locale;\n }\n /**\n *\n * @param value The number to be formatted as a percentage.\n * @param digitsInfo Decimal representation options, specified by a string\n * in the following format:
    \n * {minIntegerDigits}.{minFractionDigits}-{maxFractionDigits}.\n * - `minIntegerDigits`: The minimum number of integer digits before the decimal point.\n * Default is `1`.\n * - `minFractionDigits`: The minimum number of digits after the decimal point.\n * Default is `0`.\n * - `maxFractionDigits`: The maximum number of digits after the decimal point.\n * Default is `0`.\n * @param locale A locale code for the locale format rules to use.\n * When not supplied, uses the value of `LOCALE_ID`, which is `en-US` by default.\n * See [Setting your app locale](guide/i18n-common-locale-id).\n */\n transform(value, digitsInfo, locale) {\n if (!isValue(value))\n return null;\n locale = locale || this._locale;\n try {\n const num = strToNumber(value);\n return formatPercent(num, locale, digitsInfo);\n }\n catch (error) {\n throw invalidPipeArgumentError(PercentPipe, error.message);\n }\n }\n}\nPercentPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: PercentPipe, deps: [{ token: LOCALE_ID }], target: i0.ɵɵFactoryTarget.Pipe });\nPercentPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: PercentPipe, name: \"percent\" });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: PercentPipe, decorators: [{\n type: Pipe,\n args: [{ name: 'percent' }]\n }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n type: Inject,\n args: [LOCALE_ID]\n }] }]; } });\n/**\n * @ngModule CommonModule\n * @description\n *\n * Transforms a number to a currency string, formatted according to locale rules\n * that determine group sizing and separator, decimal-point character,\n * and other locale-specific configurations.\n *\n * {@a currency-code-deprecation}\n *
    \n *\n * **Deprecation notice:**\n *\n * The default currency code is currently always `USD` but this is deprecated from v9.\n *\n * **In v11 the default currency code will be taken from the current locale identified by\n * the `LOCALE_ID` token. See the [i18n guide](guide/i18n-common-locale-id) for\n * more information.**\n *\n * If you need the previous behavior then set it by creating a `DEFAULT_CURRENCY_CODE` provider in\n * your application `NgModule`:\n *\n * ```ts\n * {provide: DEFAULT_CURRENCY_CODE, useValue: 'USD'}\n * ```\n *\n *
    \n *\n * @see `getCurrencySymbol()`\n * @see `formatCurrency()`\n *\n * @usageNotes\n * The following code shows how the pipe transforms numbers\n * into text strings, according to various format specifications,\n * where the caller's default locale is `en-US`.\n *\n * \n *\n * @publicApi\n */\nclass CurrencyPipe {\n constructor(_locale, _defaultCurrencyCode = 'USD') {\n this._locale = _locale;\n this._defaultCurrencyCode = _defaultCurrencyCode;\n }\n /**\n *\n * @param value The number to be formatted as currency.\n * @param currencyCode The [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code,\n * such as `USD` for the US dollar and `EUR` for the euro. The default currency code can be\n * configured using the `DEFAULT_CURRENCY_CODE` injection token.\n * @param display The format for the currency indicator. One of the following:\n * - `code`: Show the code (such as `USD`).\n * - `symbol`(default): Show the symbol (such as `$`).\n * - `symbol-narrow`: Use the narrow symbol for locales that have two symbols for their\n * currency.\n * For example, the Canadian dollar CAD has the symbol `CA$` and the symbol-narrow `$`. If the\n * locale has no narrow symbol, uses the standard symbol for the locale.\n * - String: Use the given string value instead of a code or a symbol.\n * For example, an empty string will suppress the currency & symbol.\n * - Boolean (marked deprecated in v5): `true` for symbol and false for `code`.\n *\n * @param digitsInfo Decimal representation options, specified by a string\n * in the following format:
    \n * {minIntegerDigits}.{minFractionDigits}-{maxFractionDigits}.\n * - `minIntegerDigits`: The minimum number of integer digits before the decimal point.\n * Default is `1`.\n * - `minFractionDigits`: The minimum number of digits after the decimal point.\n * Default is `2`.\n * - `maxFractionDigits`: The maximum number of digits after the decimal point.\n * Default is `2`.\n * If not provided, the number will be formatted with the proper amount of digits,\n * depending on what the [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) specifies.\n * For example, the Canadian dollar has 2 digits, whereas the Chilean peso has none.\n * @param locale A locale code for the locale format rules to use.\n * When not supplied, uses the value of `LOCALE_ID`, which is `en-US` by default.\n * See [Setting your app locale](guide/i18n-common-locale-id).\n */\n transform(value, currencyCode = this._defaultCurrencyCode, display = 'symbol', digitsInfo, locale) {\n if (!isValue(value))\n return null;\n locale = locale || this._locale;\n if (typeof display === 'boolean') {\n if ((typeof ngDevMode === 'undefined' || ngDevMode) && console && console.warn) {\n console.warn(`Warning: the currency pipe has been changed in Angular v5. The symbolDisplay option (third parameter) is now a string instead of a boolean. The accepted values are \"code\", \"symbol\" or \"symbol-narrow\".`);\n }\n display = display ? 'symbol' : 'code';\n }\n let currency = currencyCode || this._defaultCurrencyCode;\n if (display !== 'code') {\n if (display === 'symbol' || display === 'symbol-narrow') {\n currency = getCurrencySymbol(currency, display === 'symbol' ? 'wide' : 'narrow', locale);\n }\n else {\n currency = display;\n }\n }\n try {\n const num = strToNumber(value);\n return formatCurrency(num, locale, currency, currencyCode, digitsInfo);\n }\n catch (error) {\n throw invalidPipeArgumentError(CurrencyPipe, error.message);\n }\n }\n}\nCurrencyPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: CurrencyPipe, deps: [{ token: LOCALE_ID }, { token: DEFAULT_CURRENCY_CODE }], target: i0.ɵɵFactoryTarget.Pipe });\nCurrencyPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: CurrencyPipe, name: \"currency\" });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: CurrencyPipe, decorators: [{\n type: Pipe,\n args: [{ name: 'currency' }]\n }], ctorParameters: function () { return [{ type: undefined, decorators: [{\n type: Inject,\n args: [LOCALE_ID]\n }] }, { type: undefined, decorators: [{\n type: Inject,\n args: [DEFAULT_CURRENCY_CODE]\n }] }]; } });\nfunction isValue(value) {\n return !(value == null || value === '' || value !== value);\n}\n/**\n * Transforms a string into a number (if needed).\n */\nfunction strToNumber(value) {\n // Convert strings to numbers\n if (typeof value === 'string' && !isNaN(Number(value) - parseFloat(value))) {\n return Number(value);\n }\n if (typeof value !== 'number') {\n throw new Error(`${value} is not a number`);\n }\n return value;\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @ngModule CommonModule\n * @description\n *\n * Creates a new `Array` or `String` containing a subset (slice) of the elements.\n *\n * @usageNotes\n *\n * All behavior is based on the expected behavior of the JavaScript API `Array.prototype.slice()`\n * and `String.prototype.slice()`.\n *\n * When operating on an `Array`, the returned `Array` is always a copy even when all\n * the elements are being returned.\n *\n * When operating on a blank value, the pipe returns the blank value.\n *\n * ### List Example\n *\n * This `ngFor` example:\n *\n * {@example common/pipes/ts/slice_pipe.ts region='SlicePipe_list'}\n *\n * produces the following:\n *\n * ```html\n *
  • b
  • \n *
  • c
  • \n * ```\n *\n * ### String Examples\n *\n * {@example common/pipes/ts/slice_pipe.ts region='SlicePipe_string'}\n *\n * @publicApi\n */\nclass SlicePipe {\n transform(value, start, end) {\n if (value == null)\n return null;\n if (!this.supports(value)) {\n throw invalidPipeArgumentError(SlicePipe, value);\n }\n return value.slice(start, end);\n }\n supports(obj) {\n return typeof obj === 'string' || Array.isArray(obj);\n }\n}\nSlicePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: SlicePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });\nSlicePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: SlicePipe, name: \"slice\", pure: false });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: SlicePipe, decorators: [{\n type: Pipe,\n args: [{ name: 'slice', pure: false }]\n }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A collection of Angular pipes that are likely to be used in each and every application.\n */\nconst COMMON_PIPES = [\n AsyncPipe,\n UpperCasePipe,\n LowerCasePipe,\n JsonPipe,\n SlicePipe,\n DecimalPipe,\n PercentPipe,\n TitleCasePipe,\n CurrencyPipe,\n DatePipe,\n I18nPluralPipe,\n I18nSelectPipe,\n KeyValuePipe,\n];\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// Note: This does not contain the location providers,\n// as they need some platform specific implementations to work.\n/**\n * Exports all the basic Angular directives and pipes,\n * such as `NgIf`, `NgForOf`, `DecimalPipe`, and so on.\n * Re-exported by `BrowserModule`, which is included automatically in the root\n * `AppModule` when you create a new app with the CLI `new` command.\n *\n * * The `providers` options configure the NgModule's injector to provide\n * localization dependencies to members.\n * * The `exports` options make the declared directives and pipes available for import\n * by other NgModules.\n *\n * @publicApi\n */\nclass CommonModule {\n}\nCommonModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: CommonModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });\nCommonModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: CommonModule, declarations: [NgClass, NgComponentOutlet, NgForOf, NgIf, NgTemplateOutlet, NgStyle, NgSwitch, NgSwitchCase, NgSwitchDefault, NgPlural, NgPluralCase, AsyncPipe, UpperCasePipe, LowerCasePipe, JsonPipe, SlicePipe, DecimalPipe, PercentPipe, TitleCasePipe, CurrencyPipe, DatePipe, I18nPluralPipe, I18nSelectPipe, KeyValuePipe], exports: [NgClass, NgComponentOutlet, NgForOf, NgIf, NgTemplateOutlet, NgStyle, NgSwitch, NgSwitchCase, NgSwitchDefault, NgPlural, NgPluralCase, AsyncPipe, UpperCasePipe, LowerCasePipe, JsonPipe, SlicePipe, DecimalPipe, PercentPipe, TitleCasePipe, CurrencyPipe, DatePipe, I18nPluralPipe, I18nSelectPipe, KeyValuePipe] });\nCommonModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: CommonModule });\ni0.ɵɵngDeclareClassMetadata({ minVersion: \"12.0.0\", version: \"13.3.12\", ngImport: i0, type: CommonModule, decorators: [{\n type: NgModule,\n args: [{\n declarations: [COMMON_DIRECTIVES, COMMON_PIPES],\n exports: [COMMON_DIRECTIVES, COMMON_PIPES],\n }]\n }] });\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst PLATFORM_BROWSER_ID = 'browser';\nconst PLATFORM_SERVER_ID = 'server';\nconst PLATFORM_WORKER_APP_ID = 'browserWorkerApp';\nconst PLATFORM_WORKER_UI_ID = 'browserWorkerUi';\n/**\n * Returns whether a platform id represents a browser platform.\n * @publicApi\n */\nfunction isPlatformBrowser(platformId) {\n return platformId === PLATFORM_BROWSER_ID;\n}\n/**\n * Returns whether a platform id represents a server platform.\n * @publicApi\n */\nfunction isPlatformServer(platformId) {\n return platformId === PLATFORM_SERVER_ID;\n}\n/**\n * Returns whether a platform id represents a web worker app platform.\n * @publicApi\n */\nfunction isPlatformWorkerApp(platformId) {\n return platformId === PLATFORM_WORKER_APP_ID;\n}\n/**\n * Returns whether a platform id represents a web worker UI platform.\n * @publicApi\n */\nfunction isPlatformWorkerUi(platformId) {\n return platformId === PLATFORM_WORKER_UI_ID;\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @publicApi\n */\nconst VERSION = new Version('13.3.12');\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Defines a scroll position manager. Implemented by `BrowserViewportScroller`.\n *\n * @publicApi\n */\nclass ViewportScroller {\n}\n// De-sugared tree-shakable injection\n// See #23917\n/** @nocollapse */\nViewportScroller.ɵprov = ɵɵdefineInjectable({\n token: ViewportScroller,\n providedIn: 'root',\n factory: () => new BrowserViewportScroller(ɵɵinject(DOCUMENT), window)\n});\n/**\n * Manages the scroll position for a browser window.\n */\nclass BrowserViewportScroller {\n constructor(document, window) {\n this.document = document;\n this.window = window;\n this.offset = () => [0, 0];\n }\n /**\n * Configures the top offset used when scrolling to an anchor.\n * @param offset A position in screen coordinates (a tuple with x and y values)\n * or a function that returns the top offset position.\n *\n */\n setOffset(offset) {\n if (Array.isArray(offset)) {\n this.offset = () => offset;\n }\n else {\n this.offset = offset;\n }\n }\n /**\n * Retrieves the current scroll position.\n * @returns The position in screen coordinates.\n */\n getScrollPosition() {\n if (this.supportsScrolling()) {\n return [this.window.pageXOffset, this.window.pageYOffset];\n }\n else {\n return [0, 0];\n }\n }\n /**\n * Sets the scroll position.\n * @param position The new position in screen coordinates.\n */\n scrollToPosition(position) {\n if (this.supportsScrolling()) {\n this.window.scrollTo(position[0], position[1]);\n }\n }\n /**\n * Scrolls to an element and attempts to focus the element.\n *\n * Note that the function name here is misleading in that the target string may be an ID for a\n * non-anchor element.\n *\n * @param target The ID of an element or name of the anchor.\n *\n * @see https://html.spec.whatwg.org/#the-indicated-part-of-the-document\n * @see https://html.spec.whatwg.org/#scroll-to-fragid\n */\n scrollToAnchor(target) {\n if (!this.supportsScrolling()) {\n return;\n }\n const elSelected = findAnchorFromDocument(this.document, target);\n if (elSelected) {\n this.scrollToElement(elSelected);\n // After scrolling to the element, the spec dictates that we follow the focus steps for the\n // target. Rather than following the robust steps, simply attempt focus.\n //\n // @see https://html.spec.whatwg.org/#get-the-focusable-area\n // @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLOrForeignElement/focus\n // @see https://html.spec.whatwg.org/#focusable-area\n elSelected.focus();\n }\n }\n /**\n * Disables automatic scroll restoration provided by the browser.\n */\n setHistoryScrollRestoration(scrollRestoration) {\n if (this.supportScrollRestoration()) {\n const history = this.window.history;\n if (history && history.scrollRestoration) {\n history.scrollRestoration = scrollRestoration;\n }\n }\n }\n /**\n * Scrolls to an element using the native offset and the specified offset set on this scroller.\n *\n * The offset can be used when we know that there is a floating header and scrolling naively to an\n * element (ex: `scrollIntoView`) leaves the element hidden behind the floating header.\n */\n scrollToElement(el) {\n const rect = el.getBoundingClientRect();\n const left = rect.left + this.window.pageXOffset;\n const top = rect.top + this.window.pageYOffset;\n const offset = this.offset();\n this.window.scrollTo(left - offset[0], top - offset[1]);\n }\n /**\n * We only support scroll restoration when we can get a hold of window.\n * This means that we do not support this behavior when running in a web worker.\n *\n * Lifting this restriction right now would require more changes in the dom adapter.\n * Since webworkers aren't widely used, we will lift it once RouterScroller is\n * battle-tested.\n */\n supportScrollRestoration() {\n try {\n if (!this.supportsScrolling()) {\n return false;\n }\n // The `scrollRestoration` property could be on the `history` instance or its prototype.\n const scrollRestorationDescriptor = getScrollRestorationProperty(this.window.history) ||\n getScrollRestorationProperty(Object.getPrototypeOf(this.window.history));\n // We can write to the `scrollRestoration` property if it is a writable data field or it has a\n // setter function.\n return !!scrollRestorationDescriptor &&\n !!(scrollRestorationDescriptor.writable || scrollRestorationDescriptor.set);\n }\n catch {\n return false;\n }\n }\n supportsScrolling() {\n try {\n return !!this.window && !!this.window.scrollTo && 'pageXOffset' in this.window;\n }\n catch {\n return false;\n }\n }\n}\nfunction getScrollRestorationProperty(obj) {\n return Object.getOwnPropertyDescriptor(obj, 'scrollRestoration');\n}\nfunction findAnchorFromDocument(document, target) {\n const documentResult = document.getElementById(target) || document.getElementsByName(target)[0];\n if (documentResult) {\n return documentResult;\n }\n // `getElementById` and `getElementsByName` won't pierce through the shadow DOM so we\n // have to traverse the DOM manually and do the lookup through the shadow roots.\n if (typeof document.createTreeWalker === 'function' && document.body &&\n (document.body.createShadowRoot || document.body.attachShadow)) {\n const treeWalker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT);\n let currentNode = treeWalker.currentNode;\n while (currentNode) {\n const shadowRoot = currentNode.shadowRoot;\n if (shadowRoot) {\n // Note that `ShadowRoot` doesn't support `getElementsByName`\n // so we have to fall back to `querySelector`.\n const result = shadowRoot.getElementById(target) || shadowRoot.querySelector(`[name=\"${target}\"]`);\n if (result) {\n return result;\n }\n }\n currentNode = treeWalker.nextNode();\n }\n }\n return null;\n}\n/**\n * Provides an empty implementation of the viewport scroller.\n */\nclass NullViewportScroller {\n /**\n * Empty implementation\n */\n setOffset(offset) { }\n /**\n * Empty implementation\n */\n getScrollPosition() {\n return [0, 0];\n }\n /**\n * Empty implementation\n */\n scrollToPosition(position) { }\n /**\n * Empty implementation\n */\n scrollToAnchor(anchor) { }\n /**\n * Empty implementation\n */\n setHistoryScrollRestoration(scrollRestoration) { }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A wrapper around the `XMLHttpRequest` constructor.\n *\n * @publicApi\n */\nclass XhrFactory {\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// This file only reexports content of the `src` folder. Keep it that way.\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { APP_BASE_HREF, AsyncPipe, CommonModule, CurrencyPipe, DATE_PIPE_DEFAULT_TIMEZONE, DOCUMENT, DatePipe, DecimalPipe, FormStyle, FormatWidth, HashLocationStrategy, I18nPluralPipe, I18nSelectPipe, JsonPipe, KeyValuePipe, LOCATION_INITIALIZED, Location, LocationStrategy, LowerCasePipe, NgClass, NgComponentOutlet, NgForOf, NgForOfContext, NgIf, NgIfContext, NgLocaleLocalization, NgLocalization, NgPlural, NgPluralCase, NgStyle, NgSwitch, NgSwitchCase, NgSwitchDefault, NgTemplateOutlet, NumberFormatStyle, NumberSymbol, PathLocationStrategy, PercentPipe, PlatformLocation, Plural, SlicePipe, TitleCasePipe, TranslationWidth, UpperCasePipe, VERSION, ViewportScroller, WeekDay, XhrFactory, formatCurrency, formatDate, formatNumber, formatPercent, getCurrencySymbol, getLocaleCurrencyCode, getLocaleCurrencyName, getLocaleCurrencySymbol, getLocaleDateFormat, getLocaleDateTimeFormat, getLocaleDayNames, getLocaleDayPeriods, getLocaleDirection, getLocaleEraNames, getLocaleExtraDayPeriodRules, getLocaleExtraDayPeriods, getLocaleFirstDayOfWeek, getLocaleId, getLocaleMonthNames, getLocaleNumberFormat, getLocaleNumberSymbol, getLocalePluralCase, getLocaleTimeFormat, getLocaleWeekEndRange, getNumberOfCurrencyDigits, isPlatformBrowser, isPlatformServer, isPlatformWorkerApp, isPlatformWorkerUi, registerLocaleData, BrowserPlatformLocation as ɵBrowserPlatformLocation, DomAdapter as ɵDomAdapter, NullViewportScroller as ɵNullViewportScroller, PLATFORM_BROWSER_ID as ɵPLATFORM_BROWSER_ID, PLATFORM_SERVER_ID as ɵPLATFORM_SERVER_ID, PLATFORM_WORKER_APP_ID as ɵPLATFORM_WORKER_APP_ID, PLATFORM_WORKER_UI_ID as ɵPLATFORM_WORKER_UI_ID, getDOM as ɵgetDOM, parseCookieValue as ɵparseCookieValue, setRootDomAdapter as ɵsetRootDomAdapter };\n","/**\n * @license Angular v13.3.12\n * (c) 2010-2022 Google LLC. https://angular.io/\n * License: MIT\n */\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar TagContentType;\n(function (TagContentType) {\n TagContentType[TagContentType[\"RAW_TEXT\"] = 0] = \"RAW_TEXT\";\n TagContentType[TagContentType[\"ESCAPABLE_RAW_TEXT\"] = 1] = \"ESCAPABLE_RAW_TEXT\";\n TagContentType[TagContentType[\"PARSABLE_DATA\"] = 2] = \"PARSABLE_DATA\";\n})(TagContentType || (TagContentType = {}));\nfunction splitNsName(elementName) {\n if (elementName[0] != ':') {\n return [null, elementName];\n }\n const colonIndex = elementName.indexOf(':', 1);\n if (colonIndex === -1) {\n throw new Error(`Unsupported format \"${elementName}\" expecting \":namespace:name\"`);\n }\n return [elementName.slice(1, colonIndex), elementName.slice(colonIndex + 1)];\n}\n// `` tags work the same regardless the namespace\nfunction isNgContainer(tagName) {\n return splitNsName(tagName)[1] === 'ng-container';\n}\n// `` tags work the same regardless the namespace\nfunction isNgContent(tagName) {\n return splitNsName(tagName)[1] === 'ng-content';\n}\n// `` tags work the same regardless the namespace\nfunction isNgTemplate(tagName) {\n return splitNsName(tagName)[1] === 'ng-template';\n}\nfunction getNsPrefix(fullName) {\n return fullName === null ? null : splitNsName(fullName)[0];\n}\nfunction mergeNsAndName(prefix, localName) {\n return prefix ? `:${prefix}:${localName}` : localName;\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass HtmlTagDefinition {\n constructor({ closedByChildren, implicitNamespacePrefix, contentType = TagContentType.PARSABLE_DATA, closedByParent = false, isVoid = false, ignoreFirstLf = false, preventNamespaceInheritance = false } = {}) {\n this.closedByChildren = {};\n this.closedByParent = false;\n this.canSelfClose = false;\n if (closedByChildren && closedByChildren.length > 0) {\n closedByChildren.forEach(tagName => this.closedByChildren[tagName] = true);\n }\n this.isVoid = isVoid;\n this.closedByParent = closedByParent || isVoid;\n this.implicitNamespacePrefix = implicitNamespacePrefix || null;\n this.contentType = contentType;\n this.ignoreFirstLf = ignoreFirstLf;\n this.preventNamespaceInheritance = preventNamespaceInheritance;\n }\n isClosedByChild(name) {\n return this.isVoid || name.toLowerCase() in this.closedByChildren;\n }\n getContentType(prefix) {\n if (typeof this.contentType === 'object') {\n const overrideType = prefix === undefined ? undefined : this.contentType[prefix];\n return overrideType ?? this.contentType.default;\n }\n return this.contentType;\n }\n}\nlet _DEFAULT_TAG_DEFINITION;\n// see https://www.w3.org/TR/html51/syntax.html#optional-tags\n// This implementation does not fully conform to the HTML5 spec.\nlet TAG_DEFINITIONS;\nfunction getHtmlTagDefinition(tagName) {\n if (!TAG_DEFINITIONS) {\n _DEFAULT_TAG_DEFINITION = new HtmlTagDefinition();\n TAG_DEFINITIONS = {\n 'base': new HtmlTagDefinition({ isVoid: true }),\n 'meta': new HtmlTagDefinition({ isVoid: true }),\n 'area': new HtmlTagDefinition({ isVoid: true }),\n 'embed': new HtmlTagDefinition({ isVoid: true }),\n 'link': new HtmlTagDefinition({ isVoid: true }),\n 'img': new HtmlTagDefinition({ isVoid: true }),\n 'input': new HtmlTagDefinition({ isVoid: true }),\n 'param': new HtmlTagDefinition({ isVoid: true }),\n 'hr': new HtmlTagDefinition({ isVoid: true }),\n 'br': new HtmlTagDefinition({ isVoid: true }),\n 'source': new HtmlTagDefinition({ isVoid: true }),\n 'track': new HtmlTagDefinition({ isVoid: true }),\n 'wbr': new HtmlTagDefinition({ isVoid: true }),\n 'p': new HtmlTagDefinition({\n closedByChildren: [\n 'address', 'article', 'aside', 'blockquote', 'div', 'dl', 'fieldset',\n 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5',\n 'h6', 'header', 'hgroup', 'hr', 'main', 'nav', 'ol',\n 'p', 'pre', 'section', 'table', 'ul'\n ],\n closedByParent: true\n }),\n 'thead': new HtmlTagDefinition({ closedByChildren: ['tbody', 'tfoot'] }),\n 'tbody': new HtmlTagDefinition({ closedByChildren: ['tbody', 'tfoot'], closedByParent: true }),\n 'tfoot': new HtmlTagDefinition({ closedByChildren: ['tbody'], closedByParent: true }),\n 'tr': new HtmlTagDefinition({ closedByChildren: ['tr'], closedByParent: true }),\n 'td': new HtmlTagDefinition({ closedByChildren: ['td', 'th'], closedByParent: true }),\n 'th': new HtmlTagDefinition({ closedByChildren: ['td', 'th'], closedByParent: true }),\n 'col': new HtmlTagDefinition({ isVoid: true }),\n 'svg': new HtmlTagDefinition({ implicitNamespacePrefix: 'svg' }),\n 'foreignObject': new HtmlTagDefinition({\n // Usually the implicit namespace here would be redundant since it will be inherited from\n // the parent `svg`, but we have to do it for `foreignObject`, because the way the parser\n // works is that the parent node of an end tag is its own start tag which means that\n // the `preventNamespaceInheritance` on `foreignObject` would have it default to the\n // implicit namespace which is `html`, unless specified otherwise.\n implicitNamespacePrefix: 'svg',\n // We want to prevent children of foreignObject from inheriting its namespace, because\n // the point of the element is to allow nodes from other namespaces to be inserted.\n preventNamespaceInheritance: true,\n }),\n 'math': new HtmlTagDefinition({ implicitNamespacePrefix: 'math' }),\n 'li': new HtmlTagDefinition({ closedByChildren: ['li'], closedByParent: true }),\n 'dt': new HtmlTagDefinition({ closedByChildren: ['dt', 'dd'] }),\n 'dd': new HtmlTagDefinition({ closedByChildren: ['dt', 'dd'], closedByParent: true }),\n 'rb': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }),\n 'rt': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }),\n 'rtc': new HtmlTagDefinition({ closedByChildren: ['rb', 'rtc', 'rp'], closedByParent: true }),\n 'rp': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }),\n 'optgroup': new HtmlTagDefinition({ closedByChildren: ['optgroup'], closedByParent: true }),\n 'option': new HtmlTagDefinition({ closedByChildren: ['option', 'optgroup'], closedByParent: true }),\n 'pre': new HtmlTagDefinition({ ignoreFirstLf: true }),\n 'listing': new HtmlTagDefinition({ ignoreFirstLf: true }),\n 'style': new HtmlTagDefinition({ contentType: TagContentType.RAW_TEXT }),\n 'script': new HtmlTagDefinition({ contentType: TagContentType.RAW_TEXT }),\n 'title': new HtmlTagDefinition({\n // The browser supports two separate `title` tags which have to use\n // a different content type: `HTMLTitleElement` and `SVGTitleElement`\n contentType: { default: TagContentType.ESCAPABLE_RAW_TEXT, svg: TagContentType.PARSABLE_DATA }\n }),\n 'textarea': new HtmlTagDefinition({ contentType: TagContentType.ESCAPABLE_RAW_TEXT, ignoreFirstLf: true }),\n };\n }\n // We have to make both a case-sensitive and a case-insensitive lookup, because\n // HTML tag names are case insensitive, whereas some SVG tags are case sensitive.\n return TAG_DEFINITIONS[tagName] ?? TAG_DEFINITIONS[tagName.toLowerCase()] ??\n _DEFAULT_TAG_DEFINITION;\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst _SELECTOR_REGEXP = new RegExp('(\\\\:not\\\\()|' + // 1: \":not(\"\n '(([\\\\.\\\\#]?)[-\\\\w]+)|' + // 2: \"tag\"; 3: \".\"/\"#\";\n // \"-\" should appear first in the regexp below as FF31 parses \"[.-\\w]\" as a range\n // 4: attribute; 5: attribute_string; 6: attribute_value\n '(?:\\\\[([-.\\\\w*\\\\\\\\$]+)(?:=([\\\"\\']?)([^\\\\]\\\"\\']*)\\\\5)?\\\\])|' + // \"[name]\", \"[name=value]\",\n // \"[name=\"value\"]\",\n // \"[name='value']\"\n '(\\\\))|' + // 7: \")\"\n '(\\\\s*,\\\\s*)', // 8: \",\"\n'g');\n/**\n * A css selector contains an element name,\n * css classes and attribute/value pairs with the purpose\n * of selecting subsets out of them.\n */\nclass CssSelector {\n constructor() {\n this.element = null;\n this.classNames = [];\n /**\n * The selectors are encoded in pairs where:\n * - even locations are attribute names\n * - odd locations are attribute values.\n *\n * Example:\n * Selector: `[key1=value1][key2]` would parse to:\n * ```\n * ['key1', 'value1', 'key2', '']\n * ```\n */\n this.attrs = [];\n this.notSelectors = [];\n }\n static parse(selector) {\n const results = [];\n const _addResult = (res, cssSel) => {\n if (cssSel.notSelectors.length > 0 && !cssSel.element && cssSel.classNames.length == 0 &&\n cssSel.attrs.length == 0) {\n cssSel.element = '*';\n }\n res.push(cssSel);\n };\n let cssSelector = new CssSelector();\n let match;\n let current = cssSelector;\n let inNot = false;\n _SELECTOR_REGEXP.lastIndex = 0;\n while (match = _SELECTOR_REGEXP.exec(selector)) {\n if (match[1 /* NOT */]) {\n if (inNot) {\n throw new Error('Nesting :not in a selector is not allowed');\n }\n inNot = true;\n current = new CssSelector();\n cssSelector.notSelectors.push(current);\n }\n const tag = match[2 /* TAG */];\n if (tag) {\n const prefix = match[3 /* PREFIX */];\n if (prefix === '#') {\n // #hash\n current.addAttribute('id', tag.substr(1));\n }\n else if (prefix === '.') {\n // Class\n current.addClassName(tag.substr(1));\n }\n else {\n // Element\n current.setElement(tag);\n }\n }\n const attribute = match[4 /* ATTRIBUTE */];\n if (attribute) {\n current.addAttribute(current.unescapeAttribute(attribute), match[6 /* ATTRIBUTE_VALUE */]);\n }\n if (match[7 /* NOT_END */]) {\n inNot = false;\n current = cssSelector;\n }\n if (match[8 /* SEPARATOR */]) {\n if (inNot) {\n throw new Error('Multiple selectors in :not are not supported');\n }\n _addResult(results, cssSelector);\n cssSelector = current = new CssSelector();\n }\n }\n _addResult(results, cssSelector);\n return results;\n }\n /**\n * Unescape `\\$` sequences from the CSS attribute selector.\n *\n * This is needed because `$` can have a special meaning in CSS selectors,\n * but we might want to match an attribute that contains `$`.\n * [MDN web link for more\n * info](https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors).\n * @param attr the attribute to unescape.\n * @returns the unescaped string.\n */\n unescapeAttribute(attr) {\n let result = '';\n let escaping = false;\n for (let i = 0; i < attr.length; i++) {\n const char = attr.charAt(i);\n if (char === '\\\\') {\n escaping = true;\n continue;\n }\n if (char === '$' && !escaping) {\n throw new Error(`Error in attribute selector \"${attr}\". ` +\n `Unescaped \"$\" is not supported. Please escape with \"\\\\$\".`);\n }\n escaping = false;\n result += char;\n }\n return result;\n }\n /**\n * Escape `$` sequences from the CSS attribute selector.\n *\n * This is needed because `$` can have a special meaning in CSS selectors,\n * with this method we are escaping `$` with `\\$'.\n * [MDN web link for more\n * info](https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors).\n * @param attr the attribute to escape.\n * @returns the escaped string.\n */\n escapeAttribute(attr) {\n return attr.replace(/\\\\/g, '\\\\\\\\').replace(/\\$/g, '\\\\$');\n }\n isElementSelector() {\n return this.hasElementSelector() && this.classNames.length == 0 && this.attrs.length == 0 &&\n this.notSelectors.length === 0;\n }\n hasElementSelector() {\n return !!this.element;\n }\n setElement(element = null) {\n this.element = element;\n }\n /** Gets a template string for an element that matches the selector. */\n getMatchingElementTemplate() {\n const tagName = this.element || 'div';\n const classAttr = this.classNames.length > 0 ? ` class=\"${this.classNames.join(' ')}\"` : '';\n let attrs = '';\n for (let i = 0; i < this.attrs.length; i += 2) {\n const attrName = this.attrs[i];\n const attrValue = this.attrs[i + 1] !== '' ? `=\"${this.attrs[i + 1]}\"` : '';\n attrs += ` ${attrName}${attrValue}`;\n }\n return getHtmlTagDefinition(tagName).isVoid ? `<${tagName}${classAttr}${attrs}/>` :\n `<${tagName}${classAttr}${attrs}>`;\n }\n getAttrs() {\n const result = [];\n if (this.classNames.length > 0) {\n result.push('class', this.classNames.join(' '));\n }\n return result.concat(this.attrs);\n }\n addAttribute(name, value = '') {\n this.attrs.push(name, value && value.toLowerCase() || '');\n }\n addClassName(name) {\n this.classNames.push(name.toLowerCase());\n }\n toString() {\n let res = this.element || '';\n if (this.classNames) {\n this.classNames.forEach(klass => res += `.${klass}`);\n }\n if (this.attrs) {\n for (let i = 0; i < this.attrs.length; i += 2) {\n const name = this.escapeAttribute(this.attrs[i]);\n const value = this.attrs[i + 1];\n res += `[${name}${value ? '=' + value : ''}]`;\n }\n }\n this.notSelectors.forEach(notSelector => res += `:not(${notSelector})`);\n return res;\n }\n}\n/**\n * Reads a list of CssSelectors and allows to calculate which ones\n * are contained in a given CssSelector.\n */\nclass SelectorMatcher {\n constructor() {\n this._elementMap = new Map();\n this._elementPartialMap = new Map();\n this._classMap = new Map();\n this._classPartialMap = new Map();\n this._attrValueMap = new Map();\n this._attrValuePartialMap = new Map();\n this._listContexts = [];\n }\n static createNotMatcher(notSelectors) {\n const notMatcher = new SelectorMatcher();\n notMatcher.addSelectables(notSelectors, null);\n return notMatcher;\n }\n addSelectables(cssSelectors, callbackCtxt) {\n let listContext = null;\n if (cssSelectors.length > 1) {\n listContext = new SelectorListContext(cssSelectors);\n this._listContexts.push(listContext);\n }\n for (let i = 0; i < cssSelectors.length; i++) {\n this._addSelectable(cssSelectors[i], callbackCtxt, listContext);\n }\n }\n /**\n * Add an object that can be found later on by calling `match`.\n * @param cssSelector A css selector\n * @param callbackCtxt An opaque object that will be given to the callback of the `match` function\n */\n _addSelectable(cssSelector, callbackCtxt, listContext) {\n let matcher = this;\n const element = cssSelector.element;\n const classNames = cssSelector.classNames;\n const attrs = cssSelector.attrs;\n const selectable = new SelectorContext(cssSelector, callbackCtxt, listContext);\n if (element) {\n const isTerminal = attrs.length === 0 && classNames.length === 0;\n if (isTerminal) {\n this._addTerminal(matcher._elementMap, element, selectable);\n }\n else {\n matcher = this._addPartial(matcher._elementPartialMap, element);\n }\n }\n if (classNames) {\n for (let i = 0; i < classNames.length; i++) {\n const isTerminal = attrs.length === 0 && i === classNames.length - 1;\n const className = classNames[i];\n if (isTerminal) {\n this._addTerminal(matcher._classMap, className, selectable);\n }\n else {\n matcher = this._addPartial(matcher._classPartialMap, className);\n }\n }\n }\n if (attrs) {\n for (let i = 0; i < attrs.length; i += 2) {\n const isTerminal = i === attrs.length - 2;\n const name = attrs[i];\n const value = attrs[i + 1];\n if (isTerminal) {\n const terminalMap = matcher._attrValueMap;\n let terminalValuesMap = terminalMap.get(name);\n if (!terminalValuesMap) {\n terminalValuesMap = new Map();\n terminalMap.set(name, terminalValuesMap);\n }\n this._addTerminal(terminalValuesMap, value, selectable);\n }\n else {\n const partialMap = matcher._attrValuePartialMap;\n let partialValuesMap = partialMap.get(name);\n if (!partialValuesMap) {\n partialValuesMap = new Map();\n partialMap.set(name, partialValuesMap);\n }\n matcher = this._addPartial(partialValuesMap, value);\n }\n }\n }\n }\n _addTerminal(map, name, selectable) {\n let terminalList = map.get(name);\n if (!terminalList) {\n terminalList = [];\n map.set(name, terminalList);\n }\n terminalList.push(selectable);\n }\n _addPartial(map, name) {\n let matcher = map.get(name);\n if (!matcher) {\n matcher = new SelectorMatcher();\n map.set(name, matcher);\n }\n return matcher;\n }\n /**\n * Find the objects that have been added via `addSelectable`\n * whose css selector is contained in the given css selector.\n * @param cssSelector A css selector\n * @param matchedCallback This callback will be called with the object handed into `addSelectable`\n * @return boolean true if a match was found\n */\n match(cssSelector, matchedCallback) {\n let result = false;\n const element = cssSelector.element;\n const classNames = cssSelector.classNames;\n const attrs = cssSelector.attrs;\n for (let i = 0; i < this._listContexts.length; i++) {\n this._listContexts[i].alreadyMatched = false;\n }\n result = this._matchTerminal(this._elementMap, element, cssSelector, matchedCallback) || result;\n result = this._matchPartial(this._elementPartialMap, element, cssSelector, matchedCallback) ||\n result;\n if (classNames) {\n for (let i = 0; i < classNames.length; i++) {\n const className = classNames[i];\n result =\n this._matchTerminal(this._classMap, className, cssSelector, matchedCallback) || result;\n result =\n this._matchPartial(this._classPartialMap, className, cssSelector, matchedCallback) ||\n result;\n }\n }\n if (attrs) {\n for (let i = 0; i < attrs.length; i += 2) {\n const name = attrs[i];\n const value = attrs[i + 1];\n const terminalValuesMap = this._attrValueMap.get(name);\n if (value) {\n result =\n this._matchTerminal(terminalValuesMap, '', cssSelector, matchedCallback) || result;\n }\n result =\n this._matchTerminal(terminalValuesMap, value, cssSelector, matchedCallback) || result;\n const partialValuesMap = this._attrValuePartialMap.get(name);\n if (value) {\n result = this._matchPartial(partialValuesMap, '', cssSelector, matchedCallback) || result;\n }\n result =\n this._matchPartial(partialValuesMap, value, cssSelector, matchedCallback) || result;\n }\n }\n return result;\n }\n /** @internal */\n _matchTerminal(map, name, cssSelector, matchedCallback) {\n if (!map || typeof name !== 'string') {\n return false;\n }\n let selectables = map.get(name) || [];\n const starSelectables = map.get('*');\n if (starSelectables) {\n selectables = selectables.concat(starSelectables);\n }\n if (selectables.length === 0) {\n return false;\n }\n let selectable;\n let result = false;\n for (let i = 0; i < selectables.length; i++) {\n selectable = selectables[i];\n result = selectable.finalize(cssSelector, matchedCallback) || result;\n }\n return result;\n }\n /** @internal */\n _matchPartial(map, name, cssSelector, matchedCallback) {\n if (!map || typeof name !== 'string') {\n return false;\n }\n const nestedSelector = map.get(name);\n if (!nestedSelector) {\n return false;\n }\n // TODO(perf): get rid of recursion and measure again\n // TODO(perf): don't pass the whole selector into the recursion,\n // but only the not processed parts\n return nestedSelector.match(cssSelector, matchedCallback);\n }\n}\nclass SelectorListContext {\n constructor(selectors) {\n this.selectors = selectors;\n this.alreadyMatched = false;\n }\n}\n// Store context to pass back selector and context when a selector is matched\nclass SelectorContext {\n constructor(selector, cbContext, listContext) {\n this.selector = selector;\n this.cbContext = cbContext;\n this.listContext = listContext;\n this.notSelectors = selector.notSelectors;\n }\n finalize(cssSelector, callback) {\n let result = true;\n if (this.notSelectors.length > 0 && (!this.listContext || !this.listContext.alreadyMatched)) {\n const notMatcher = SelectorMatcher.createNotMatcher(this.notSelectors);\n result = !notMatcher.match(cssSelector, null);\n }\n if (result && callback && (!this.listContext || !this.listContext.alreadyMatched)) {\n if (this.listContext) {\n this.listContext.alreadyMatched = true;\n }\n callback(this.selector, this.cbContext);\n }\n return result;\n }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// Stores the default value of `emitDistinctChangesOnly` when the `emitDistinctChangesOnly` is not\n// explicitly set.\nconst emitDistinctChangesOnlyDefaultValue = true;\nvar ViewEncapsulation;\n(function (ViewEncapsulation) {\n ViewEncapsulation[ViewEncapsulation[\"Emulated\"] = 0] = \"Emulated\";\n // Historically the 1 value was for `Native` encapsulation which has been removed as of v11.\n ViewEncapsulation[ViewEncapsulation[\"None\"] = 2] = \"None\";\n ViewEncapsulation[ViewEncapsulation[\"ShadowDom\"] = 3] = \"ShadowDom\";\n})(ViewEncapsulation || (ViewEncapsulation = {}));\nvar ChangeDetectionStrategy;\n(function (ChangeDetectionStrategy) {\n ChangeDetectionStrategy[ChangeDetectionStrategy[\"OnPush\"] = 0] = \"OnPush\";\n ChangeDetectionStrategy[ChangeDetectionStrategy[\"Default\"] = 1] = \"Default\";\n})(ChangeDetectionStrategy || (ChangeDetectionStrategy = {}));\nconst CUSTOM_ELEMENTS_SCHEMA = {\n name: 'custom-elements'\n};\nconst NO_ERRORS_SCHEMA = {\n name: 'no-errors-schema'\n};\nconst Type$1 = Function;\nvar SecurityContext;\n(function (SecurityContext) {\n SecurityContext[SecurityContext[\"NONE\"] = 0] = \"NONE\";\n SecurityContext[SecurityContext[\"HTML\"] = 1] = \"HTML\";\n SecurityContext[SecurityContext[\"STYLE\"] = 2] = \"STYLE\";\n SecurityContext[SecurityContext[\"SCRIPT\"] = 3] = \"SCRIPT\";\n SecurityContext[SecurityContext[\"URL\"] = 4] = \"URL\";\n SecurityContext[SecurityContext[\"RESOURCE_URL\"] = 5] = \"RESOURCE_URL\";\n})(SecurityContext || (SecurityContext = {}));\nvar MissingTranslationStrategy;\n(function (MissingTranslationStrategy) {\n MissingTranslationStrategy[MissingTranslationStrategy[\"Error\"] = 0] = \"Error\";\n MissingTranslationStrategy[MissingTranslationStrategy[\"Warning\"] = 1] = \"Warning\";\n MissingTranslationStrategy[MissingTranslationStrategy[\"Ignore\"] = 2] = \"Ignore\";\n})(MissingTranslationStrategy || (MissingTranslationStrategy = {}));\nfunction parserSelectorToSimpleSelector(selector) {\n const classes = selector.classNames && selector.classNames.length ?\n [8 /* CLASS */, ...selector.classNames] :\n [];\n const elementName = selector.element && selector.element !== '*' ? selector.element : '';\n return [elementName, ...selector.attrs, ...classes];\n}\nfunction parserSelectorToNegativeSelector(selector) {\n const classes = selector.classNames && selector.classNames.length ?\n [8 /* CLASS */, ...selector.classNames] :\n [];\n if (selector.element) {\n return [\n 1 /* NOT */ | 4 /* ELEMENT */, selector.element, ...selector.attrs, ...classes\n ];\n }\n else if (selector.attrs.length) {\n return [1 /* NOT */ | 2 /* ATTRIBUTE */, ...selector.attrs, ...classes];\n }\n else {\n return selector.classNames && selector.classNames.length ?\n [1 /* NOT */ | 8 /* CLASS */, ...selector.classNames] :\n [];\n }\n}\nfunction parserSelectorToR3Selector(selector) {\n const positive = parserSelectorToSimpleSelector(selector);\n const negative = selector.notSelectors && selector.notSelectors.length ?\n selector.notSelectors.map(notSelector => parserSelectorToNegativeSelector(notSelector)) :\n [];\n return positive.concat(...negative);\n}\nfunction parseSelectorToR3Selector(selector) {\n return selector ? CssSelector.parse(selector).map(parserSelectorToR3Selector) : [];\n}\n\nvar core = /*#__PURE__*/Object.freeze({\n __proto__: null,\n emitDistinctChangesOnlyDefaultValue: emitDistinctChangesOnlyDefaultValue,\n get ViewEncapsulation () { return ViewEncapsulation; },\n get ChangeDetectionStrategy () { return ChangeDetectionStrategy; },\n CUSTOM_ELEMENTS_SCHEMA: CUSTOM_ELEMENTS_SCHEMA,\n NO_ERRORS_SCHEMA: NO_ERRORS_SCHEMA,\n Type: Type$1,\n get SecurityContext () { return SecurityContext; },\n get MissingTranslationStrategy () { return MissingTranslationStrategy; },\n parseSelectorToR3Selector: parseSelectorToR3Selector\n});\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst DASH_CASE_REGEXP = /-+([a-z0-9])/g;\nfunction dashCaseToCamelCase(input) {\n return input.replace(DASH_CASE_REGEXP, (...m) => m[1].toUpperCase());\n}\nfunction splitAtColon(input, defaultValues) {\n return _splitAt(input, ':', defaultValues);\n}\nfunction splitAtPeriod(input, defaultValues) {\n return _splitAt(input, '.', defaultValues);\n}\nfunction _splitAt(input, character, defaultValues) {\n const characterIndex = input.indexOf(character);\n if (characterIndex == -1)\n return defaultValues;\n return [input.slice(0, characterIndex).trim(), input.slice(characterIndex + 1).trim()];\n}\nfunction noUndefined(val) {\n return val === undefined ? null : val;\n}\nfunction error(msg) {\n throw new Error(`Internal Error: ${msg}`);\n}\n// Escape characters that have a special meaning in Regular Expressions\nfunction escapeRegExp(s) {\n return s.replace(/([.*+?^=!:${}()|[\\]\\/\\\\])/g, '\\\\$1');\n}\nfunction utf8Encode(str) {\n let encoded = [];\n for (let index = 0; index < str.length; index++) {\n let codePoint = str.charCodeAt(index);\n // decode surrogate\n // see https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n if (codePoint >= 0xd800 && codePoint <= 0xdbff && str.length > (index + 1)) {\n const low = str.charCodeAt(index + 1);\n if (low >= 0xdc00 && low <= 0xdfff) {\n index++;\n codePoint = ((codePoint - 0xd800) << 10) + low - 0xdc00 + 0x10000;\n }\n }\n if (codePoint <= 0x7f) {\n encoded.push(codePoint);\n }\n else if (codePoint <= 0x7ff) {\n encoded.push(((codePoint >> 6) & 0x1F) | 0xc0, (codePoint & 0x3f) | 0x80);\n }\n else if (codePoint <= 0xffff) {\n encoded.push((codePoint >> 12) | 0xe0, ((codePoint >> 6) & 0x3f) | 0x80, (codePoint & 0x3f) | 0x80);\n }\n else if (codePoint <= 0x1fffff) {\n encoded.push(((codePoint >> 18) & 0x07) | 0xf0, ((codePoint >> 12) & 0x3f) | 0x80, ((codePoint >> 6) & 0x3f) | 0x80, (codePoint & 0x3f) | 0x80);\n }\n }\n return encoded;\n}\nfunction stringify(token) {\n if (typeof token === 'string') {\n return token;\n }\n if (Array.isArray(token)) {\n return '[' + token.map(stringify).join(', ') + ']';\n }\n if (token == null) {\n return '' + token;\n }\n if (token.overriddenName) {\n return `${token.overriddenName}`;\n }\n if (token.name) {\n return `${token.name}`;\n }\n if (!token.toString) {\n return 'object';\n }\n // WARNING: do not try to `JSON.stringify(token)` here\n // see https://github.com/angular/angular/issues/23440\n const res = token.toString();\n if (res == null) {\n return '' + res;\n }\n const newLineIndex = res.indexOf('\\n');\n return newLineIndex === -1 ? res : res.substring(0, newLineIndex);\n}\nclass Version {\n constructor(full) {\n this.full = full;\n const splits = full.split('.');\n this.major = splits[0];\n this.minor = splits[1];\n this.patch = splits.slice(2).join('.');\n }\n}\nconst __window = typeof window !== 'undefined' && window;\nconst __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&\n self instanceof WorkerGlobalScope && self;\nconst __global = typeof global !== 'undefined' && global;\n// Check __global first, because in Node tests both __global and __window may be defined and _global\n// should be __global in that case.\nconst _global = __global || __window || __self;\nfunction newArray(size, value) {\n const list = [];\n for (let i = 0; i < size; i++) {\n list.push(value);\n }\n return list;\n}\n/**\n * Partitions a given array into 2 arrays, based on a boolean value returned by the condition\n * function.\n *\n * @param arr Input array that should be partitioned\n * @param conditionFn Condition function that is called for each item in a given array and returns a\n * boolean value.\n */\nfunction partitionArray(arr, conditionFn) {\n const truthy = [];\n const falsy = [];\n for (const item of arr) {\n (conditionFn(item) ? truthy : falsy).push(item);\n }\n return [truthy, falsy];\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Represents a big integer using a buffer of its individual digits, with the least significant\n * digit stored at the beginning of the array (little endian).\n *\n * For performance reasons, each instance is mutable. The addition operation can be done in-place\n * to reduce memory pressure of allocation for the digits array.\n */\nclass BigInteger {\n /**\n * Creates a big integer using its individual digits in little endian storage.\n */\n constructor(digits) {\n this.digits = digits;\n }\n static zero() {\n return new BigInteger([0]);\n }\n static one() {\n return new BigInteger([1]);\n }\n /**\n * Creates a clone of this instance.\n */\n clone() {\n return new BigInteger(this.digits.slice());\n }\n /**\n * Returns a new big integer with the sum of `this` and `other` as its value. This does not mutate\n * `this` but instead returns a new instance, unlike `addToSelf`.\n */\n add(other) {\n const result = this.clone();\n result.addToSelf(other);\n return result;\n }\n /**\n * Adds `other` to the instance itself, thereby mutating its value.\n */\n addToSelf(other) {\n const maxNrOfDigits = Math.max(this.digits.length, other.digits.length);\n let carry = 0;\n for (let i = 0; i < maxNrOfDigits; i++) {\n let digitSum = carry;\n if (i < this.digits.length) {\n digitSum += this.digits[i];\n }\n if (i < other.digits.length) {\n digitSum += other.digits[i];\n }\n if (digitSum >= 10) {\n this.digits[i] = digitSum - 10;\n carry = 1;\n }\n else {\n this.digits[i] = digitSum;\n carry = 0;\n }\n }\n // Apply a remaining carry if needed.\n if (carry > 0) {\n this.digits[maxNrOfDigits] = 1;\n }\n }\n /**\n * Builds the decimal string representation of the big integer. As this is stored in\n * little endian, the digits are concatenated in reverse order.\n */\n toString() {\n let res = '';\n for (let i = this.digits.length - 1; i >= 0; i--) {\n res += this.digits[i];\n }\n return res;\n }\n}\n/**\n * Represents a big integer which is optimized for multiplication operations, as its power-of-twos\n * are memoized. See `multiplyBy()` for details on the multiplication algorithm.\n */\nclass BigIntForMultiplication {\n constructor(value) {\n this.powerOfTwos = [value];\n }\n /**\n * Returns the big integer itself.\n */\n getValue() {\n return this.powerOfTwos[0];\n }\n /**\n * Computes the value for `num * b`, where `num` is a JS number and `b` is a big integer. The\n * value for `b` is represented by a storage model that is optimized for this computation.\n *\n * This operation is implemented in N(log2(num)) by continuous halving of the number, where the\n * least-significant bit (LSB) is tested in each iteration. If the bit is set, the bit's index is\n * used as exponent into the power-of-two multiplication of `b`.\n *\n * As an example, consider the multiplication num=42, b=1337. In binary 42 is 0b00101010 and the\n * algorithm unrolls into the following iterations:\n *\n * Iteration | num | LSB | b * 2^iter | Add? | product\n * -----------|------------|------|------------|------|--------\n * 0 | 0b00101010 | 0 | 1337 | No | 0\n * 1 | 0b00010101 | 1 | 2674 | Yes | 2674\n * 2 | 0b00001010 | 0 | 5348 | No | 2674\n * 3 | 0b00000101 | 1 | 10696 | Yes | 13370\n * 4 | 0b00000010 | 0 | 21392 | No | 13370\n * 5 | 0b00000001 | 1 | 42784 | Yes | 56154\n * 6 | 0b00000000 | 0 | 85568 | No | 56154\n *\n * The computed product of 56154 is indeed the correct result.\n *\n * The `BigIntForMultiplication` representation for a big integer provides memoized access to the\n * power-of-two values to reduce the workload in computing those values.\n */\n multiplyBy(num) {\n const product = BigInteger.zero();\n this.multiplyByAndAddTo(num, product);\n return product;\n }\n /**\n * See `multiplyBy()` for details. This function allows for the computed product to be added\n * directly to the provided result big integer.\n */\n multiplyByAndAddTo(num, result) {\n for (let exponent = 0; num !== 0; num = num >>> 1, exponent++) {\n if (num & 1) {\n const value = this.getMultipliedByPowerOfTwo(exponent);\n result.addToSelf(value);\n }\n }\n }\n /**\n * Computes and memoizes the big integer value for `this.number * 2^exponent`.\n */\n getMultipliedByPowerOfTwo(exponent) {\n // Compute the powers up until the requested exponent, where each value is computed from its\n // predecessor. This is simple as `this.number * 2^(exponent - 1)` only has to be doubled (i.e.\n // added to itself) to reach `this.number * 2^exponent`.\n for (let i = this.powerOfTwos.length; i <= exponent; i++) {\n const previousPower = this.powerOfTwos[i - 1];\n this.powerOfTwos[i] = previousPower.add(previousPower);\n }\n return this.powerOfTwos[exponent];\n }\n}\n/**\n * Represents an exponentiation operation for the provided base, of which exponents are computed and\n * memoized. The results are represented by a `BigIntForMultiplication` which is tailored for\n * multiplication operations by memoizing the power-of-twos. This effectively results in a matrix\n * representation that is lazily computed upon request.\n */\nclass BigIntExponentiation {\n constructor(base) {\n this.base = base;\n this.exponents = [new BigIntForMultiplication(BigInteger.one())];\n }\n /**\n * Compute the value for `this.base^exponent`, resulting in a big integer that is optimized for\n * further multiplication operations.\n */\n toThePowerOf(exponent) {\n // Compute the results up until the requested exponent, where every value is computed from its\n // predecessor. This is because `this.base^(exponent - 1)` only has to be multiplied by `base`\n // to reach `this.base^exponent`.\n for (let i = this.exponents.length; i <= exponent; i++) {\n const value = this.exponents[i - 1].multiplyBy(this.base);\n this.exponents[i] = new BigIntForMultiplication(value);\n }\n return this.exponents[exponent];\n }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Return the message id or compute it using the XLIFF1 digest.\n */\nfunction digest$1(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 `` :\n `${ph.children.map(child => child.visit(this)).join(', ')}`;\n }\n visitPlaceholder(ph, context) {\n return ph.value ? `${ph.value}` : ``;\n }\n visitIcuPlaceholder(ph, context) {\n return `${ph.value.visit(this)}`;\n }\n}\nconst serializerVisitor$1 = new _SerializerVisitor();\nfunction serializeNodes(nodes) {\n return nodes.map(a => a.visit(serializerVisitor$1, 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 const utf8 = utf8Encode(str);\n const words32 = bytesToWords32(utf8, Endian.Big);\n const len = utf8.length * 8;\n const w = newArray(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 return bytesToHexString(words32ToByteString([a, b, c, d, e]));\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 const utf8 = utf8Encode(str);\n let hi = hash32(utf8, 0);\n let lo = hash32(utf8, 102072);\n if (hi == 0 && (lo == 0 || lo == 1)) {\n hi = hi ^ 0x130f9bef;\n lo = lo ^ -0x6b5f56d8;\n }\n return [hi, lo];\n}\nfunction computeMsgId(msg, meaning = '') {\n let msgFingerprint = fingerprint(msg);\n if (meaning) {\n const meaningFingerprint = fingerprint(meaning);\n msgFingerprint = add64(rol64(msgFingerprint, 1), meaningFingerprint);\n }\n const hi = msgFingerprint[0];\n const lo = msgFingerprint[1];\n return wordsToDecimalString(hi & 0x7fffffff, lo);\n}\nfunction hash32(bytes, c) {\n let a = 0x9e3779b9, b = 0x9e3779b9;\n let i;\n const len = bytes.length;\n for (i = 0; i + 12 <= len; i += 12) {\n a = add32(a, wordAt(bytes, i, Endian.Little));\n b = add32(b, wordAt(bytes, i + 4, Endian.Little));\n c = add32(c, wordAt(bytes, i + 8, Endian.Little));\n const res = mix(a, b, c);\n a = res[0], b = res[1], c = res[2];\n }\n a = add32(a, wordAt(bytes, i, Endian.Little));\n b = add32(b, wordAt(bytes, i + 4, Endian.Little));\n // the first byte of c is reserved for the length\n c = add32(c, len);\n c = add32(c, wordAt(bytes, i + 8, Endian.Little) << 8);\n return mix(a, b, c)[2];\n}\n// clang-format off\nfunction mix(a, b, c) {\n a = sub32(a, b);\n a = sub32(a, c);\n a ^= c >>> 13;\n b = sub32(b, c);\n b = sub32(b, a);\n b ^= a << 8;\n c = sub32(c, a);\n c = sub32(c, b);\n c ^= b >>> 13;\n a = sub32(a, b);\n a = sub32(a, c);\n a ^= c >>> 12;\n b = sub32(b, c);\n b = sub32(b, a);\n b ^= a << 16;\n c = sub32(c, a);\n c = sub32(c, b);\n c ^= b >>> 5;\n a = sub32(a, b);\n a = sub32(a, c);\n a ^= c >>> 3;\n b = sub32(b, c);\n b = sub32(b, a);\n b ^= a << 10;\n c = sub32(c, a);\n c = sub32(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}\nfunction add64(a, b) {\n const ah = a[0], al = a[1];\n const bh = b[0], bl = b[1];\n const result = add32to64(al, bl);\n const carry = result[0];\n const l = result[1];\n const h = add32(add32(ah, bh), carry);\n return [h, l];\n}\nfunction sub32(a, b) {\n const low = (a & 0xffff) - (b & 0xffff);\n const high = (a >> 16) - (b >> 16) + (low >> 16);\n return (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}\n// Rotate a 64b number left `count` position\nfunction rol64(num, count) {\n const hi = num[0], lo = num[1];\n const h = (hi << count) | (lo >>> (32 - count));\n const l = (lo << count) | (hi >>> (32 - count));\n return [h, l];\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}\nfunction words32ToByteString(words32) {\n return words32.reduce((bytes, word) => bytes.concat(word32ToByteString(word)), []);\n}\nfunction word32ToByteString(word) {\n let bytes = [];\n for (let i = 0; i < 4; i++) {\n bytes.push((word >>> 8 * (3 - i)) & 0xff);\n }\n return bytes;\n}\nfunction bytesToHexString(bytes) {\n let hex = '';\n for (let i = 0; i < bytes.length; i++) {\n const b = byteAt(bytes, i);\n hex += (b >>> 4).toString(16) + (b & 0x0f).toString(16);\n }\n return hex.toLowerCase();\n}\n/**\n * Create a shared exponentiation pool for base-256 computations. This shared pool provides memoized\n * power-of-256 results with memoized power-of-two computations for efficient multiplication.\n *\n * For our purposes, this can be safely stored as a global without memory concerns. The reason is\n * that we encode two words, so only need the 0th (for the low word) and 4th (for the high word)\n * exponent.\n */\nconst base256 = new BigIntExponentiation(256);\n/**\n * Represents two 32-bit words as a single decimal number. This requires a big integer storage\n * model as JS numbers are not accurate enough to represent the 64-bit number.\n *\n * Based on https://www.danvk.org/hex2dec.html\n */\nfunction wordsToDecimalString(hi, lo) {\n // Encode the four bytes in lo in the lower digits of the decimal number.\n // Note: the multiplication results in lo itself but represented by a big integer using its\n // decimal digits.\n const decimal = base256.toThePowerOf(0).multiplyBy(lo);\n // Encode the four bytes in hi above the four lo bytes. lo is a maximum of (2^8)^4, which is why\n // this multiplication factor is applied.\n base256.toThePowerOf(4).multiplyByAndAddTo(hi, decimal);\n return decimal.toString();\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n//// Types\nvar TypeModifier;\n(function (TypeModifier) {\n TypeModifier[TypeModifier[\"None\"] = 0] = \"None\";\n TypeModifier[TypeModifier[\"Const\"] = 1] = \"Const\";\n})(TypeModifier || (TypeModifier = {}));\nclass Type {\n constructor(modifiers = TypeModifier.None) {\n this.modifiers = modifiers;\n }\n hasModifier(modifier) {\n return (this.modifiers & modifier) !== 0;\n }\n}\nvar BuiltinTypeName;\n(function (BuiltinTypeName) {\n BuiltinTypeName[BuiltinTypeName[\"Dynamic\"] = 0] = \"Dynamic\";\n BuiltinTypeName[BuiltinTypeName[\"Bool\"] = 1] = \"Bool\";\n BuiltinTypeName[BuiltinTypeName[\"String\"] = 2] = \"String\";\n BuiltinTypeName[BuiltinTypeName[\"Int\"] = 3] = \"Int\";\n BuiltinTypeName[BuiltinTypeName[\"Number\"] = 4] = \"Number\";\n BuiltinTypeName[BuiltinTypeName[\"Function\"] = 5] = \"Function\";\n BuiltinTypeName[BuiltinTypeName[\"Inferred\"] = 6] = \"Inferred\";\n BuiltinTypeName[BuiltinTypeName[\"None\"] = 7] = \"None\";\n})(BuiltinTypeName || (BuiltinTypeName = {}));\nclass BuiltinType extends Type {\n constructor(name, modifiers) {\n super(modifiers);\n this.name = name;\n }\n visitType(visitor, context) {\n return visitor.visitBuiltinType(this, context);\n }\n}\nclass ExpressionType extends Type {\n constructor(value, modifiers, typeParams = null) {\n super(modifiers);\n this.value = value;\n this.typeParams = typeParams;\n }\n visitType(visitor, context) {\n return visitor.visitExpressionType(this, context);\n }\n}\nclass ArrayType extends Type {\n constructor(of, modifiers) {\n super(modifiers);\n this.of = of;\n }\n visitType(visitor, context) {\n return visitor.visitArrayType(this, context);\n }\n}\nclass MapType extends Type {\n constructor(valueType, modifiers) {\n super(modifiers);\n this.valueType = valueType || null;\n }\n visitType(visitor, context) {\n return visitor.visitMapType(this, context);\n }\n}\nconst DYNAMIC_TYPE = new BuiltinType(BuiltinTypeName.Dynamic);\nconst INFERRED_TYPE = new BuiltinType(BuiltinTypeName.Inferred);\nconst BOOL_TYPE = new BuiltinType(BuiltinTypeName.Bool);\nconst INT_TYPE = new BuiltinType(BuiltinTypeName.Int);\nconst NUMBER_TYPE = new BuiltinType(BuiltinTypeName.Number);\nconst STRING_TYPE = new BuiltinType(BuiltinTypeName.String);\nconst FUNCTION_TYPE = new BuiltinType(BuiltinTypeName.Function);\nconst NONE_TYPE = new BuiltinType(BuiltinTypeName.None);\n///// Expressions\nvar UnaryOperator;\n(function (UnaryOperator) {\n UnaryOperator[UnaryOperator[\"Minus\"] = 0] = \"Minus\";\n UnaryOperator[UnaryOperator[\"Plus\"] = 1] = \"Plus\";\n})(UnaryOperator || (UnaryOperator = {}));\nvar BinaryOperator;\n(function (BinaryOperator) {\n BinaryOperator[BinaryOperator[\"Equals\"] = 0] = \"Equals\";\n BinaryOperator[BinaryOperator[\"NotEquals\"] = 1] = \"NotEquals\";\n BinaryOperator[BinaryOperator[\"Identical\"] = 2] = \"Identical\";\n BinaryOperator[BinaryOperator[\"NotIdentical\"] = 3] = \"NotIdentical\";\n BinaryOperator[BinaryOperator[\"Minus\"] = 4] = \"Minus\";\n BinaryOperator[BinaryOperator[\"Plus\"] = 5] = \"Plus\";\n BinaryOperator[BinaryOperator[\"Divide\"] = 6] = \"Divide\";\n BinaryOperator[BinaryOperator[\"Multiply\"] = 7] = \"Multiply\";\n BinaryOperator[BinaryOperator[\"Modulo\"] = 8] = \"Modulo\";\n BinaryOperator[BinaryOperator[\"And\"] = 9] = \"And\";\n BinaryOperator[BinaryOperator[\"Or\"] = 10] = \"Or\";\n BinaryOperator[BinaryOperator[\"BitwiseAnd\"] = 11] = \"BitwiseAnd\";\n BinaryOperator[BinaryOperator[\"Lower\"] = 12] = \"Lower\";\n BinaryOperator[BinaryOperator[\"LowerEquals\"] = 13] = \"LowerEquals\";\n BinaryOperator[BinaryOperator[\"Bigger\"] = 14] = \"Bigger\";\n BinaryOperator[BinaryOperator[\"BiggerEquals\"] = 15] = \"BiggerEquals\";\n BinaryOperator[BinaryOperator[\"NullishCoalesce\"] = 16] = \"NullishCoalesce\";\n})(BinaryOperator || (BinaryOperator = {}));\nfunction nullSafeIsEquivalent(base, other) {\n if (base == null || other == null) {\n return base == other;\n }\n return base.isEquivalent(other);\n}\nfunction areAllEquivalentPredicate(base, other, equivalentPredicate) {\n const len = base.length;\n if (len !== other.length) {\n return false;\n }\n for (let i = 0; i < len; i++) {\n if (!equivalentPredicate(base[i], other[i])) {\n return false;\n }\n }\n return true;\n}\nfunction areAllEquivalent(base, other) {\n return areAllEquivalentPredicate(base, other, (baseElement, otherElement) => baseElement.isEquivalent(otherElement));\n}\nclass Expression {\n constructor(type, sourceSpan) {\n this.type = type || null;\n this.sourceSpan = sourceSpan || null;\n }\n prop(name, sourceSpan) {\n return new ReadPropExpr(this, name, null, sourceSpan);\n }\n key(index, type, sourceSpan) {\n return new ReadKeyExpr(this, index, type, sourceSpan);\n }\n callFn(params, sourceSpan, pure) {\n return new InvokeFunctionExpr(this, params, null, sourceSpan, pure);\n }\n instantiate(params, type, sourceSpan) {\n return new InstantiateExpr(this, params, type, sourceSpan);\n }\n conditional(trueCase, falseCase = null, sourceSpan) {\n return new ConditionalExpr(this, trueCase, falseCase, null, sourceSpan);\n }\n equals(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.Equals, this, rhs, null, sourceSpan);\n }\n notEquals(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.NotEquals, this, rhs, null, sourceSpan);\n }\n identical(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.Identical, this, rhs, null, sourceSpan);\n }\n notIdentical(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.NotIdentical, this, rhs, null, sourceSpan);\n }\n minus(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.Minus, this, rhs, null, sourceSpan);\n }\n plus(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.Plus, this, rhs, null, sourceSpan);\n }\n divide(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.Divide, this, rhs, null, sourceSpan);\n }\n multiply(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.Multiply, this, rhs, null, sourceSpan);\n }\n modulo(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.Modulo, this, rhs, null, sourceSpan);\n }\n and(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.And, this, rhs, null, sourceSpan);\n }\n bitwiseAnd(rhs, sourceSpan, parens = true) {\n return new BinaryOperatorExpr(BinaryOperator.BitwiseAnd, this, rhs, null, sourceSpan, parens);\n }\n or(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.Or, this, rhs, null, sourceSpan);\n }\n lower(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.Lower, this, rhs, null, sourceSpan);\n }\n lowerEquals(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.LowerEquals, this, rhs, null, sourceSpan);\n }\n bigger(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.Bigger, this, rhs, null, sourceSpan);\n }\n biggerEquals(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.BiggerEquals, this, rhs, null, sourceSpan);\n }\n isBlank(sourceSpan) {\n // Note: We use equals by purpose here to compare to null and undefined in JS.\n // We use the typed null to allow strictNullChecks to narrow types.\n return this.equals(TYPED_NULL_EXPR, sourceSpan);\n }\n nullishCoalesce(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.NullishCoalesce, this, rhs, null, sourceSpan);\n }\n toStmt() {\n return new ExpressionStatement(this, null);\n }\n}\nclass ReadVarExpr extends Expression {\n constructor(name, type, sourceSpan) {\n super(type, sourceSpan);\n this.name = name;\n }\n isEquivalent(e) {\n return e instanceof ReadVarExpr && this.name === e.name;\n }\n isConstant() {\n return false;\n }\n visitExpression(visitor, context) {\n return visitor.visitReadVarExpr(this, context);\n }\n set(value) {\n return new WriteVarExpr(this.name, value, null, this.sourceSpan);\n }\n}\nclass TypeofExpr extends Expression {\n constructor(expr, type, sourceSpan) {\n super(type, sourceSpan);\n this.expr = expr;\n }\n visitExpression(visitor, context) {\n return visitor.visitTypeofExpr(this, context);\n }\n isEquivalent(e) {\n return e instanceof TypeofExpr && e.expr.isEquivalent(this.expr);\n }\n isConstant() {\n return this.expr.isConstant();\n }\n}\nclass WrappedNodeExpr extends Expression {\n constructor(node, type, sourceSpan) {\n super(type, sourceSpan);\n this.node = node;\n }\n isEquivalent(e) {\n return e instanceof WrappedNodeExpr && this.node === e.node;\n }\n isConstant() {\n return false;\n }\n visitExpression(visitor, context) {\n return visitor.visitWrappedNodeExpr(this, context);\n }\n}\nclass WriteVarExpr extends Expression {\n constructor(name, value, type, sourceSpan) {\n super(type || value.type, sourceSpan);\n this.name = name;\n this.value = value;\n }\n isEquivalent(e) {\n return e instanceof WriteVarExpr && this.name === e.name && this.value.isEquivalent(e.value);\n }\n isConstant() {\n return false;\n }\n visitExpression(visitor, context) {\n return visitor.visitWriteVarExpr(this, context);\n }\n toDeclStmt(type, modifiers) {\n return new DeclareVarStmt(this.name, this.value, type, modifiers, this.sourceSpan);\n }\n toConstDecl() {\n return this.toDeclStmt(INFERRED_TYPE, StmtModifier.Final);\n }\n}\nclass WriteKeyExpr extends Expression {\n constructor(receiver, index, value, type, sourceSpan) {\n super(type || value.type, sourceSpan);\n this.receiver = receiver;\n this.index = index;\n this.value = value;\n }\n isEquivalent(e) {\n return e instanceof WriteKeyExpr && this.receiver.isEquivalent(e.receiver) &&\n this.index.isEquivalent(e.index) && this.value.isEquivalent(e.value);\n }\n isConstant() {\n return false;\n }\n visitExpression(visitor, context) {\n return visitor.visitWriteKeyExpr(this, context);\n }\n}\nclass WritePropExpr extends Expression {\n constructor(receiver, name, value, type, sourceSpan) {\n super(type || value.type, sourceSpan);\n this.receiver = receiver;\n this.name = name;\n this.value = value;\n }\n isEquivalent(e) {\n return e instanceof WritePropExpr && this.receiver.isEquivalent(e.receiver) &&\n this.name === e.name && this.value.isEquivalent(e.value);\n }\n isConstant() {\n return false;\n }\n visitExpression(visitor, context) {\n return visitor.visitWritePropExpr(this, context);\n }\n}\nclass InvokeFunctionExpr extends Expression {\n constructor(fn, args, type, sourceSpan, pure = false) {\n super(type, sourceSpan);\n this.fn = fn;\n this.args = args;\n this.pure = pure;\n }\n isEquivalent(e) {\n return e instanceof InvokeFunctionExpr && this.fn.isEquivalent(e.fn) &&\n areAllEquivalent(this.args, e.args) && this.pure === e.pure;\n }\n isConstant() {\n return false;\n }\n visitExpression(visitor, context) {\n return visitor.visitInvokeFunctionExpr(this, context);\n }\n}\nclass TaggedTemplateExpr extends Expression {\n constructor(tag, template, type, sourceSpan) {\n super(type, sourceSpan);\n this.tag = tag;\n this.template = template;\n }\n isEquivalent(e) {\n return e instanceof TaggedTemplateExpr && this.tag.isEquivalent(e.tag) &&\n areAllEquivalentPredicate(this.template.elements, e.template.elements, (a, b) => a.text === b.text) &&\n areAllEquivalent(this.template.expressions, e.template.expressions);\n }\n isConstant() {\n return false;\n }\n visitExpression(visitor, context) {\n return visitor.visitTaggedTemplateExpr(this, context);\n }\n}\nclass InstantiateExpr extends Expression {\n constructor(classExpr, args, type, sourceSpan) {\n super(type, sourceSpan);\n this.classExpr = classExpr;\n this.args = args;\n }\n isEquivalent(e) {\n return e instanceof InstantiateExpr && this.classExpr.isEquivalent(e.classExpr) &&\n areAllEquivalent(this.args, e.args);\n }\n isConstant() {\n return false;\n }\n visitExpression(visitor, context) {\n return visitor.visitInstantiateExpr(this, context);\n }\n}\nclass LiteralExpr extends Expression {\n constructor(value, type, sourceSpan) {\n super(type, sourceSpan);\n this.value = value;\n }\n isEquivalent(e) {\n return e instanceof LiteralExpr && this.value === e.value;\n }\n isConstant() {\n return true;\n }\n visitExpression(visitor, context) {\n return visitor.visitLiteralExpr(this, context);\n }\n}\nclass TemplateLiteral {\n constructor(elements, expressions) {\n this.elements = elements;\n this.expressions = expressions;\n }\n}\nclass TemplateLiteralElement {\n constructor(text, sourceSpan, rawText) {\n this.text = text;\n this.sourceSpan = sourceSpan;\n // If `rawText` is not provided, try to extract the raw string from its\n // associated `sourceSpan`. If that is also not available, \"fake\" the raw\n // string instead by escaping the following control sequences:\n // - \"\\\" would otherwise indicate that the next character is a control character.\n // - \"`\" and \"${\" are template string control sequences that would otherwise prematurely\n // indicate the end of the template literal element.\n this.rawText =\n rawText ?? sourceSpan?.toString() ?? escapeForTemplateLiteral(escapeSlashes(text));\n }\n}\nclass LiteralPiece {\n constructor(text, sourceSpan) {\n this.text = text;\n this.sourceSpan = sourceSpan;\n }\n}\nclass PlaceholderPiece {\n /**\n * Create a new instance of a `PlaceholderPiece`.\n *\n * @param text the name of this placeholder (e.g. `PH_1`).\n * @param sourceSpan the location of this placeholder in its localized message the source code.\n * @param associatedMessage reference to another message that this placeholder is associated with.\n * The `associatedMessage` is mainly used to provide a relationship to an ICU message that has\n * been extracted out from the message containing the placeholder.\n */\n constructor(text, sourceSpan, associatedMessage) {\n this.text = text;\n this.sourceSpan = sourceSpan;\n this.associatedMessage = associatedMessage;\n }\n}\nconst MEANING_SEPARATOR$1 = '|';\nconst ID_SEPARATOR$1 = '@@';\nconst LEGACY_ID_INDICATOR = '␟';\nclass LocalizedString extends Expression {\n constructor(metaBlock, messageParts, placeHolderNames, expressions, sourceSpan) {\n super(STRING_TYPE, sourceSpan);\n this.metaBlock = metaBlock;\n this.messageParts = messageParts;\n this.placeHolderNames = placeHolderNames;\n this.expressions = expressions;\n }\n isEquivalent(e) {\n // return e instanceof LocalizedString && this.message === e.message;\n return false;\n }\n isConstant() {\n return false;\n }\n visitExpression(visitor, context) {\n return visitor.visitLocalizedString(this, context);\n }\n /**\n * Serialize the given `meta` and `messagePart` into \"cooked\" and \"raw\" strings that can be used\n * in a `$localize` tagged string. The format of the metadata is the same as that parsed by\n * `parseI18nMeta()`.\n *\n * @param meta The metadata to serialize\n * @param messagePart The first part of the tagged string\n */\n serializeI18nHead() {\n let metaBlock = this.metaBlock.description || '';\n if (this.metaBlock.meaning) {\n metaBlock = `${this.metaBlock.meaning}${MEANING_SEPARATOR$1}${metaBlock}`;\n }\n if (this.metaBlock.customId) {\n metaBlock = `${metaBlock}${ID_SEPARATOR$1}${this.metaBlock.customId}`;\n }\n if (this.metaBlock.legacyIds) {\n this.metaBlock.legacyIds.forEach(legacyId => {\n metaBlock = `${metaBlock}${LEGACY_ID_INDICATOR}${legacyId}`;\n });\n }\n return createCookedRawString(metaBlock, this.messageParts[0].text, this.getMessagePartSourceSpan(0));\n }\n getMessagePartSourceSpan(i) {\n return this.messageParts[i]?.sourceSpan ?? this.sourceSpan;\n }\n getPlaceholderSourceSpan(i) {\n return this.placeHolderNames[i]?.sourceSpan ?? this.expressions[i]?.sourceSpan ??\n this.sourceSpan;\n }\n /**\n * Serialize the given `placeholderName` and `messagePart` into \"cooked\" and \"raw\" strings that\n * can be used in a `$localize` tagged string.\n *\n * The format is `:[@@]:`.\n *\n * The `associated-id` is the message id of the (usually an ICU) message to which this placeholder\n * refers.\n *\n * @param partIndex The index of the message part to serialize.\n */\n serializeI18nTemplatePart(partIndex) {\n const placeholder = this.placeHolderNames[partIndex - 1];\n const messagePart = this.messageParts[partIndex];\n let metaBlock = placeholder.text;\n if (placeholder.associatedMessage?.legacyIds.length === 0) {\n metaBlock += `${ID_SEPARATOR$1}${computeMsgId(placeholder.associatedMessage.messageString, placeholder.associatedMessage.meaning)}`;\n }\n return createCookedRawString(metaBlock, messagePart.text, this.getMessagePartSourceSpan(partIndex));\n }\n}\nconst escapeSlashes = (str) => str.replace(/\\\\/g, '\\\\\\\\');\nconst escapeStartingColon = (str) => str.replace(/^:/, '\\\\:');\nconst escapeColons = (str) => str.replace(/:/g, '\\\\:');\nconst escapeForTemplateLiteral = (str) => str.replace(/`/g, '\\\\`').replace(/\\${/g, '$\\\\{');\n/**\n * Creates a `{cooked, raw}` object from the `metaBlock` and `messagePart`.\n *\n * The `raw` text must have various character sequences escaped:\n * * \"\\\" would otherwise indicate that the next character is a control character.\n * * \"`\" and \"${\" are template string control sequences that would otherwise prematurely indicate\n * the end of a message part.\n * * \":\" inside a metablock would prematurely indicate the end of the metablock.\n * * \":\" at the start of a messagePart with no metablock would erroneously indicate the start of a\n * metablock.\n *\n * @param metaBlock Any metadata that should be prepended to the string\n * @param messagePart The message part of the string\n */\nfunction createCookedRawString(metaBlock, messagePart, range) {\n if (metaBlock === '') {\n return {\n cooked: messagePart,\n raw: escapeForTemplateLiteral(escapeStartingColon(escapeSlashes(messagePart))),\n range,\n };\n }\n else {\n return {\n cooked: `:${metaBlock}:${messagePart}`,\n raw: escapeForTemplateLiteral(`:${escapeColons(escapeSlashes(metaBlock))}:${escapeSlashes(messagePart)}`),\n range,\n };\n }\n}\nclass ExternalExpr extends Expression {\n constructor(value, type, typeParams = null, sourceSpan) {\n super(type, sourceSpan);\n this.value = value;\n this.typeParams = typeParams;\n }\n isEquivalent(e) {\n return e instanceof ExternalExpr && this.value.name === e.value.name &&\n this.value.moduleName === e.value.moduleName && this.value.runtime === e.value.runtime;\n }\n isConstant() {\n return false;\n }\n visitExpression(visitor, context) {\n return visitor.visitExternalExpr(this, context);\n }\n}\nclass ExternalReference {\n constructor(moduleName, name, runtime) {\n this.moduleName = moduleName;\n this.name = name;\n this.runtime = runtime;\n }\n}\nclass ConditionalExpr extends Expression {\n constructor(condition, trueCase, falseCase = null, type, sourceSpan) {\n super(type || trueCase.type, sourceSpan);\n this.condition = condition;\n this.falseCase = falseCase;\n this.trueCase = trueCase;\n }\n isEquivalent(e) {\n return e instanceof ConditionalExpr && this.condition.isEquivalent(e.condition) &&\n this.trueCase.isEquivalent(e.trueCase) && nullSafeIsEquivalent(this.falseCase, e.falseCase);\n }\n isConstant() {\n return false;\n }\n visitExpression(visitor, context) {\n return visitor.visitConditionalExpr(this, context);\n }\n}\nclass NotExpr extends Expression {\n constructor(condition, sourceSpan) {\n super(BOOL_TYPE, sourceSpan);\n this.condition = condition;\n }\n isEquivalent(e) {\n return e instanceof NotExpr && this.condition.isEquivalent(e.condition);\n }\n isConstant() {\n return false;\n }\n visitExpression(visitor, context) {\n return visitor.visitNotExpr(this, context);\n }\n}\nclass FnParam {\n constructor(name, type = null) {\n this.name = name;\n this.type = type;\n }\n isEquivalent(param) {\n return this.name === param.name;\n }\n}\nclass FunctionExpr extends Expression {\n constructor(params, statements, type, sourceSpan, name) {\n super(type, sourceSpan);\n this.params = params;\n this.statements = statements;\n this.name = name;\n }\n isEquivalent(e) {\n return e instanceof FunctionExpr && areAllEquivalent(this.params, e.params) &&\n areAllEquivalent(this.statements, e.statements);\n }\n isConstant() {\n return false;\n }\n visitExpression(visitor, context) {\n return visitor.visitFunctionExpr(this, context);\n }\n toDeclStmt(name, modifiers) {\n return new DeclareFunctionStmt(name, this.params, this.statements, this.type, modifiers, this.sourceSpan);\n }\n}\nclass UnaryOperatorExpr extends Expression {\n constructor(operator, expr, type, sourceSpan, parens = true) {\n super(type || NUMBER_TYPE, sourceSpan);\n this.operator = operator;\n this.expr = expr;\n this.parens = parens;\n }\n isEquivalent(e) {\n return e instanceof UnaryOperatorExpr && this.operator === e.operator &&\n this.expr.isEquivalent(e.expr);\n }\n isConstant() {\n return false;\n }\n visitExpression(visitor, context) {\n return visitor.visitUnaryOperatorExpr(this, context);\n }\n}\nclass BinaryOperatorExpr extends Expression {\n constructor(operator, lhs, rhs, type, sourceSpan, parens = true) {\n super(type || lhs.type, sourceSpan);\n this.operator = operator;\n this.rhs = rhs;\n this.parens = parens;\n this.lhs = lhs;\n }\n isEquivalent(e) {\n return e instanceof BinaryOperatorExpr && this.operator === e.operator &&\n this.lhs.isEquivalent(e.lhs) && this.rhs.isEquivalent(e.rhs);\n }\n isConstant() {\n return false;\n }\n visitExpression(visitor, context) {\n return visitor.visitBinaryOperatorExpr(this, context);\n }\n}\nclass ReadPropExpr extends Expression {\n constructor(receiver, name, type, sourceSpan) {\n super(type, sourceSpan);\n this.receiver = receiver;\n this.name = name;\n }\n isEquivalent(e) {\n return e instanceof ReadPropExpr && this.receiver.isEquivalent(e.receiver) &&\n this.name === e.name;\n }\n isConstant() {\n return false;\n }\n visitExpression(visitor, context) {\n return visitor.visitReadPropExpr(this, context);\n }\n set(value) {\n return new WritePropExpr(this.receiver, this.name, value, null, this.sourceSpan);\n }\n}\nclass ReadKeyExpr extends Expression {\n constructor(receiver, index, type, sourceSpan) {\n super(type, sourceSpan);\n this.receiver = receiver;\n this.index = index;\n }\n isEquivalent(e) {\n return e instanceof ReadKeyExpr && this.receiver.isEquivalent(e.receiver) &&\n this.index.isEquivalent(e.index);\n }\n isConstant() {\n return false;\n }\n visitExpression(visitor, context) {\n return visitor.visitReadKeyExpr(this, context);\n }\n set(value) {\n return new WriteKeyExpr(this.receiver, this.index, value, null, this.sourceSpan);\n }\n}\nclass LiteralArrayExpr extends Expression {\n constructor(entries, type, sourceSpan) {\n super(type, sourceSpan);\n this.entries = entries;\n }\n isConstant() {\n return this.entries.every(e => e.isConstant());\n }\n isEquivalent(e) {\n return e instanceof LiteralArrayExpr && areAllEquivalent(this.entries, e.entries);\n }\n visitExpression(visitor, context) {\n return visitor.visitLiteralArrayExpr(this, context);\n }\n}\nclass LiteralMapEntry {\n constructor(key, value, quoted) {\n this.key = key;\n this.value = value;\n this.quoted = quoted;\n }\n isEquivalent(e) {\n return this.key === e.key && this.value.isEquivalent(e.value);\n }\n}\nclass LiteralMapExpr extends Expression {\n constructor(entries, type, sourceSpan) {\n super(type, sourceSpan);\n this.entries = entries;\n this.valueType = null;\n if (type) {\n this.valueType = type.valueType;\n }\n }\n isEquivalent(e) {\n return e instanceof LiteralMapExpr && areAllEquivalent(this.entries, e.entries);\n }\n isConstant() {\n return this.entries.every(e => e.value.isConstant());\n }\n visitExpression(visitor, context) {\n return visitor.visitLiteralMapExpr(this, context);\n }\n}\nclass CommaExpr extends Expression {\n constructor(parts, sourceSpan) {\n super(parts[parts.length - 1].type, sourceSpan);\n this.parts = parts;\n }\n isEquivalent(e) {\n return e instanceof CommaExpr && areAllEquivalent(this.parts, e.parts);\n }\n isConstant() {\n return false;\n }\n visitExpression(visitor, context) {\n return visitor.visitCommaExpr(this, context);\n }\n}\nconst NULL_EXPR = new LiteralExpr(null, null, null);\nconst TYPED_NULL_EXPR = new LiteralExpr(null, INFERRED_TYPE, null);\n//// Statements\nvar StmtModifier;\n(function (StmtModifier) {\n StmtModifier[StmtModifier[\"None\"] = 0] = \"None\";\n StmtModifier[StmtModifier[\"Final\"] = 1] = \"Final\";\n StmtModifier[StmtModifier[\"Private\"] = 2] = \"Private\";\n StmtModifier[StmtModifier[\"Exported\"] = 4] = \"Exported\";\n StmtModifier[StmtModifier[\"Static\"] = 8] = \"Static\";\n})(StmtModifier || (StmtModifier = {}));\nclass LeadingComment {\n constructor(text, multiline, trailingNewline) {\n this.text = text;\n this.multiline = multiline;\n this.trailingNewline = trailingNewline;\n }\n toString() {\n return this.multiline ? ` ${this.text} ` : this.text;\n }\n}\nclass JSDocComment extends LeadingComment {\n constructor(tags) {\n super('', /* multiline */ true, /* trailingNewline */ true);\n this.tags = tags;\n }\n toString() {\n return serializeTags(this.tags);\n }\n}\nclass Statement {\n constructor(modifiers = StmtModifier.None, sourceSpan = null, leadingComments) {\n this.modifiers = modifiers;\n this.sourceSpan = sourceSpan;\n this.leadingComments = leadingComments;\n }\n hasModifier(modifier) {\n return (this.modifiers & modifier) !== 0;\n }\n addLeadingComment(leadingComment) {\n this.leadingComments = this.leadingComments ?? [];\n this.leadingComments.push(leadingComment);\n }\n}\nclass DeclareVarStmt extends Statement {\n constructor(name, value, type, modifiers, sourceSpan, leadingComments) {\n super(modifiers, sourceSpan, leadingComments);\n this.name = name;\n this.value = value;\n this.type = type || (value && value.type) || null;\n }\n isEquivalent(stmt) {\n return stmt instanceof DeclareVarStmt && this.name === stmt.name &&\n (this.value ? !!stmt.value && this.value.isEquivalent(stmt.value) : !stmt.value);\n }\n visitStatement(visitor, context) {\n return visitor.visitDeclareVarStmt(this, context);\n }\n}\nclass DeclareFunctionStmt extends Statement {\n constructor(name, params, statements, type, modifiers, sourceSpan, leadingComments) {\n super(modifiers, sourceSpan, leadingComments);\n this.name = name;\n this.params = params;\n this.statements = statements;\n this.type = type || null;\n }\n isEquivalent(stmt) {\n return stmt instanceof DeclareFunctionStmt && areAllEquivalent(this.params, stmt.params) &&\n areAllEquivalent(this.statements, stmt.statements);\n }\n visitStatement(visitor, context) {\n return visitor.visitDeclareFunctionStmt(this, context);\n }\n}\nclass ExpressionStatement extends Statement {\n constructor(expr, sourceSpan, leadingComments) {\n super(StmtModifier.None, sourceSpan, leadingComments);\n this.expr = expr;\n }\n isEquivalent(stmt) {\n return stmt instanceof ExpressionStatement && this.expr.isEquivalent(stmt.expr);\n }\n visitStatement(visitor, context) {\n return visitor.visitExpressionStmt(this, context);\n }\n}\nclass ReturnStatement extends Statement {\n constructor(value, sourceSpan = null, leadingComments) {\n super(StmtModifier.None, sourceSpan, leadingComments);\n this.value = value;\n }\n isEquivalent(stmt) {\n return stmt instanceof ReturnStatement && this.value.isEquivalent(stmt.value);\n }\n visitStatement(visitor, context) {\n return visitor.visitReturnStmt(this, context);\n }\n}\nclass IfStmt extends Statement {\n constructor(condition, trueCase, falseCase = [], sourceSpan, leadingComments) {\n super(StmtModifier.None, sourceSpan, leadingComments);\n this.condition = condition;\n this.trueCase = trueCase;\n this.falseCase = falseCase;\n }\n isEquivalent(stmt) {\n return stmt instanceof IfStmt && this.condition.isEquivalent(stmt.condition) &&\n areAllEquivalent(this.trueCase, stmt.trueCase) &&\n areAllEquivalent(this.falseCase, stmt.falseCase);\n }\n visitStatement(visitor, context) {\n return visitor.visitIfStmt(this, context);\n }\n}\nclass RecursiveAstVisitor$1 {\n visitType(ast, context) {\n return ast;\n }\n visitExpression(ast, context) {\n if (ast.type) {\n ast.type.visitType(this, context);\n }\n return ast;\n }\n visitBuiltinType(type, context) {\n return this.visitType(type, context);\n }\n visitExpressionType(type, context) {\n type.value.visitExpression(this, context);\n if (type.typeParams !== null) {\n type.typeParams.forEach(param => this.visitType(param, context));\n }\n return this.visitType(type, context);\n }\n visitArrayType(type, context) {\n return this.visitType(type, context);\n }\n visitMapType(type, context) {\n return this.visitType(type, context);\n }\n visitWrappedNodeExpr(ast, context) {\n return ast;\n }\n visitTypeofExpr(ast, context) {\n return this.visitExpression(ast, context);\n }\n visitReadVarExpr(ast, context) {\n return this.visitExpression(ast, context);\n }\n visitWriteVarExpr(ast, context) {\n ast.value.visitExpression(this, context);\n return this.visitExpression(ast, context);\n }\n visitWriteKeyExpr(ast, context) {\n ast.receiver.visitExpression(this, context);\n ast.index.visitExpression(this, context);\n ast.value.visitExpression(this, context);\n return this.visitExpression(ast, context);\n }\n visitWritePropExpr(ast, context) {\n ast.receiver.visitExpression(this, context);\n ast.value.visitExpression(this, context);\n return this.visitExpression(ast, context);\n }\n visitInvokeFunctionExpr(ast, context) {\n ast.fn.visitExpression(this, context);\n this.visitAllExpressions(ast.args, context);\n return this.visitExpression(ast, context);\n }\n visitTaggedTemplateExpr(ast, context) {\n ast.tag.visitExpression(this, context);\n this.visitAllExpressions(ast.template.expressions, context);\n return this.visitExpression(ast, context);\n }\n visitInstantiateExpr(ast, context) {\n ast.classExpr.visitExpression(this, context);\n this.visitAllExpressions(ast.args, context);\n return this.visitExpression(ast, context);\n }\n visitLiteralExpr(ast, context) {\n return this.visitExpression(ast, context);\n }\n visitLocalizedString(ast, context) {\n return this.visitExpression(ast, context);\n }\n visitExternalExpr(ast, context) {\n if (ast.typeParams) {\n ast.typeParams.forEach(type => type.visitType(this, context));\n }\n return this.visitExpression(ast, context);\n }\n visitConditionalExpr(ast, context) {\n ast.condition.visitExpression(this, context);\n ast.trueCase.visitExpression(this, context);\n ast.falseCase.visitExpression(this, context);\n return this.visitExpression(ast, context);\n }\n visitNotExpr(ast, context) {\n ast.condition.visitExpression(this, context);\n return this.visitExpression(ast, context);\n }\n visitFunctionExpr(ast, context) {\n this.visitAllStatements(ast.statements, context);\n return this.visitExpression(ast, context);\n }\n visitUnaryOperatorExpr(ast, context) {\n ast.expr.visitExpression(this, context);\n return this.visitExpression(ast, context);\n }\n visitBinaryOperatorExpr(ast, context) {\n ast.lhs.visitExpression(this, context);\n ast.rhs.visitExpression(this, context);\n return this.visitExpression(ast, context);\n }\n visitReadPropExpr(ast, context) {\n ast.receiver.visitExpression(this, context);\n return this.visitExpression(ast, context);\n }\n visitReadKeyExpr(ast, context) {\n ast.receiver.visitExpression(this, context);\n ast.index.visitExpression(this, context);\n return this.visitExpression(ast, context);\n }\n visitLiteralArrayExpr(ast, context) {\n this.visitAllExpressions(ast.entries, context);\n return this.visitExpression(ast, context);\n }\n visitLiteralMapExpr(ast, context) {\n ast.entries.forEach((entry) => entry.value.visitExpression(this, context));\n return this.visitExpression(ast, context);\n }\n visitCommaExpr(ast, context) {\n this.visitAllExpressions(ast.parts, context);\n return this.visitExpression(ast, context);\n }\n visitAllExpressions(exprs, context) {\n exprs.forEach(expr => expr.visitExpression(this, context));\n }\n visitDeclareVarStmt(stmt, context) {\n if (stmt.value) {\n stmt.value.visitExpression(this, context);\n }\n if (stmt.type) {\n stmt.type.visitType(this, context);\n }\n return stmt;\n }\n visitDeclareFunctionStmt(stmt, context) {\n this.visitAllStatements(stmt.statements, context);\n if (stmt.type) {\n stmt.type.visitType(this, context);\n }\n return stmt;\n }\n visitExpressionStmt(stmt, context) {\n stmt.expr.visitExpression(this, context);\n return stmt;\n }\n visitReturnStmt(stmt, context) {\n stmt.value.visitExpression(this, context);\n return stmt;\n }\n visitIfStmt(stmt, context) {\n stmt.condition.visitExpression(this, context);\n this.visitAllStatements(stmt.trueCase, context);\n this.visitAllStatements(stmt.falseCase, context);\n return stmt;\n }\n visitAllStatements(stmts, context) {\n stmts.forEach(stmt => stmt.visitStatement(this, context));\n }\n}\nfunction leadingComment(text, multiline = false, trailingNewline = true) {\n return new LeadingComment(text, multiline, trailingNewline);\n}\nfunction jsDocComment(tags = []) {\n return new JSDocComment(tags);\n}\nfunction variable(name, type, sourceSpan) {\n return new ReadVarExpr(name, type, sourceSpan);\n}\nfunction importExpr(id, typeParams = null, sourceSpan) {\n return new ExternalExpr(id, null, typeParams, sourceSpan);\n}\nfunction importType(id, typeParams, typeModifiers) {\n return id != null ? expressionType(importExpr(id, typeParams, null), typeModifiers) : null;\n}\nfunction expressionType(expr, typeModifiers, typeParams) {\n return new ExpressionType(expr, typeModifiers, typeParams);\n}\nfunction typeofExpr(expr) {\n return new TypeofExpr(expr);\n}\nfunction literalArr(values, type, sourceSpan) {\n return new LiteralArrayExpr(values, type, sourceSpan);\n}\nfunction literalMap(values, type = null) {\n return new LiteralMapExpr(values.map(e => new LiteralMapEntry(e.key, e.value, e.quoted)), type, null);\n}\nfunction unary(operator, expr, type, sourceSpan) {\n return new UnaryOperatorExpr(operator, expr, type, sourceSpan);\n}\nfunction not(expr, sourceSpan) {\n return new NotExpr(expr, sourceSpan);\n}\nfunction fn(params, body, type, sourceSpan, name) {\n return new FunctionExpr(params, body, type, sourceSpan, name);\n}\nfunction ifStmt(condition, thenClause, elseClause, sourceSpan, leadingComments) {\n return new IfStmt(condition, thenClause, elseClause, sourceSpan, leadingComments);\n}\nfunction taggedTemplate(tag, template, type, sourceSpan) {\n return new TaggedTemplateExpr(tag, template, type, sourceSpan);\n}\nfunction literal(value, type, sourceSpan) {\n return new LiteralExpr(value, type, sourceSpan);\n}\nfunction localizedString(metaBlock, messageParts, placeholderNames, expressions, sourceSpan) {\n return new LocalizedString(metaBlock, messageParts, placeholderNames, expressions, sourceSpan);\n}\nfunction isNull(exp) {\n return exp instanceof LiteralExpr && exp.value === null;\n}\n/*\n * Serializes a `Tag` into a string.\n * Returns a string like \" @foo {bar} baz\" (note the leading whitespace before `@foo`).\n */\nfunction tagToString(tag) {\n let out = '';\n if (tag.tagName) {\n out += ` @${tag.tagName}`;\n }\n if (tag.text) {\n if (tag.text.match(/\\/\\*|\\*\\//)) {\n throw new Error('JSDoc text cannot contain \"/*\" and \"*/\"');\n }\n out += ' ' + tag.text.replace(/@/g, '\\\\@');\n }\n return out;\n}\nfunction serializeTags(tags) {\n if (tags.length === 0)\n return '';\n if (tags.length === 1 && tags[0].tagName && !tags[0].text) {\n // The JSDOC comment is a single simple tag: e.g `/** @tagname */`.\n return `*${tagToString(tags[0])} `;\n }\n let out = '*\\n';\n for (const tag of tags) {\n out += ' *';\n // If the tagToString is multi-line, insert \" * \" prefixes on lines.\n out += tagToString(tag).replace(/\\n/g, '\\n * ');\n out += '\\n';\n }\n out += ' ';\n return out;\n}\n\nvar output_ast = /*#__PURE__*/Object.freeze({\n __proto__: null,\n get TypeModifier () { return TypeModifier; },\n Type: Type,\n get BuiltinTypeName () { return BuiltinTypeName; },\n BuiltinType: BuiltinType,\n ExpressionType: ExpressionType,\n ArrayType: ArrayType,\n MapType: MapType,\n DYNAMIC_TYPE: DYNAMIC_TYPE,\n INFERRED_TYPE: INFERRED_TYPE,\n BOOL_TYPE: BOOL_TYPE,\n INT_TYPE: INT_TYPE,\n NUMBER_TYPE: NUMBER_TYPE,\n STRING_TYPE: STRING_TYPE,\n FUNCTION_TYPE: FUNCTION_TYPE,\n NONE_TYPE: NONE_TYPE,\n get UnaryOperator () { return UnaryOperator; },\n get BinaryOperator () { return BinaryOperator; },\n nullSafeIsEquivalent: nullSafeIsEquivalent,\n areAllEquivalent: areAllEquivalent,\n Expression: Expression,\n ReadVarExpr: ReadVarExpr,\n TypeofExpr: TypeofExpr,\n WrappedNodeExpr: WrappedNodeExpr,\n WriteVarExpr: WriteVarExpr,\n WriteKeyExpr: WriteKeyExpr,\n WritePropExpr: WritePropExpr,\n InvokeFunctionExpr: InvokeFunctionExpr,\n TaggedTemplateExpr: TaggedTemplateExpr,\n InstantiateExpr: InstantiateExpr,\n LiteralExpr: LiteralExpr,\n TemplateLiteral: TemplateLiteral,\n TemplateLiteralElement: TemplateLiteralElement,\n LiteralPiece: LiteralPiece,\n PlaceholderPiece: PlaceholderPiece,\n LocalizedString: LocalizedString,\n ExternalExpr: ExternalExpr,\n ExternalReference: ExternalReference,\n ConditionalExpr: ConditionalExpr,\n NotExpr: NotExpr,\n FnParam: FnParam,\n FunctionExpr: FunctionExpr,\n UnaryOperatorExpr: UnaryOperatorExpr,\n BinaryOperatorExpr: BinaryOperatorExpr,\n ReadPropExpr: ReadPropExpr,\n ReadKeyExpr: ReadKeyExpr,\n LiteralArrayExpr: LiteralArrayExpr,\n LiteralMapEntry: LiteralMapEntry,\n LiteralMapExpr: LiteralMapExpr,\n CommaExpr: CommaExpr,\n NULL_EXPR: NULL_EXPR,\n TYPED_NULL_EXPR: TYPED_NULL_EXPR,\n get StmtModifier () { return StmtModifier; },\n LeadingComment: LeadingComment,\n JSDocComment: JSDocComment,\n Statement: Statement,\n DeclareVarStmt: DeclareVarStmt,\n DeclareFunctionStmt: DeclareFunctionStmt,\n ExpressionStatement: ExpressionStatement,\n ReturnStatement: ReturnStatement,\n IfStmt: IfStmt,\n RecursiveAstVisitor: RecursiveAstVisitor$1,\n leadingComment: leadingComment,\n jsDocComment: jsDocComment,\n variable: variable,\n importExpr: importExpr,\n importType: importType,\n expressionType: expressionType,\n typeofExpr: typeofExpr,\n literalArr: literalArr,\n literalMap: literalMap,\n unary: unary,\n not: not,\n fn: fn,\n ifStmt: ifStmt,\n taggedTemplate: taggedTemplate,\n literal: literal,\n localizedString: localizedString,\n isNull: isNull\n});\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst CONSTANT_PREFIX = '_c';\n/**\n * `ConstantPool` tries to reuse literal factories when two or more literals are identical.\n * We determine whether literals are identical by creating a key out of their AST using the\n * `KeyVisitor`. This constant is used to replace dynamic expressions which can't be safely\n * converted into a key. E.g. given an expression `{foo: bar()}`, since we don't know what\n * the result of `bar` will be, we create a key that looks like `{foo: }`. Note\n * that we use a variable, rather than something like `null` in order to avoid collisions.\n */\nconst UNKNOWN_VALUE_KEY = variable('');\n/**\n * Context to use when producing a key.\n *\n * This ensures we see the constant not the reference variable when producing\n * a key.\n */\nconst KEY_CONTEXT = {};\n/**\n * Generally all primitive values are excluded from the `ConstantPool`, but there is an exclusion\n * for strings that reach a certain length threshold. This constant defines the length threshold for\n * strings.\n */\nconst POOL_INCLUSION_LENGTH_THRESHOLD_FOR_STRINGS = 50;\n/**\n * A node that is a place-holder that allows the node to be replaced when the actual\n * node is known.\n *\n * This allows the constant pool to change an expression from a direct reference to\n * a constant to a shared constant. It returns a fix-up node that is later allowed to\n * change the referenced expression.\n */\nclass FixupExpression extends Expression {\n constructor(resolved) {\n super(resolved.type);\n this.resolved = resolved;\n this.original = resolved;\n }\n visitExpression(visitor, context) {\n if (context === KEY_CONTEXT) {\n // When producing a key we want to traverse the constant not the\n // variable used to refer to it.\n return this.original.visitExpression(visitor, context);\n }\n else {\n return this.resolved.visitExpression(visitor, context);\n }\n }\n isEquivalent(e) {\n return e instanceof FixupExpression && this.resolved.isEquivalent(e.resolved);\n }\n isConstant() {\n return true;\n }\n fixup(expression) {\n this.resolved = expression;\n this.shared = true;\n }\n}\n/**\n * A constant pool allows a code emitter to share constant in an output context.\n *\n * The constant pool also supports sharing access to ivy definitions references.\n */\nclass ConstantPool {\n constructor(isClosureCompilerEnabled = false) {\n this.isClosureCompilerEnabled = isClosureCompilerEnabled;\n this.statements = [];\n this.literals = new Map();\n this.literalFactories = new Map();\n this.nextNameIndex = 0;\n }\n getConstLiteral(literal, forceShared) {\n if ((literal instanceof LiteralExpr && !isLongStringLiteral(literal)) ||\n literal instanceof FixupExpression) {\n // Do no put simple literals into the constant pool or try to produce a constant for a\n // reference to a constant.\n return literal;\n }\n const key = this.keyOf(literal);\n let fixup = this.literals.get(key);\n let newValue = false;\n if (!fixup) {\n fixup = new FixupExpression(literal);\n this.literals.set(key, fixup);\n newValue = true;\n }\n if ((!newValue && !fixup.shared) || (newValue && forceShared)) {\n // Replace the expression with a variable\n const name = this.freshName();\n let definition;\n let usage;\n if (this.isClosureCompilerEnabled && isLongStringLiteral(literal)) {\n // For string literals, Closure will **always** inline the string at\n // **all** usages, duplicating it each time. For large strings, this\n // unnecessarily bloats bundle size. To work around this restriction, we\n // wrap the string in a function, and call that function for each usage.\n // This tricks Closure into using inline logic for functions instead of\n // string literals. Function calls are only inlined if the body is small\n // enough to be worth it. By doing this, very large strings will be\n // shared across multiple usages, rather than duplicating the string at\n // each usage site.\n //\n // const myStr = function() { return \"very very very long string\"; };\n // const usage1 = myStr();\n // const usage2 = myStr();\n definition = variable(name).set(new FunctionExpr([], // Params.\n [\n // Statements.\n new ReturnStatement(literal),\n ]));\n usage = variable(name).callFn([]);\n }\n else {\n // Just declare and use the variable directly, without a function call\n // indirection. This saves a few bytes and avoids an unncessary call.\n definition = variable(name).set(literal);\n usage = variable(name);\n }\n this.statements.push(definition.toDeclStmt(INFERRED_TYPE, StmtModifier.Final));\n fixup.fixup(usage);\n }\n return fixup;\n }\n getLiteralFactory(literal) {\n // Create a pure function that builds an array of a mix of constant and variable expressions\n if (literal instanceof LiteralArrayExpr) {\n const argumentsForKey = literal.entries.map(e => e.isConstant() ? e : UNKNOWN_VALUE_KEY);\n const key = this.keyOf(literalArr(argumentsForKey));\n return this._getLiteralFactory(key, literal.entries, entries => literalArr(entries));\n }\n else {\n const expressionForKey = literalMap(literal.entries.map(e => ({\n key: e.key,\n value: e.value.isConstant() ? e.value : UNKNOWN_VALUE_KEY,\n quoted: e.quoted\n })));\n const key = this.keyOf(expressionForKey);\n return this._getLiteralFactory(key, literal.entries.map(e => e.value), entries => literalMap(entries.map((value, index) => ({\n key: literal.entries[index].key,\n value,\n quoted: literal.entries[index].quoted\n }))));\n }\n }\n _getLiteralFactory(key, values, resultMap) {\n let literalFactory = this.literalFactories.get(key);\n const literalFactoryArguments = values.filter((e => !e.isConstant()));\n if (!literalFactory) {\n const resultExpressions = values.map((e, index) => e.isConstant() ? this.getConstLiteral(e, true) : variable(`a${index}`));\n const parameters = resultExpressions.filter(isVariable).map(e => new FnParam(e.name, DYNAMIC_TYPE));\n const pureFunctionDeclaration = fn(parameters, [new ReturnStatement(resultMap(resultExpressions))], INFERRED_TYPE);\n const name = this.freshName();\n this.statements.push(variable(name)\n .set(pureFunctionDeclaration)\n .toDeclStmt(INFERRED_TYPE, StmtModifier.Final));\n literalFactory = variable(name);\n this.literalFactories.set(key, literalFactory);\n }\n return { literalFactory, literalFactoryArguments };\n }\n /**\n * Produce a unique name.\n *\n * The name might be unique among different prefixes if any of the prefixes end in\n * a digit so the prefix should be a constant string (not based on user input) and\n * must not end in a digit.\n */\n uniqueName(prefix) {\n return `${prefix}${this.nextNameIndex++}`;\n }\n freshName() {\n return this.uniqueName(CONSTANT_PREFIX);\n }\n keyOf(expression) {\n return expression.visitExpression(new KeyVisitor(), KEY_CONTEXT);\n }\n}\n/**\n * Visitor used to determine if 2 expressions are equivalent and can be shared in the\n * `ConstantPool`.\n *\n * When the id (string) generated by the visitor is equal, expressions are considered equivalent.\n */\nclass KeyVisitor {\n constructor() {\n this.visitWrappedNodeExpr = invalid$1;\n this.visitWriteVarExpr = invalid$1;\n this.visitWriteKeyExpr = invalid$1;\n this.visitWritePropExpr = invalid$1;\n this.visitInvokeFunctionExpr = invalid$1;\n this.visitTaggedTemplateExpr = invalid$1;\n this.visitInstantiateExpr = invalid$1;\n this.visitConditionalExpr = invalid$1;\n this.visitNotExpr = invalid$1;\n this.visitAssertNotNullExpr = invalid$1;\n this.visitCastExpr = invalid$1;\n this.visitFunctionExpr = invalid$1;\n this.visitUnaryOperatorExpr = invalid$1;\n this.visitBinaryOperatorExpr = invalid$1;\n this.visitReadPropExpr = invalid$1;\n this.visitReadKeyExpr = invalid$1;\n this.visitCommaExpr = invalid$1;\n this.visitLocalizedString = invalid$1;\n }\n visitLiteralExpr(ast) {\n return `${typeof ast.value === 'string' ? '\"' + ast.value + '\"' : ast.value}`;\n }\n visitLiteralArrayExpr(ast, context) {\n return `[${ast.entries.map(entry => entry.visitExpression(this, context)).join(',')}]`;\n }\n visitLiteralMapExpr(ast, context) {\n const mapKey = (entry) => {\n const quote = entry.quoted ? '\"' : '';\n return `${quote}${entry.key}${quote}`;\n };\n const mapEntry = (entry) => `${mapKey(entry)}:${entry.value.visitExpression(this, context)}`;\n return `{${ast.entries.map(mapEntry).join(',')}`;\n }\n visitExternalExpr(ast) {\n return ast.value.moduleName ? `EX:${ast.value.moduleName}:${ast.value.name}` :\n `EX:${ast.value.runtime.name}`;\n }\n visitReadVarExpr(node) {\n return `VAR:${node.name}`;\n }\n visitTypeofExpr(node, context) {\n return `TYPEOF:${node.expr.visitExpression(this, context)}`;\n }\n}\nfunction invalid$1(arg) {\n throw new Error(`Invalid state: Visitor ${this.constructor.name} doesn't handle ${arg.constructor.name}`);\n}\nfunction isVariable(e) {\n return e instanceof ReadVarExpr;\n}\nfunction isLongStringLiteral(expr) {\n return expr instanceof LiteralExpr && typeof expr.value === 'string' &&\n expr.value.length >= POOL_INCLUSION_LENGTH_THRESHOLD_FOR_STRINGS;\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst CORE = '@angular/core';\nclass Identifiers {\n}\n/* Methods */\nIdentifiers.NEW_METHOD = 'factory';\nIdentifiers.TRANSFORM_METHOD = 'transform';\nIdentifiers.PATCH_DEPS = 'patchedDeps';\nIdentifiers.core = { name: null, moduleName: CORE };\n/* Instructions */\nIdentifiers.namespaceHTML = { name: 'ɵɵnamespaceHTML', moduleName: CORE };\nIdentifiers.namespaceMathML = { name: 'ɵɵnamespaceMathML', moduleName: CORE };\nIdentifiers.namespaceSVG = { name: 'ɵɵnamespaceSVG', moduleName: CORE };\nIdentifiers.element = { name: 'ɵɵelement', moduleName: CORE };\nIdentifiers.elementStart = { name: 'ɵɵelementStart', moduleName: CORE };\nIdentifiers.elementEnd = { name: 'ɵɵelementEnd', moduleName: CORE };\nIdentifiers.advance = { name: 'ɵɵadvance', moduleName: CORE };\nIdentifiers.syntheticHostProperty = { name: 'ɵɵsyntheticHostProperty', moduleName: CORE };\nIdentifiers.syntheticHostListener = { name: 'ɵɵsyntheticHostListener', moduleName: CORE };\nIdentifiers.attribute = { name: 'ɵɵattribute', moduleName: CORE };\nIdentifiers.attributeInterpolate1 = { name: 'ɵɵattributeInterpolate1', moduleName: CORE };\nIdentifiers.attributeInterpolate2 = { name: 'ɵɵattributeInterpolate2', moduleName: CORE };\nIdentifiers.attributeInterpolate3 = { name: 'ɵɵattributeInterpolate3', moduleName: CORE };\nIdentifiers.attributeInterpolate4 = { name: 'ɵɵattributeInterpolate4', moduleName: CORE };\nIdentifiers.attributeInterpolate5 = { name: 'ɵɵattributeInterpolate5', moduleName: CORE };\nIdentifiers.attributeInterpolate6 = { name: 'ɵɵattributeInterpolate6', moduleName: CORE };\nIdentifiers.attributeInterpolate7 = { name: 'ɵɵattributeInterpolate7', moduleName: CORE };\nIdentifiers.attributeInterpolate8 = { name: 'ɵɵattributeInterpolate8', moduleName: CORE };\nIdentifiers.attributeInterpolateV = { name: 'ɵɵattributeInterpolateV', moduleName: CORE };\nIdentifiers.classProp = { name: 'ɵɵclassProp', moduleName: CORE };\nIdentifiers.elementContainerStart = { name: 'ɵɵelementContainerStart', moduleName: CORE };\nIdentifiers.elementContainerEnd = { name: 'ɵɵelementContainerEnd', moduleName: CORE };\nIdentifiers.elementContainer = { name: 'ɵɵelementContainer', moduleName: CORE };\nIdentifiers.styleMap = { name: 'ɵɵstyleMap', moduleName: CORE };\nIdentifiers.styleMapInterpolate1 = { name: 'ɵɵstyleMapInterpolate1', moduleName: CORE };\nIdentifiers.styleMapInterpolate2 = { name: 'ɵɵstyleMapInterpolate2', moduleName: CORE };\nIdentifiers.styleMapInterpolate3 = { name: 'ɵɵstyleMapInterpolate3', moduleName: CORE };\nIdentifiers.styleMapInterpolate4 = { name: 'ɵɵstyleMapInterpolate4', moduleName: CORE };\nIdentifiers.styleMapInterpolate5 = { name: 'ɵɵstyleMapInterpolate5', moduleName: CORE };\nIdentifiers.styleMapInterpolate6 = { name: 'ɵɵstyleMapInterpolate6', moduleName: CORE };\nIdentifiers.styleMapInterpolate7 = { name: 'ɵɵstyleMapInterpolate7', moduleName: CORE };\nIdentifiers.styleMapInterpolate8 = { name: 'ɵɵstyleMapInterpolate8', moduleName: CORE };\nIdentifiers.styleMapInterpolateV = { name: 'ɵɵstyleMapInterpolateV', moduleName: CORE };\nIdentifiers.classMap = { name: 'ɵɵclassMap', moduleName: CORE };\nIdentifiers.classMapInterpolate1 = { name: 'ɵɵclassMapInterpolate1', moduleName: CORE };\nIdentifiers.classMapInterpolate2 = { name: 'ɵɵclassMapInterpolate2', moduleName: CORE };\nIdentifiers.classMapInterpolate3 = { name: 'ɵɵclassMapInterpolate3', moduleName: CORE };\nIdentifiers.classMapInterpolate4 = { name: 'ɵɵclassMapInterpolate4', moduleName: CORE };\nIdentifiers.classMapInterpolate5 = { name: 'ɵɵclassMapInterpolate5', moduleName: CORE };\nIdentifiers.classMapInterpolate6 = { name: 'ɵɵclassMapInterpolate6', moduleName: CORE };\nIdentifiers.classMapInterpolate7 = { name: 'ɵɵclassMapInterpolate7', moduleName: CORE };\nIdentifiers.classMapInterpolate8 = { name: 'ɵɵclassMapInterpolate8', moduleName: CORE };\nIdentifiers.classMapInterpolateV = { name: 'ɵɵclassMapInterpolateV', moduleName: CORE };\nIdentifiers.styleProp = { name: 'ɵɵstyleProp', moduleName: CORE };\nIdentifiers.stylePropInterpolate1 = { name: 'ɵɵstylePropInterpolate1', moduleName: CORE };\nIdentifiers.stylePropInterpolate2 = { name: 'ɵɵstylePropInterpolate2', moduleName: CORE };\nIdentifiers.stylePropInterpolate3 = { name: 'ɵɵstylePropInterpolate3', moduleName: CORE };\nIdentifiers.stylePropInterpolate4 = { name: 'ɵɵstylePropInterpolate4', moduleName: CORE };\nIdentifiers.stylePropInterpolate5 = { name: 'ɵɵstylePropInterpolate5', moduleName: CORE };\nIdentifiers.stylePropInterpolate6 = { name: 'ɵɵstylePropInterpolate6', moduleName: CORE };\nIdentifiers.stylePropInterpolate7 = { name: 'ɵɵstylePropInterpolate7', moduleName: CORE };\nIdentifiers.stylePropInterpolate8 = { name: 'ɵɵstylePropInterpolate8', moduleName: CORE };\nIdentifiers.stylePropInterpolateV = { name: 'ɵɵstylePropInterpolateV', moduleName: CORE };\nIdentifiers.nextContext = { name: 'ɵɵnextContext', moduleName: CORE };\nIdentifiers.templateCreate = { name: 'ɵɵtemplate', moduleName: CORE };\nIdentifiers.text = { name: 'ɵɵtext', moduleName: CORE };\nIdentifiers.enableBindings = { name: 'ɵɵenableBindings', moduleName: CORE };\nIdentifiers.disableBindings = { name: 'ɵɵdisableBindings', moduleName: CORE };\nIdentifiers.getCurrentView = { name: 'ɵɵgetCurrentView', moduleName: CORE };\nIdentifiers.textInterpolate = { name: 'ɵɵtextInterpolate', moduleName: CORE };\nIdentifiers.textInterpolate1 = { name: 'ɵɵtextInterpolate1', moduleName: CORE };\nIdentifiers.textInterpolate2 = { name: 'ɵɵtextInterpolate2', moduleName: CORE };\nIdentifiers.textInterpolate3 = { name: 'ɵɵtextInterpolate3', moduleName: CORE };\nIdentifiers.textInterpolate4 = { name: 'ɵɵtextInterpolate4', moduleName: CORE };\nIdentifiers.textInterpolate5 = { name: 'ɵɵtextInterpolate5', moduleName: CORE };\nIdentifiers.textInterpolate6 = { name: 'ɵɵtextInterpolate6', moduleName: CORE };\nIdentifiers.textInterpolate7 = { name: 'ɵɵtextInterpolate7', moduleName: CORE };\nIdentifiers.textInterpolate8 = { name: 'ɵɵtextInterpolate8', moduleName: CORE };\nIdentifiers.textInterpolateV = { name: 'ɵɵtextInterpolateV', moduleName: CORE };\nIdentifiers.restoreView = { name: 'ɵɵrestoreView', moduleName: CORE };\nIdentifiers.pureFunction0 = { name: 'ɵɵpureFunction0', moduleName: CORE };\nIdentifiers.pureFunction1 = { name: 'ɵɵpureFunction1', moduleName: CORE };\nIdentifiers.pureFunction2 = { name: 'ɵɵpureFunction2', moduleName: CORE };\nIdentifiers.pureFunction3 = { name: 'ɵɵpureFunction3', moduleName: CORE };\nIdentifiers.pureFunction4 = { name: 'ɵɵpureFunction4', moduleName: CORE };\nIdentifiers.pureFunction5 = { name: 'ɵɵpureFunction5', moduleName: CORE };\nIdentifiers.pureFunction6 = { name: 'ɵɵpureFunction6', moduleName: CORE };\nIdentifiers.pureFunction7 = { name: 'ɵɵpureFunction7', moduleName: CORE };\nIdentifiers.pureFunction8 = { name: 'ɵɵpureFunction8', moduleName: CORE };\nIdentifiers.pureFunctionV = { name: 'ɵɵpureFunctionV', moduleName: CORE };\nIdentifiers.pipeBind1 = { name: 'ɵɵpipeBind1', moduleName: CORE };\nIdentifiers.pipeBind2 = { name: 'ɵɵpipeBind2', moduleName: CORE };\nIdentifiers.pipeBind3 = { name: 'ɵɵpipeBind3', moduleName: CORE };\nIdentifiers.pipeBind4 = { name: 'ɵɵpipeBind4', moduleName: CORE };\nIdentifiers.pipeBindV = { name: 'ɵɵpipeBindV', moduleName: CORE };\nIdentifiers.hostProperty = { name: 'ɵɵhostProperty', moduleName: CORE };\nIdentifiers.property = { name: 'ɵɵproperty', moduleName: CORE };\nIdentifiers.propertyInterpolate = { name: 'ɵɵpropertyInterpolate', moduleName: CORE };\nIdentifiers.propertyInterpolate1 = { name: 'ɵɵpropertyInterpolate1', moduleName: CORE };\nIdentifiers.propertyInterpolate2 = { name: 'ɵɵpropertyInterpolate2', moduleName: CORE };\nIdentifiers.propertyInterpolate3 = { name: 'ɵɵpropertyInterpolate3', moduleName: CORE };\nIdentifiers.propertyInterpolate4 = { name: 'ɵɵpropertyInterpolate4', moduleName: CORE };\nIdentifiers.propertyInterpolate5 = { name: 'ɵɵpropertyInterpolate5', moduleName: CORE };\nIdentifiers.propertyInterpolate6 = { name: 'ɵɵpropertyInterpolate6', moduleName: CORE };\nIdentifiers.propertyInterpolate7 = { name: 'ɵɵpropertyInterpolate7', moduleName: CORE };\nIdentifiers.propertyInterpolate8 = { name: 'ɵɵpropertyInterpolate8', moduleName: CORE };\nIdentifiers.propertyInterpolateV = { name: 'ɵɵpropertyInterpolateV', moduleName: CORE };\nIdentifiers.i18n = { name: 'ɵɵi18n', moduleName: CORE };\nIdentifiers.i18nAttributes = { name: 'ɵɵi18nAttributes', moduleName: CORE };\nIdentifiers.i18nExp = { name: 'ɵɵi18nExp', moduleName: CORE };\nIdentifiers.i18nStart = { name: 'ɵɵi18nStart', moduleName: CORE };\nIdentifiers.i18nEnd = { name: 'ɵɵi18nEnd', moduleName: CORE };\nIdentifiers.i18nApply = { name: 'ɵɵi18nApply', moduleName: CORE };\nIdentifiers.i18nPostprocess = { name: 'ɵɵi18nPostprocess', moduleName: CORE };\nIdentifiers.pipe = { name: 'ɵɵpipe', moduleName: CORE };\nIdentifiers.projection = { name: 'ɵɵprojection', moduleName: CORE };\nIdentifiers.projectionDef = { name: 'ɵɵprojectionDef', moduleName: CORE };\nIdentifiers.reference = { name: 'ɵɵreference', moduleName: CORE };\nIdentifiers.inject = { name: 'ɵɵinject', moduleName: CORE };\nIdentifiers.injectAttribute = { name: 'ɵɵinjectAttribute', moduleName: CORE };\nIdentifiers.directiveInject = { name: 'ɵɵdirectiveInject', moduleName: CORE };\nIdentifiers.invalidFactory = { name: 'ɵɵinvalidFactory', moduleName: CORE };\nIdentifiers.invalidFactoryDep = { name: 'ɵɵinvalidFactoryDep', moduleName: CORE };\nIdentifiers.templateRefExtractor = { name: 'ɵɵtemplateRefExtractor', moduleName: CORE };\nIdentifiers.forwardRef = { name: 'forwardRef', moduleName: CORE };\nIdentifiers.resolveForwardRef = { name: 'resolveForwardRef', moduleName: CORE };\nIdentifiers.ɵɵdefineInjectable = { name: 'ɵɵdefineInjectable', moduleName: CORE };\nIdentifiers.declareInjectable = { name: 'ɵɵngDeclareInjectable', moduleName: CORE };\nIdentifiers.InjectableDeclaration = { name: 'ɵɵInjectableDeclaration', moduleName: CORE };\nIdentifiers.resolveWindow = { name: 'ɵɵresolveWindow', moduleName: CORE };\nIdentifiers.resolveDocument = { name: 'ɵɵresolveDocument', moduleName: CORE };\nIdentifiers.resolveBody = { name: 'ɵɵresolveBody', moduleName: CORE };\nIdentifiers.defineComponent = { name: 'ɵɵdefineComponent', moduleName: CORE };\nIdentifiers.declareComponent = { name: 'ɵɵngDeclareComponent', moduleName: CORE };\nIdentifiers.setComponentScope = { name: 'ɵɵsetComponentScope', moduleName: CORE };\nIdentifiers.ChangeDetectionStrategy = {\n name: 'ChangeDetectionStrategy',\n moduleName: CORE,\n};\nIdentifiers.ViewEncapsulation = {\n name: 'ViewEncapsulation',\n moduleName: CORE,\n};\nIdentifiers.ComponentDeclaration = {\n name: 'ɵɵComponentDeclaration',\n moduleName: CORE,\n};\nIdentifiers.FactoryDeclaration = {\n name: 'ɵɵFactoryDeclaration',\n moduleName: CORE,\n};\nIdentifiers.declareFactory = { name: 'ɵɵngDeclareFactory', moduleName: CORE };\nIdentifiers.FactoryTarget = { name: 'ɵɵFactoryTarget', moduleName: CORE };\nIdentifiers.defineDirective = { name: 'ɵɵdefineDirective', moduleName: CORE };\nIdentifiers.declareDirective = { name: 'ɵɵngDeclareDirective', moduleName: CORE };\nIdentifiers.DirectiveDeclaration = {\n name: 'ɵɵDirectiveDeclaration',\n moduleName: CORE,\n};\nIdentifiers.InjectorDef = { name: 'ɵɵInjectorDef', moduleName: CORE };\nIdentifiers.InjectorDeclaration = { name: 'ɵɵInjectorDeclaration', moduleName: CORE };\nIdentifiers.defineInjector = { name: 'ɵɵdefineInjector', moduleName: CORE };\nIdentifiers.declareInjector = { name: 'ɵɵngDeclareInjector', moduleName: CORE };\nIdentifiers.NgModuleDeclaration = {\n name: 'ɵɵNgModuleDeclaration',\n moduleName: CORE,\n};\nIdentifiers.ModuleWithProviders = {\n name: 'ModuleWithProviders',\n moduleName: CORE,\n};\nIdentifiers.defineNgModule = { name: 'ɵɵdefineNgModule', moduleName: CORE };\nIdentifiers.declareNgModule = { name: 'ɵɵngDeclareNgModule', moduleName: CORE };\nIdentifiers.setNgModuleScope = { name: 'ɵɵsetNgModuleScope', moduleName: CORE };\nIdentifiers.PipeDeclaration = { name: 'ɵɵPipeDeclaration', moduleName: CORE };\nIdentifiers.definePipe = { name: 'ɵɵdefinePipe', moduleName: CORE };\nIdentifiers.declarePipe = { name: 'ɵɵngDeclarePipe', moduleName: CORE };\nIdentifiers.declareClassMetadata = { name: 'ɵɵngDeclareClassMetadata', moduleName: CORE };\nIdentifiers.setClassMetadata = { name: 'ɵsetClassMetadata', moduleName: CORE };\nIdentifiers.queryRefresh = { name: 'ɵɵqueryRefresh', moduleName: CORE };\nIdentifiers.viewQuery = { name: 'ɵɵviewQuery', moduleName: CORE };\nIdentifiers.loadQuery = { name: 'ɵɵloadQuery', moduleName: CORE };\nIdentifiers.contentQuery = { name: 'ɵɵcontentQuery', moduleName: CORE };\nIdentifiers.NgOnChangesFeature = { name: 'ɵɵNgOnChangesFeature', moduleName: CORE };\nIdentifiers.InheritDefinitionFeature = { name: 'ɵɵInheritDefinitionFeature', moduleName: CORE };\nIdentifiers.CopyDefinitionFeature = { name: 'ɵɵCopyDefinitionFeature', moduleName: CORE };\nIdentifiers.ProvidersFeature = { name: 'ɵɵProvidersFeature', moduleName: CORE };\nIdentifiers.listener = { name: 'ɵɵlistener', moduleName: CORE };\nIdentifiers.getInheritedFactory = {\n name: 'ɵɵgetInheritedFactory',\n moduleName: CORE,\n};\n// sanitization-related functions\nIdentifiers.sanitizeHtml = { name: 'ɵɵsanitizeHtml', moduleName: CORE };\nIdentifiers.sanitizeStyle = { name: 'ɵɵsanitizeStyle', moduleName: CORE };\nIdentifiers.sanitizeResourceUrl = { name: 'ɵɵsanitizeResourceUrl', moduleName: CORE };\nIdentifiers.sanitizeScript = { name: 'ɵɵsanitizeScript', moduleName: CORE };\nIdentifiers.sanitizeUrl = { name: 'ɵɵsanitizeUrl', moduleName: CORE };\nIdentifiers.sanitizeUrlOrResourceUrl = { name: 'ɵɵsanitizeUrlOrResourceUrl', moduleName: CORE };\nIdentifiers.trustConstantHtml = { name: 'ɵɵtrustConstantHtml', moduleName: CORE };\nIdentifiers.trustConstantResourceUrl = { name: 'ɵɵtrustConstantResourceUrl', moduleName: CORE };\nIdentifiers.validateIframeAttribute = { name: 'ɵɵvalidateIframeAttribute', moduleName: CORE };\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit\nconst VERSION$1 = 3;\nconst JS_B64_PREFIX = '# sourceMappingURL=data:application/json;base64,';\nclass SourceMapGenerator {\n constructor(file = null) {\n this.file = file;\n this.sourcesContent = new Map();\n this.lines = [];\n this.lastCol0 = 0;\n this.hasMappings = false;\n }\n // The content is `null` when the content is expected to be loaded using the URL\n addSource(url, content = null) {\n if (!this.sourcesContent.has(url)) {\n this.sourcesContent.set(url, content);\n }\n return this;\n }\n addLine() {\n this.lines.push([]);\n this.lastCol0 = 0;\n return this;\n }\n addMapping(col0, sourceUrl, sourceLine0, sourceCol0) {\n if (!this.currentLine) {\n throw new Error(`A line must be added before mappings can be added`);\n }\n if (sourceUrl != null && !this.sourcesContent.has(sourceUrl)) {\n throw new Error(`Unknown source file \"${sourceUrl}\"`);\n }\n if (col0 == null) {\n throw new Error(`The column in the generated code must be provided`);\n }\n if (col0 < this.lastCol0) {\n throw new Error(`Mapping should be added in output order`);\n }\n if (sourceUrl && (sourceLine0 == null || sourceCol0 == null)) {\n throw new Error(`The source location must be provided when a source url is provided`);\n }\n this.hasMappings = true;\n this.lastCol0 = col0;\n this.currentLine.push({ col0, sourceUrl, sourceLine0, sourceCol0 });\n return this;\n }\n /**\n * @internal strip this from published d.ts files due to\n * https://github.com/microsoft/TypeScript/issues/36216\n */\n get currentLine() {\n return this.lines.slice(-1)[0];\n }\n toJSON() {\n if (!this.hasMappings) {\n return null;\n }\n const sourcesIndex = new Map();\n const sources = [];\n const sourcesContent = [];\n Array.from(this.sourcesContent.keys()).forEach((url, i) => {\n sourcesIndex.set(url, i);\n sources.push(url);\n sourcesContent.push(this.sourcesContent.get(url) || null);\n });\n let mappings = '';\n let lastCol0 = 0;\n let lastSourceIndex = 0;\n let lastSourceLine0 = 0;\n let lastSourceCol0 = 0;\n this.lines.forEach(segments => {\n lastCol0 = 0;\n mappings += segments\n .map(segment => {\n // zero-based starting column of the line in the generated code\n let segAsStr = toBase64VLQ(segment.col0 - lastCol0);\n lastCol0 = segment.col0;\n if (segment.sourceUrl != null) {\n // zero-based index into the “sources” list\n segAsStr +=\n toBase64VLQ(sourcesIndex.get(segment.sourceUrl) - lastSourceIndex);\n lastSourceIndex = sourcesIndex.get(segment.sourceUrl);\n // the zero-based starting line in the original source\n segAsStr += toBase64VLQ(segment.sourceLine0 - lastSourceLine0);\n lastSourceLine0 = segment.sourceLine0;\n // the zero-based starting column in the original source\n segAsStr += toBase64VLQ(segment.sourceCol0 - lastSourceCol0);\n lastSourceCol0 = segment.sourceCol0;\n }\n return segAsStr;\n })\n .join(',');\n mappings += ';';\n });\n mappings = mappings.slice(0, -1);\n return {\n 'file': this.file || '',\n 'version': VERSION$1,\n 'sourceRoot': '',\n 'sources': sources,\n 'sourcesContent': sourcesContent,\n 'mappings': mappings,\n };\n }\n toJsComment() {\n return this.hasMappings ? '//' + JS_B64_PREFIX + toBase64String(JSON.stringify(this, null, 0)) :\n '';\n }\n}\nfunction toBase64String(value) {\n let b64 = '';\n const encoded = utf8Encode(value);\n for (let i = 0; i < encoded.length;) {\n const i1 = encoded[i++];\n const i2 = i < encoded.length ? encoded[i++] : null;\n const i3 = i < encoded.length ? encoded[i++] : null;\n b64 += toBase64Digit(i1 >> 2);\n b64 += toBase64Digit(((i1 & 3) << 4) | (i2 === null ? 0 : i2 >> 4));\n b64 += i2 === null ? '=' : toBase64Digit(((i2 & 15) << 2) | (i3 === null ? 0 : i3 >> 6));\n b64 += i2 === null || i3 === null ? '=' : toBase64Digit(i3 & 63);\n }\n return b64;\n}\nfunction toBase64VLQ(value) {\n value = value < 0 ? ((-value) << 1) + 1 : value << 1;\n let out = '';\n do {\n let digit = value & 31;\n value = value >> 5;\n if (value > 0) {\n digit = digit | 32;\n }\n out += toBase64Digit(digit);\n } while (value > 0);\n return out;\n}\nconst B64_DIGITS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\nfunction toBase64Digit(value) {\n if (value < 0 || value >= 64) {\n throw new Error(`Can only encode value in the range [0, 63]`);\n }\n return B64_DIGITS[value];\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst _SINGLE_QUOTE_ESCAPE_STRING_RE = /'|\\\\|\\n|\\r|\\$/g;\nconst _LEGAL_IDENTIFIER_RE = /^[$A-Z_][0-9A-Z_$]*$/i;\nconst _INDENT_WITH = ' ';\nclass _EmittedLine {\n constructor(indent) {\n this.indent = indent;\n this.partsLength = 0;\n this.parts = [];\n this.srcSpans = [];\n }\n}\nclass EmitterVisitorContext {\n constructor(_indent) {\n this._indent = _indent;\n this._lines = [new _EmittedLine(_indent)];\n }\n static createRoot() {\n return new EmitterVisitorContext(0);\n }\n /**\n * @internal strip this from published d.ts files due to\n * https://github.com/microsoft/TypeScript/issues/36216\n */\n get _currentLine() {\n return this._lines[this._lines.length - 1];\n }\n println(from, lastPart = '') {\n this.print(from || null, lastPart, true);\n }\n lineIsEmpty() {\n return this._currentLine.parts.length === 0;\n }\n lineLength() {\n return this._currentLine.indent * _INDENT_WITH.length + this._currentLine.partsLength;\n }\n print(from, part, newLine = false) {\n if (part.length > 0) {\n this._currentLine.parts.push(part);\n this._currentLine.partsLength += part.length;\n this._currentLine.srcSpans.push(from && from.sourceSpan || null);\n }\n if (newLine) {\n this._lines.push(new _EmittedLine(this._indent));\n }\n }\n removeEmptyLastLine() {\n if (this.lineIsEmpty()) {\n this._lines.pop();\n }\n }\n incIndent() {\n this._indent++;\n if (this.lineIsEmpty()) {\n this._currentLine.indent = this._indent;\n }\n }\n decIndent() {\n this._indent--;\n if (this.lineIsEmpty()) {\n this._currentLine.indent = this._indent;\n }\n }\n toSource() {\n return this.sourceLines\n .map(l => l.parts.length > 0 ? _createIndent(l.indent) + l.parts.join('') : '')\n .join('\\n');\n }\n toSourceMapGenerator(genFilePath, startsAtLine = 0) {\n const map = new SourceMapGenerator(genFilePath);\n let firstOffsetMapped = false;\n const mapFirstOffsetIfNeeded = () => {\n if (!firstOffsetMapped) {\n // Add a single space so that tools won't try to load the file from disk.\n // Note: We are using virtual urls like `ng:///`, so we have to\n // provide a content here.\n map.addSource(genFilePath, ' ').addMapping(0, genFilePath, 0, 0);\n firstOffsetMapped = true;\n }\n };\n for (let i = 0; i < startsAtLine; i++) {\n map.addLine();\n mapFirstOffsetIfNeeded();\n }\n this.sourceLines.forEach((line, lineIdx) => {\n map.addLine();\n const spans = line.srcSpans;\n const parts = line.parts;\n let col0 = line.indent * _INDENT_WITH.length;\n let spanIdx = 0;\n // skip leading parts without source spans\n while (spanIdx < spans.length && !spans[spanIdx]) {\n col0 += parts[spanIdx].length;\n spanIdx++;\n }\n if (spanIdx < spans.length && lineIdx === 0 && col0 === 0) {\n firstOffsetMapped = true;\n }\n else {\n mapFirstOffsetIfNeeded();\n }\n while (spanIdx < spans.length) {\n const span = spans[spanIdx];\n const source = span.start.file;\n const sourceLine = span.start.line;\n const sourceCol = span.start.col;\n map.addSource(source.url, source.content)\n .addMapping(col0, source.url, sourceLine, sourceCol);\n col0 += parts[spanIdx].length;\n spanIdx++;\n // assign parts without span or the same span to the previous segment\n while (spanIdx < spans.length && (span === spans[spanIdx] || !spans[spanIdx])) {\n col0 += parts[spanIdx].length;\n spanIdx++;\n }\n }\n });\n return map;\n }\n spanOf(line, column) {\n const emittedLine = this._lines[line];\n if (emittedLine) {\n let columnsLeft = column - _createIndent(emittedLine.indent).length;\n for (let partIndex = 0; partIndex < emittedLine.parts.length; partIndex++) {\n const part = emittedLine.parts[partIndex];\n if (part.length > columnsLeft) {\n return emittedLine.srcSpans[partIndex];\n }\n columnsLeft -= part.length;\n }\n }\n return null;\n }\n /**\n * @internal strip this from published d.ts files due to\n * https://github.com/microsoft/TypeScript/issues/36216\n */\n get sourceLines() {\n if (this._lines.length && this._lines[this._lines.length - 1].parts.length === 0) {\n return this._lines.slice(0, -1);\n }\n return this._lines;\n }\n}\nclass AbstractEmitterVisitor {\n constructor(_escapeDollarInStrings) {\n this._escapeDollarInStrings = _escapeDollarInStrings;\n }\n printLeadingComments(stmt, ctx) {\n if (stmt.leadingComments === undefined) {\n return;\n }\n for (const comment of stmt.leadingComments) {\n if (comment instanceof JSDocComment) {\n ctx.print(stmt, `/*${comment.toString()}*/`, comment.trailingNewline);\n }\n else {\n if (comment.multiline) {\n ctx.print(stmt, `/* ${comment.text} */`, comment.trailingNewline);\n }\n else {\n comment.text.split('\\n').forEach((line) => {\n ctx.println(stmt, `// ${line}`);\n });\n }\n }\n }\n }\n visitExpressionStmt(stmt, ctx) {\n this.printLeadingComments(stmt, ctx);\n stmt.expr.visitExpression(this, ctx);\n ctx.println(stmt, ';');\n return null;\n }\n visitReturnStmt(stmt, ctx) {\n this.printLeadingComments(stmt, ctx);\n ctx.print(stmt, `return `);\n stmt.value.visitExpression(this, ctx);\n ctx.println(stmt, ';');\n return null;\n }\n visitIfStmt(stmt, ctx) {\n this.printLeadingComments(stmt, ctx);\n ctx.print(stmt, `if (`);\n stmt.condition.visitExpression(this, ctx);\n ctx.print(stmt, `) {`);\n const hasElseCase = stmt.falseCase != null && stmt.falseCase.length > 0;\n if (stmt.trueCase.length <= 1 && !hasElseCase) {\n ctx.print(stmt, ` `);\n this.visitAllStatements(stmt.trueCase, ctx);\n ctx.removeEmptyLastLine();\n ctx.print(stmt, ` `);\n }\n else {\n ctx.println();\n ctx.incIndent();\n this.visitAllStatements(stmt.trueCase, ctx);\n ctx.decIndent();\n if (hasElseCase) {\n ctx.println(stmt, `} else {`);\n ctx.incIndent();\n this.visitAllStatements(stmt.falseCase, ctx);\n ctx.decIndent();\n }\n }\n ctx.println(stmt, `}`);\n return null;\n }\n visitWriteVarExpr(expr, ctx) {\n const lineWasEmpty = ctx.lineIsEmpty();\n if (!lineWasEmpty) {\n ctx.print(expr, '(');\n }\n ctx.print(expr, `${expr.name} = `);\n expr.value.visitExpression(this, ctx);\n if (!lineWasEmpty) {\n ctx.print(expr, ')');\n }\n return null;\n }\n visitWriteKeyExpr(expr, ctx) {\n const lineWasEmpty = ctx.lineIsEmpty();\n if (!lineWasEmpty) {\n ctx.print(expr, '(');\n }\n expr.receiver.visitExpression(this, ctx);\n ctx.print(expr, `[`);\n expr.index.visitExpression(this, ctx);\n ctx.print(expr, `] = `);\n expr.value.visitExpression(this, ctx);\n if (!lineWasEmpty) {\n ctx.print(expr, ')');\n }\n return null;\n }\n visitWritePropExpr(expr, ctx) {\n const lineWasEmpty = ctx.lineIsEmpty();\n if (!lineWasEmpty) {\n ctx.print(expr, '(');\n }\n expr.receiver.visitExpression(this, ctx);\n ctx.print(expr, `.${expr.name} = `);\n expr.value.visitExpression(this, ctx);\n if (!lineWasEmpty) {\n ctx.print(expr, ')');\n }\n return null;\n }\n visitInvokeFunctionExpr(expr, ctx) {\n expr.fn.visitExpression(this, ctx);\n ctx.print(expr, `(`);\n this.visitAllExpressions(expr.args, ctx, ',');\n ctx.print(expr, `)`);\n return null;\n }\n visitTaggedTemplateExpr(expr, ctx) {\n expr.tag.visitExpression(this, ctx);\n ctx.print(expr, '`' + expr.template.elements[0].rawText);\n for (let i = 1; i < expr.template.elements.length; i++) {\n ctx.print(expr, '${');\n expr.template.expressions[i - 1].visitExpression(this, ctx);\n ctx.print(expr, `}${expr.template.elements[i].rawText}`);\n }\n ctx.print(expr, '`');\n return null;\n }\n visitWrappedNodeExpr(ast, ctx) {\n throw new Error('Abstract emitter cannot visit WrappedNodeExpr.');\n }\n visitTypeofExpr(expr, ctx) {\n ctx.print(expr, 'typeof ');\n expr.expr.visitExpression(this, ctx);\n }\n visitReadVarExpr(ast, ctx) {\n ctx.print(ast, ast.name);\n return null;\n }\n visitInstantiateExpr(ast, ctx) {\n ctx.print(ast, `new `);\n ast.classExpr.visitExpression(this, ctx);\n ctx.print(ast, `(`);\n this.visitAllExpressions(ast.args, ctx, ',');\n ctx.print(ast, `)`);\n return null;\n }\n visitLiteralExpr(ast, ctx) {\n const value = ast.value;\n if (typeof value === 'string') {\n ctx.print(ast, escapeIdentifier(value, this._escapeDollarInStrings));\n }\n else {\n ctx.print(ast, `${value}`);\n }\n return null;\n }\n visitLocalizedString(ast, ctx) {\n const head = ast.serializeI18nHead();\n ctx.print(ast, '$localize `' + head.raw);\n for (let i = 1; i < ast.messageParts.length; i++) {\n ctx.print(ast, '${');\n ast.expressions[i - 1].visitExpression(this, ctx);\n ctx.print(ast, `}${ast.serializeI18nTemplatePart(i).raw}`);\n }\n ctx.print(ast, '`');\n return null;\n }\n visitConditionalExpr(ast, ctx) {\n ctx.print(ast, `(`);\n ast.condition.visitExpression(this, ctx);\n ctx.print(ast, '? ');\n ast.trueCase.visitExpression(this, ctx);\n ctx.print(ast, ': ');\n ast.falseCase.visitExpression(this, ctx);\n ctx.print(ast, `)`);\n return null;\n }\n visitNotExpr(ast, ctx) {\n ctx.print(ast, '!');\n ast.condition.visitExpression(this, ctx);\n return null;\n }\n visitUnaryOperatorExpr(ast, ctx) {\n let opStr;\n switch (ast.operator) {\n case UnaryOperator.Plus:\n opStr = '+';\n break;\n case UnaryOperator.Minus:\n opStr = '-';\n break;\n default:\n throw new Error(`Unknown operator ${ast.operator}`);\n }\n if (ast.parens)\n ctx.print(ast, `(`);\n ctx.print(ast, opStr);\n ast.expr.visitExpression(this, ctx);\n if (ast.parens)\n ctx.print(ast, `)`);\n return null;\n }\n visitBinaryOperatorExpr(ast, ctx) {\n let opStr;\n switch (ast.operator) {\n case BinaryOperator.Equals:\n opStr = '==';\n break;\n case BinaryOperator.Identical:\n opStr = '===';\n break;\n case BinaryOperator.NotEquals:\n opStr = '!=';\n break;\n case BinaryOperator.NotIdentical:\n opStr = '!==';\n break;\n case BinaryOperator.And:\n opStr = '&&';\n break;\n case BinaryOperator.BitwiseAnd:\n opStr = '&';\n break;\n case BinaryOperator.Or:\n opStr = '||';\n break;\n case BinaryOperator.Plus:\n opStr = '+';\n break;\n case BinaryOperator.Minus:\n opStr = '-';\n break;\n case BinaryOperator.Divide:\n opStr = '/';\n break;\n case BinaryOperator.Multiply:\n opStr = '*';\n break;\n case BinaryOperator.Modulo:\n opStr = '%';\n break;\n case BinaryOperator.Lower:\n opStr = '<';\n break;\n case BinaryOperator.LowerEquals:\n opStr = '<=';\n break;\n case BinaryOperator.Bigger:\n opStr = '>';\n break;\n case BinaryOperator.BiggerEquals:\n opStr = '>=';\n break;\n case BinaryOperator.NullishCoalesce:\n opStr = '??';\n break;\n default:\n throw new Error(`Unknown operator ${ast.operator}`);\n }\n if (ast.parens)\n ctx.print(ast, `(`);\n ast.lhs.visitExpression(this, ctx);\n ctx.print(ast, ` ${opStr} `);\n ast.rhs.visitExpression(this, ctx);\n if (ast.parens)\n ctx.print(ast, `)`);\n return null;\n }\n visitReadPropExpr(ast, ctx) {\n ast.receiver.visitExpression(this, ctx);\n ctx.print(ast, `.`);\n ctx.print(ast, ast.name);\n return null;\n }\n visitReadKeyExpr(ast, ctx) {\n ast.receiver.visitExpression(this, ctx);\n ctx.print(ast, `[`);\n ast.index.visitExpression(this, ctx);\n ctx.print(ast, `]`);\n return null;\n }\n visitLiteralArrayExpr(ast, ctx) {\n ctx.print(ast, `[`);\n this.visitAllExpressions(ast.entries, ctx, ',');\n ctx.print(ast, `]`);\n return null;\n }\n visitLiteralMapExpr(ast, ctx) {\n ctx.print(ast, `{`);\n this.visitAllObjects(entry => {\n ctx.print(ast, `${escapeIdentifier(entry.key, this._escapeDollarInStrings, entry.quoted)}:`);\n entry.value.visitExpression(this, ctx);\n }, ast.entries, ctx, ',');\n ctx.print(ast, `}`);\n return null;\n }\n visitCommaExpr(ast, ctx) {\n ctx.print(ast, '(');\n this.visitAllExpressions(ast.parts, ctx, ',');\n ctx.print(ast, ')');\n return null;\n }\n visitAllExpressions(expressions, ctx, separator) {\n this.visitAllObjects(expr => expr.visitExpression(this, ctx), expressions, ctx, separator);\n }\n visitAllObjects(handler, expressions, ctx, separator) {\n let incrementedIndent = false;\n for (let i = 0; i < expressions.length; i++) {\n if (i > 0) {\n if (ctx.lineLength() > 80) {\n ctx.print(null, separator, true);\n if (!incrementedIndent) {\n // continuation are marked with double indent.\n ctx.incIndent();\n ctx.incIndent();\n incrementedIndent = true;\n }\n }\n else {\n ctx.print(null, separator, false);\n }\n }\n handler(expressions[i]);\n }\n if (incrementedIndent) {\n // continuation are marked with double indent.\n ctx.decIndent();\n ctx.decIndent();\n }\n }\n visitAllStatements(statements, ctx) {\n statements.forEach((stmt) => stmt.visitStatement(this, ctx));\n }\n}\nfunction escapeIdentifier(input, escapeDollar, alwaysQuote = true) {\n if (input == null) {\n return null;\n }\n const body = input.replace(_SINGLE_QUOTE_ESCAPE_STRING_RE, (...match) => {\n if (match[0] == '$') {\n return escapeDollar ? '\\\\$' : '$';\n }\n else if (match[0] == '\\n') {\n return '\\\\n';\n }\n else if (match[0] == '\\r') {\n return '\\\\r';\n }\n else {\n return `\\\\${match[0]}`;\n }\n });\n const requiresQuotes = alwaysQuote || !_LEGAL_IDENTIFIER_RE.test(body);\n return requiresQuotes ? `'${body}'` : body;\n}\nfunction _createIndent(count) {\n let res = '';\n for (let i = 0; i < count; i++) {\n res += _INDENT_WITH;\n }\n return res;\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction typeWithParameters(type, numParams) {\n if (numParams === 0) {\n return expressionType(type);\n }\n const params = [];\n for (let i = 0; i < numParams; i++) {\n params.push(DYNAMIC_TYPE);\n }\n return expressionType(type, undefined, params);\n}\nconst ANIMATE_SYMBOL_PREFIX = '@';\nfunction prepareSyntheticPropertyName(name) {\n return `${ANIMATE_SYMBOL_PREFIX}${name}`;\n}\nfunction prepareSyntheticListenerName(name, phase) {\n return `${ANIMATE_SYMBOL_PREFIX}${name}.${phase}`;\n}\nfunction getSafePropertyAccessString(accessor, name) {\n const escapedName = escapeIdentifier(name, false, false);\n return escapedName !== name ? `${accessor}[${escapedName}]` : `${accessor}.${name}`;\n}\nfunction prepareSyntheticListenerFunctionName(name, phase) {\n return `animation_${name}_${phase}`;\n}\nfunction jitOnlyGuardedExpression(expr) {\n return guardedExpression('ngJitMode', expr);\n}\nfunction devOnlyGuardedExpression(expr) {\n return guardedExpression('ngDevMode', expr);\n}\nfunction guardedExpression(guard, expr) {\n const guardExpr = new ExternalExpr({ name: guard, moduleName: null });\n const guardNotDefined = new BinaryOperatorExpr(BinaryOperator.Identical, new TypeofExpr(guardExpr), literal('undefined'));\n const guardUndefinedOrTrue = new BinaryOperatorExpr(BinaryOperator.Or, guardNotDefined, guardExpr, /* type */ undefined, \n /* sourceSpan */ undefined, true);\n return new BinaryOperatorExpr(BinaryOperator.And, guardUndefinedOrTrue, expr);\n}\nfunction wrapReference(value) {\n const wrapped = new WrappedNodeExpr(value);\n return { value: wrapped, type: wrapped };\n}\nfunction refsToArray(refs, shouldForwardDeclare) {\n const values = literalArr(refs.map(ref => ref.value));\n return shouldForwardDeclare ? fn([], [new ReturnStatement(values)]) : values;\n}\nfunction createMayBeForwardRefExpression(expression, forwardRef) {\n return { expression, forwardRef };\n}\n/**\n * Convert a `MaybeForwardRefExpression` to an `Expression`, possibly wrapping its expression in a\n * `forwardRef()` call.\n *\n * If `MaybeForwardRefExpression.forwardRef` is `ForwardRefHandling.Unwrapped` then the expression\n * was originally wrapped in a `forwardRef()` call to prevent the value from being eagerly evaluated\n * in the code.\n *\n * See `packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts` and\n * `packages/compiler/src/jit_compiler_facade.ts` for more information.\n */\nfunction convertFromMaybeForwardRefExpression({ expression, forwardRef }) {\n switch (forwardRef) {\n case 0 /* None */:\n case 1 /* Wrapped */:\n return expression;\n case 2 /* Unwrapped */:\n return generateForwardRef(expression);\n }\n}\n/**\n * Generate an expression that has the given `expr` wrapped in the following form:\n *\n * ```\n * forwardRef(() => expr)\n * ```\n */\nfunction generateForwardRef(expr) {\n return importExpr(Identifiers.forwardRef).callFn([fn([], [new ReturnStatement(expr)])]);\n}\n\nvar R3FactoryDelegateType;\n(function (R3FactoryDelegateType) {\n R3FactoryDelegateType[R3FactoryDelegateType[\"Class\"] = 0] = \"Class\";\n R3FactoryDelegateType[R3FactoryDelegateType[\"Function\"] = 1] = \"Function\";\n})(R3FactoryDelegateType || (R3FactoryDelegateType = {}));\nvar FactoryTarget$1;\n(function (FactoryTarget) {\n FactoryTarget[FactoryTarget[\"Directive\"] = 0] = \"Directive\";\n FactoryTarget[FactoryTarget[\"Component\"] = 1] = \"Component\";\n FactoryTarget[FactoryTarget[\"Injectable\"] = 2] = \"Injectable\";\n FactoryTarget[FactoryTarget[\"Pipe\"] = 3] = \"Pipe\";\n FactoryTarget[FactoryTarget[\"NgModule\"] = 4] = \"NgModule\";\n})(FactoryTarget$1 || (FactoryTarget$1 = {}));\n/**\n * Construct a factory function expression for the given `R3FactoryMetadata`.\n */\nfunction compileFactoryFunction(meta) {\n const t = variable('t');\n let baseFactoryVar = null;\n // The type to instantiate via constructor invocation. If there is no delegated factory, meaning\n // this type is always created by constructor invocation, then this is the type-to-create\n // parameter provided by the user (t) if specified, or the current type if not. If there is a\n // delegated factory (which is used to create the current type) then this is only the type-to-\n // create parameter (t).\n const typeForCtor = !isDelegatedFactoryMetadata(meta) ?\n new BinaryOperatorExpr(BinaryOperator.Or, t, meta.internalType) :\n t;\n let ctorExpr = null;\n if (meta.deps !== null) {\n // There is a constructor (either explicitly or implicitly defined).\n if (meta.deps !== 'invalid') {\n ctorExpr = new InstantiateExpr(typeForCtor, injectDependencies(meta.deps, meta.target));\n }\n }\n else {\n // There is no constructor, use the base class' factory to construct typeForCtor.\n baseFactoryVar = variable(`ɵ${meta.name}_BaseFactory`);\n ctorExpr = baseFactoryVar.callFn([typeForCtor]);\n }\n const body = [];\n let retExpr = null;\n function makeConditionalFactory(nonCtorExpr) {\n const r = variable('r');\n body.push(r.set(NULL_EXPR).toDeclStmt());\n const ctorStmt = ctorExpr !== null ? r.set(ctorExpr).toStmt() :\n importExpr(Identifiers.invalidFactory).callFn([]).toStmt();\n body.push(ifStmt(t, [ctorStmt], [r.set(nonCtorExpr).toStmt()]));\n return r;\n }\n if (isDelegatedFactoryMetadata(meta)) {\n // This type is created with a delegated factory. If a type parameter is not specified, call\n // the factory instead.\n const delegateArgs = injectDependencies(meta.delegateDeps, meta.target);\n // Either call `new delegate(...)` or `delegate(...)` depending on meta.delegateType.\n const factoryExpr = new (meta.delegateType === R3FactoryDelegateType.Class ?\n InstantiateExpr :\n InvokeFunctionExpr)(meta.delegate, delegateArgs);\n retExpr = makeConditionalFactory(factoryExpr);\n }\n else if (isExpressionFactoryMetadata(meta)) {\n // TODO(alxhub): decide whether to lower the value here or in the caller\n retExpr = makeConditionalFactory(meta.expression);\n }\n else {\n retExpr = ctorExpr;\n }\n if (retExpr === null) {\n // The expression cannot be formed so render an `ɵɵinvalidFactory()` call.\n body.push(importExpr(Identifiers.invalidFactory).callFn([]).toStmt());\n }\n else if (baseFactoryVar !== null) {\n // This factory uses a base factory, so call `ɵɵgetInheritedFactory()` to compute it.\n const getInheritedFactoryCall = importExpr(Identifiers.getInheritedFactory).callFn([meta.internalType]);\n // Memoize the base factoryFn: `baseFactory || (baseFactory = ɵɵgetInheritedFactory(...))`\n const baseFactory = new BinaryOperatorExpr(BinaryOperator.Or, baseFactoryVar, baseFactoryVar.set(getInheritedFactoryCall));\n body.push(new ReturnStatement(baseFactory.callFn([typeForCtor])));\n }\n else {\n // This is straightforward factory, just return it.\n body.push(new ReturnStatement(retExpr));\n }\n let factoryFn = fn([new FnParam('t', DYNAMIC_TYPE)], body, INFERRED_TYPE, undefined, `${meta.name}_Factory`);\n if (baseFactoryVar !== null) {\n // There is a base factory variable so wrap its declaration along with the factory function into\n // an IIFE.\n factoryFn = fn([], [\n new DeclareVarStmt(baseFactoryVar.name), new ReturnStatement(factoryFn)\n ]).callFn([], /* sourceSpan */ undefined, /* pure */ true);\n }\n return {\n expression: factoryFn,\n statements: [],\n type: createFactoryType(meta),\n };\n}\nfunction createFactoryType(meta) {\n const ctorDepsType = meta.deps !== null && meta.deps !== 'invalid' ? createCtorDepsType(meta.deps) : NONE_TYPE;\n return expressionType(importExpr(Identifiers.FactoryDeclaration, [typeWithParameters(meta.type.type, meta.typeArgumentCount), ctorDepsType]));\n}\nfunction injectDependencies(deps, target) {\n return deps.map((dep, index) => compileInjectDependency(dep, target, index));\n}\nfunction compileInjectDependency(dep, target, index) {\n // Interpret the dependency according to its resolved type.\n if (dep.token === null) {\n return importExpr(Identifiers.invalidFactoryDep).callFn([literal(index)]);\n }\n else if (dep.attributeNameType === null) {\n // Build up the injection flags according to the metadata.\n const flags = 0 /* Default */ | (dep.self ? 2 /* Self */ : 0) |\n (dep.skipSelf ? 4 /* SkipSelf */ : 0) | (dep.host ? 1 /* Host */ : 0) |\n (dep.optional ? 8 /* Optional */ : 0) |\n (target === FactoryTarget$1.Pipe ? 16 /* ForPipe */ : 0);\n // If this dependency is optional or otherwise has non-default flags, then additional\n // parameters describing how to inject the dependency must be passed to the inject function\n // that's being used.\n let flagsParam = (flags !== 0 /* Default */ || dep.optional) ? literal(flags) : null;\n // Build up the arguments to the injectFn call.\n const injectArgs = [dep.token];\n if (flagsParam) {\n injectArgs.push(flagsParam);\n }\n const injectFn = getInjectFn(target);\n return importExpr(injectFn).callFn(injectArgs);\n }\n else {\n // The `dep.attributeTypeName` value is defined, which indicates that this is an `@Attribute()`\n // type dependency. For the generated JS we still want to use the `dep.token` value in case the\n // name given for the attribute is not a string literal. For example given `@Attribute(foo())`,\n // we want to generate `ɵɵinjectAttribute(foo())`.\n //\n // The `dep.attributeTypeName` is only actually used (in `createCtorDepType()`) to generate\n // typings.\n return importExpr(Identifiers.injectAttribute).callFn([dep.token]);\n }\n}\nfunction createCtorDepsType(deps) {\n let hasTypes = false;\n const attributeTypes = deps.map(dep => {\n const type = createCtorDepType(dep);\n if (type !== null) {\n hasTypes = true;\n return type;\n }\n else {\n return literal(null);\n }\n });\n if (hasTypes) {\n return expressionType(literalArr(attributeTypes));\n }\n else {\n return NONE_TYPE;\n }\n}\nfunction createCtorDepType(dep) {\n const entries = [];\n if (dep.attributeNameType !== null) {\n entries.push({ key: 'attribute', value: dep.attributeNameType, quoted: false });\n }\n if (dep.optional) {\n entries.push({ key: 'optional', value: literal(true), quoted: false });\n }\n if (dep.host) {\n entries.push({ key: 'host', value: literal(true), quoted: false });\n }\n if (dep.self) {\n entries.push({ key: 'self', value: literal(true), quoted: false });\n }\n if (dep.skipSelf) {\n entries.push({ key: 'skipSelf', value: literal(true), quoted: false });\n }\n return entries.length > 0 ? literalMap(entries) : null;\n}\nfunction isDelegatedFactoryMetadata(meta) {\n return meta.delegateType !== undefined;\n}\nfunction isExpressionFactoryMetadata(meta) {\n return meta.expression !== undefined;\n}\nfunction getInjectFn(target) {\n switch (target) {\n case FactoryTarget$1.Component:\n case FactoryTarget$1.Directive:\n case FactoryTarget$1.Pipe:\n return Identifiers.directiveInject;\n case FactoryTarget$1.NgModule:\n case FactoryTarget$1.Injectable:\n default:\n return Identifiers.inject;\n }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * This is an R3 `Node`-like wrapper for a raw `html.Comment` node. We do not currently\n * require the implementation of a visitor for Comments as they are only collected at\n * the top-level of the R3 AST, and only if `Render3ParseOptions['collectCommentNodes']`\n * is true.\n */\nclass Comment$1 {\n constructor(value, sourceSpan) {\n this.value = value;\n this.sourceSpan = sourceSpan;\n }\n visit(_visitor) {\n throw new Error('visit() not implemented for Comment');\n }\n}\nclass Text$3 {\n constructor(value, sourceSpan) {\n this.value = value;\n this.sourceSpan = sourceSpan;\n }\n visit(visitor) {\n return visitor.visitText(this);\n }\n}\nclass BoundText {\n constructor(value, sourceSpan, i18n) {\n this.value = value;\n this.sourceSpan = sourceSpan;\n this.i18n = i18n;\n }\n visit(visitor) {\n return visitor.visitBoundText(this);\n }\n}\n/**\n * Represents a text attribute in the template.\n *\n * `valueSpan` may not be present in cases where there is no value `
    `.\n * `keySpan` may also not be present for synthetic attributes from ICU expansions.\n */\nclass TextAttribute {\n constructor(name, value, sourceSpan, keySpan, valueSpan, i18n) {\n this.name = name;\n this.value = value;\n this.sourceSpan = sourceSpan;\n this.keySpan = keySpan;\n this.valueSpan = valueSpan;\n this.i18n = i18n;\n }\n visit(visitor) {\n return visitor.visitTextAttribute(this);\n }\n}\nclass BoundAttribute {\n constructor(name, type, securityContext, value, unit, sourceSpan, keySpan, valueSpan, i18n) {\n this.name = name;\n this.type = type;\n this.securityContext = securityContext;\n this.value = value;\n this.unit = unit;\n this.sourceSpan = sourceSpan;\n this.keySpan = keySpan;\n this.valueSpan = valueSpan;\n this.i18n = i18n;\n }\n static fromBoundElementProperty(prop, i18n) {\n if (prop.keySpan === undefined) {\n throw new Error(`Unexpected state: keySpan must be defined for bound attributes but was not for ${prop.name}: ${prop.sourceSpan}`);\n }\n return new BoundAttribute(prop.name, prop.type, prop.securityContext, prop.value, prop.unit, prop.sourceSpan, prop.keySpan, prop.valueSpan, i18n);\n }\n visit(visitor) {\n return visitor.visitBoundAttribute(this);\n }\n}\nclass BoundEvent {\n constructor(name, type, handler, target, phase, sourceSpan, handlerSpan, keySpan) {\n this.name = name;\n this.type = type;\n this.handler = handler;\n this.target = target;\n this.phase = phase;\n this.sourceSpan = sourceSpan;\n this.handlerSpan = handlerSpan;\n this.keySpan = keySpan;\n }\n static fromParsedEvent(event) {\n const target = event.type === 0 /* Regular */ ? event.targetOrPhase : null;\n const phase = event.type === 1 /* Animation */ ? event.targetOrPhase : null;\n if (event.keySpan === undefined) {\n throw new Error(`Unexpected state: keySpan must be defined for bound event but was not for ${event.name}: ${event.sourceSpan}`);\n }\n return new BoundEvent(event.name, event.type, event.handler, target, phase, event.sourceSpan, event.handlerSpan, event.keySpan);\n }\n visit(visitor) {\n return visitor.visitBoundEvent(this);\n }\n}\nclass Element$1 {\n constructor(name, attributes, inputs, outputs, children, references, sourceSpan, startSourceSpan, endSourceSpan, i18n) {\n this.name = name;\n this.attributes = attributes;\n this.inputs = inputs;\n this.outputs = outputs;\n this.children = children;\n this.references = references;\n this.sourceSpan = sourceSpan;\n this.startSourceSpan = startSourceSpan;\n this.endSourceSpan = endSourceSpan;\n this.i18n = i18n;\n }\n visit(visitor) {\n return visitor.visitElement(this);\n }\n}\nclass Template {\n constructor(\n // tagName is the name of the container element, if applicable.\n // `null` is a special case for when there is a structural directive on an `ng-template` so\n // the renderer can differentiate between the synthetic template and the one written in the\n // file.\n tagName, attributes, inputs, outputs, templateAttrs, children, references, variables, sourceSpan, startSourceSpan, endSourceSpan, i18n) {\n this.tagName = tagName;\n this.attributes = attributes;\n this.inputs = inputs;\n this.outputs = outputs;\n this.templateAttrs = templateAttrs;\n this.children = children;\n this.references = references;\n this.variables = variables;\n this.sourceSpan = sourceSpan;\n this.startSourceSpan = startSourceSpan;\n this.endSourceSpan = endSourceSpan;\n this.i18n = i18n;\n }\n visit(visitor) {\n return visitor.visitTemplate(this);\n }\n}\nclass Content {\n constructor(selector, attributes, sourceSpan, i18n) {\n this.selector = selector;\n this.attributes = attributes;\n this.sourceSpan = sourceSpan;\n this.i18n = i18n;\n this.name = 'ng-content';\n }\n visit(visitor) {\n return visitor.visitContent(this);\n }\n}\nclass Variable {\n constructor(name, value, sourceSpan, keySpan, valueSpan) {\n this.name = name;\n this.value = value;\n this.sourceSpan = sourceSpan;\n this.keySpan = keySpan;\n this.valueSpan = valueSpan;\n }\n visit(visitor) {\n return visitor.visitVariable(this);\n }\n}\nclass Reference {\n constructor(name, value, sourceSpan, keySpan, valueSpan) {\n this.name = name;\n this.value = value;\n this.sourceSpan = sourceSpan;\n this.keySpan = keySpan;\n this.valueSpan = valueSpan;\n }\n visit(visitor) {\n return visitor.visitReference(this);\n }\n}\nclass Icu$1 {\n constructor(vars, placeholders, sourceSpan, i18n) {\n this.vars = vars;\n this.placeholders = placeholders;\n this.sourceSpan = sourceSpan;\n this.i18n = i18n;\n }\n visit(visitor) {\n return visitor.visitIcu(this);\n }\n}\nclass NullVisitor {\n visitElement(element) { }\n visitTemplate(template) { }\n visitContent(content) { }\n visitVariable(variable) { }\n visitReference(reference) { }\n visitTextAttribute(attribute) { }\n visitBoundAttribute(attribute) { }\n visitBoundEvent(attribute) { }\n visitText(text) { }\n visitBoundText(text) { }\n visitIcu(icu) { }\n}\nclass RecursiveVisitor$1 {\n visitElement(element) {\n visitAll$1(this, element.attributes);\n visitAll$1(this, element.inputs);\n visitAll$1(this, element.outputs);\n visitAll$1(this, element.children);\n visitAll$1(this, element.references);\n }\n visitTemplate(template) {\n visitAll$1(this, template.attributes);\n visitAll$1(this, template.inputs);\n visitAll$1(this, template.outputs);\n visitAll$1(this, template.children);\n visitAll$1(this, template.references);\n visitAll$1(this, template.variables);\n }\n visitContent(content) { }\n visitVariable(variable) { }\n visitReference(reference) { }\n visitTextAttribute(attribute) { }\n visitBoundAttribute(attribute) { }\n visitBoundEvent(attribute) { }\n visitText(text) { }\n visitBoundText(text) { }\n visitIcu(icu) { }\n}\nclass TransformVisitor {\n visitElement(element) {\n const newAttributes = transformAll(this, element.attributes);\n const newInputs = transformAll(this, element.inputs);\n const newOutputs = transformAll(this, element.outputs);\n const newChildren = transformAll(this, element.children);\n const newReferences = transformAll(this, element.references);\n if (newAttributes != element.attributes || newInputs != element.inputs ||\n newOutputs != element.outputs || newChildren != element.children ||\n newReferences != element.references) {\n return new Element$1(element.name, newAttributes, newInputs, newOutputs, newChildren, newReferences, element.sourceSpan, element.startSourceSpan, element.endSourceSpan);\n }\n return element;\n }\n visitTemplate(template) {\n const newAttributes = transformAll(this, template.attributes);\n const newInputs = transformAll(this, template.inputs);\n const newOutputs = transformAll(this, template.outputs);\n const newTemplateAttrs = transformAll(this, template.templateAttrs);\n const newChildren = transformAll(this, template.children);\n const newReferences = transformAll(this, template.references);\n const newVariables = transformAll(this, template.variables);\n if (newAttributes != template.attributes || newInputs != template.inputs ||\n newOutputs != template.outputs || newTemplateAttrs != template.templateAttrs ||\n newChildren != template.children || newReferences != template.references ||\n newVariables != template.variables) {\n return new Template(template.tagName, newAttributes, newInputs, newOutputs, newTemplateAttrs, newChildren, newReferences, newVariables, template.sourceSpan, template.startSourceSpan, template.endSourceSpan);\n }\n return template;\n }\n visitContent(content) {\n return content;\n }\n visitVariable(variable) {\n return variable;\n }\n visitReference(reference) {\n return reference;\n }\n visitTextAttribute(attribute) {\n return attribute;\n }\n visitBoundAttribute(attribute) {\n return attribute;\n }\n visitBoundEvent(attribute) {\n return attribute;\n }\n visitText(text) {\n return text;\n }\n visitBoundText(text) {\n return text;\n }\n visitIcu(icu) {\n return icu;\n }\n}\nfunction visitAll$1(visitor, nodes) {\n const result = [];\n if (visitor.visit) {\n for (const node of nodes) {\n const newNode = visitor.visit(node) || node.visit(visitor);\n }\n }\n else {\n for (const node of nodes) {\n const newNode = node.visit(visitor);\n if (newNode) {\n result.push(newNode);\n }\n }\n }\n return result;\n}\nfunction transformAll(visitor, nodes) {\n const result = [];\n let changed = false;\n for (const node of nodes) {\n const newNode = node.visit(visitor);\n if (newNode) {\n result.push(newNode);\n }\n changed = changed || newNode != node;\n }\n return changed ? result : nodes;\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass Message {\n /**\n * @param nodes message AST\n * @param placeholders maps placeholder names to static content and their source spans\n * @param placeholderToMessage maps placeholder names to messages (used for nested ICU messages)\n * @param meaning\n * @param description\n * @param customId\n */\n constructor(nodes, placeholders, placeholderToMessage, meaning, description, customId) {\n this.nodes = nodes;\n this.placeholders = placeholders;\n this.placeholderToMessage = placeholderToMessage;\n this.meaning = meaning;\n this.description = description;\n this.customId = customId;\n this.id = this.customId;\n /** The ids to use if there are no custom id and if `i18nLegacyMessageIdFormat` is not empty */\n this.legacyIds = [];\n this.messageString = serializeMessage(this.nodes);\n if (nodes.length) {\n this.sources = [{\n filePath: nodes[0].sourceSpan.start.file.url,\n startLine: nodes[0].sourceSpan.start.line + 1,\n startCol: nodes[0].sourceSpan.start.col + 1,\n endLine: nodes[nodes.length - 1].sourceSpan.end.line + 1,\n endCol: nodes[0].sourceSpan.start.col + 1\n }];\n }\n else {\n this.sources = [];\n }\n }\n}\nclass Text$2 {\n constructor(value, sourceSpan) {\n this.value = value;\n this.sourceSpan = sourceSpan;\n }\n visit(visitor, context) {\n return visitor.visitText(this, context);\n }\n}\n// TODO(vicb): do we really need this node (vs an array) ?\nclass Container {\n constructor(children, sourceSpan) {\n this.children = children;\n this.sourceSpan = sourceSpan;\n }\n visit(visitor, context) {\n return visitor.visitContainer(this, context);\n }\n}\nclass Icu {\n constructor(expression, type, cases, sourceSpan) {\n this.expression = expression;\n this.type = type;\n this.cases = cases;\n this.sourceSpan = sourceSpan;\n }\n visit(visitor, context) {\n return visitor.visitIcu(this, context);\n }\n}\nclass TagPlaceholder {\n constructor(tag, attrs, startName, closeName, children, isVoid, \n // TODO sourceSpan should cover all (we need a startSourceSpan and endSourceSpan)\n sourceSpan, startSourceSpan, endSourceSpan) {\n this.tag = tag;\n this.attrs = attrs;\n this.startName = startName;\n this.closeName = closeName;\n this.children = children;\n this.isVoid = isVoid;\n this.sourceSpan = sourceSpan;\n this.startSourceSpan = startSourceSpan;\n this.endSourceSpan = endSourceSpan;\n }\n visit(visitor, context) {\n return visitor.visitTagPlaceholder(this, context);\n }\n}\nclass Placeholder {\n constructor(value, name, sourceSpan) {\n this.value = value;\n this.name = name;\n this.sourceSpan = sourceSpan;\n }\n visit(visitor, context) {\n return visitor.visitPlaceholder(this, context);\n }\n}\nclass IcuPlaceholder {\n constructor(value, name, sourceSpan) {\n this.value = value;\n this.name = name;\n this.sourceSpan = sourceSpan;\n }\n visit(visitor, context) {\n return visitor.visitIcuPlaceholder(this, context);\n }\n}\n// Clone the AST\nclass CloneVisitor {\n visitText(text, context) {\n return new Text$2(text.value, text.sourceSpan);\n }\n visitContainer(container, context) {\n const children = container.children.map(n => n.visit(this, context));\n return new Container(children, container.sourceSpan);\n }\n visitIcu(icu, context) {\n const cases = {};\n Object.keys(icu.cases).forEach(key => cases[key] = icu.cases[key].visit(this, context));\n const msg = new Icu(icu.expression, icu.type, cases, icu.sourceSpan);\n msg.expressionPlaceholder = icu.expressionPlaceholder;\n return msg;\n }\n visitTagPlaceholder(ph, context) {\n const children = ph.children.map(n => n.visit(this, context));\n return new TagPlaceholder(ph.tag, ph.attrs, ph.startName, ph.closeName, children, ph.isVoid, ph.sourceSpan, ph.startSourceSpan, ph.endSourceSpan);\n }\n visitPlaceholder(ph, context) {\n return new Placeholder(ph.value, ph.name, ph.sourceSpan);\n }\n visitIcuPlaceholder(ph, context) {\n return new IcuPlaceholder(ph.value, ph.name, ph.sourceSpan);\n }\n}\n// Visit all the nodes recursively\nclass RecurseVisitor {\n visitText(text, context) { }\n visitContainer(container, context) {\n container.children.forEach(child => child.visit(this));\n }\n visitIcu(icu, context) {\n Object.keys(icu.cases).forEach(k => {\n icu.cases[k].visit(this);\n });\n }\n visitTagPlaceholder(ph, context) {\n ph.children.forEach(child => child.visit(this));\n }\n visitPlaceholder(ph, context) { }\n visitIcuPlaceholder(ph, context) { }\n}\n/**\n * Serialize the message to the Localize backtick string format that would appear in compiled code.\n */\nfunction serializeMessage(messageNodes) {\n const visitor = new LocalizeMessageStringVisitor();\n const str = messageNodes.map(n => n.visit(visitor)).join('');\n return str;\n}\nclass LocalizeMessageStringVisitor {\n visitText(text) {\n return text.value;\n }\n visitContainer(container) {\n return container.children.map(child => child.visit(this)).join('');\n }\n visitIcu(icu) {\n const strCases = Object.keys(icu.cases).map((k) => `${k} {${icu.cases[k].visit(this)}}`);\n return `{${icu.expressionPlaceholder}, ${icu.type}, ${strCases.join(' ')}}`;\n }\n visitTagPlaceholder(ph) {\n const children = ph.children.map(child => child.visit(this)).join('');\n return `{$${ph.startName}}${children}{$${ph.closeName}}`;\n }\n visitPlaceholder(ph) {\n return `{$${ph.name}}`;\n }\n visitIcuPlaceholder(ph) {\n return `{$${ph.name}}`;\n }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass Serializer {\n // Creates a name mapper, see `PlaceholderMapper`\n // Returning `null` means that no name mapping is used.\n createNameMapper(message) {\n return null;\n }\n}\n/**\n * A simple mapper that take a function to transform an internal name to a public name\n */\nclass SimplePlaceholderMapper extends RecurseVisitor {\n // create a mapping from the message\n constructor(message, mapName) {\n super();\n this.mapName = mapName;\n this.internalToPublic = {};\n this.publicToNextId = {};\n this.publicToInternal = {};\n message.nodes.forEach(node => node.visit(this));\n }\n toPublicName(internalName) {\n return this.internalToPublic.hasOwnProperty(internalName) ?\n this.internalToPublic[internalName] :\n null;\n }\n toInternalName(publicName) {\n return this.publicToInternal.hasOwnProperty(publicName) ? this.publicToInternal[publicName] :\n null;\n }\n visitText(text, context) {\n return null;\n }\n visitTagPlaceholder(ph, context) {\n this.visitPlaceholderName(ph.startName);\n super.visitTagPlaceholder(ph, context);\n this.visitPlaceholderName(ph.closeName);\n }\n visitPlaceholder(ph, context) {\n this.visitPlaceholderName(ph.name);\n }\n visitIcuPlaceholder(ph, context) {\n this.visitPlaceholderName(ph.name);\n }\n // XMB placeholders could only contains A-Z, 0-9 and _\n visitPlaceholderName(internalName) {\n if (!internalName || this.internalToPublic.hasOwnProperty(internalName)) {\n return;\n }\n let publicName = this.mapName(internalName);\n if (this.publicToInternal.hasOwnProperty(publicName)) {\n // Create a new XMB when it has already been used\n const nextId = this.publicToNextId[publicName];\n this.publicToNextId[publicName] = nextId + 1;\n publicName = `${publicName}_${nextId}`;\n }\n else {\n this.publicToNextId[publicName] = 1;\n }\n this.internalToPublic[internalName] = publicName;\n this.publicToInternal[publicName] = internalName;\n }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass _Visitor$2 {\n visitTag(tag) {\n const strAttrs = this._serializeAttributes(tag.attrs);\n if (tag.children.length == 0) {\n return `<${tag.name}${strAttrs}/>`;\n }\n const strChildren = tag.children.map(node => node.visit(this));\n return `<${tag.name}${strAttrs}>${strChildren.join('')}`;\n }\n visitText(text) {\n return text.value;\n }\n visitDeclaration(decl) {\n return ``;\n }\n _serializeAttributes(attrs) {\n const strAttrs = Object.keys(attrs).map((name) => `${name}=\"${attrs[name]}\"`).join(' ');\n return strAttrs.length > 0 ? ' ' + strAttrs : '';\n }\n visitDoctype(doctype) {\n return ``;\n }\n}\nconst _visitor = new _Visitor$2();\nfunction serialize(nodes) {\n return nodes.map((node) => node.visit(_visitor)).join('');\n}\nclass Declaration {\n constructor(unescapedAttrs) {\n this.attrs = {};\n Object.keys(unescapedAttrs).forEach((k) => {\n this.attrs[k] = escapeXml(unescapedAttrs[k]);\n });\n }\n visit(visitor) {\n return visitor.visitDeclaration(this);\n }\n}\nclass Doctype {\n constructor(rootTag, dtd) {\n this.rootTag = rootTag;\n this.dtd = dtd;\n }\n visit(visitor) {\n return visitor.visitDoctype(this);\n }\n}\nclass Tag {\n constructor(name, unescapedAttrs = {}, children = []) {\n this.name = name;\n this.children = children;\n this.attrs = {};\n Object.keys(unescapedAttrs).forEach((k) => {\n this.attrs[k] = escapeXml(unescapedAttrs[k]);\n });\n }\n visit(visitor) {\n return visitor.visitTag(this);\n }\n}\nclass Text$1 {\n constructor(unescapedValue) {\n this.value = escapeXml(unescapedValue);\n }\n visit(visitor) {\n return visitor.visitText(this);\n }\n}\nclass CR extends Text$1 {\n constructor(ws = 0) {\n super(`\\n${new Array(ws + 1).join(' ')}`);\n }\n}\nconst _ESCAPED_CHARS = [\n [/&/g, '&'],\n [/\"/g, '"'],\n [/'/g, '''],\n [//g, '>'],\n];\n// Escape `_ESCAPED_CHARS` characters in the given text with encoded entities\nfunction escapeXml(text) {\n return _ESCAPED_CHARS.reduce((text, entry) => text.replace(entry[0], entry[1]), text);\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst _MESSAGES_TAG = 'messagebundle';\nconst _MESSAGE_TAG = 'msg';\nconst _PLACEHOLDER_TAG$3 = 'ph';\nconst _EXAMPLE_TAG = 'ex';\nconst _SOURCE_TAG$2 = 'source';\nconst _DOCTYPE = `\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n`;\nclass Xmb extends Serializer {\n write(messages, locale) {\n const exampleVisitor = new ExampleVisitor();\n const visitor = new _Visitor$1();\n let rootNode = new Tag(_MESSAGES_TAG);\n messages.forEach(message => {\n const attrs = { id: message.id };\n if (message.description) {\n attrs['desc'] = message.description;\n }\n if (message.meaning) {\n attrs['meaning'] = message.meaning;\n }\n let sourceTags = [];\n message.sources.forEach((source) => {\n sourceTags.push(new Tag(_SOURCE_TAG$2, {}, [new Text$1(`${source.filePath}:${source.startLine}${source.endLine !== source.startLine ? ',' + source.endLine : ''}`)]));\n });\n rootNode.children.push(new CR(2), new Tag(_MESSAGE_TAG, attrs, [...sourceTags, ...visitor.serialize(message.nodes)]));\n });\n rootNode.children.push(new CR());\n return serialize([\n new Declaration({ version: '1.0', encoding: 'UTF-8' }),\n new CR(),\n new Doctype(_MESSAGES_TAG, _DOCTYPE),\n new CR(),\n exampleVisitor.addDefaultExamples(rootNode),\n new CR(),\n ]);\n }\n load(content, url) {\n throw new Error('Unsupported');\n }\n digest(message) {\n return digest(message);\n }\n createNameMapper(message) {\n return new SimplePlaceholderMapper(message, toPublicName);\n }\n}\nclass _Visitor$1 {\n visitText(text, context) {\n return [new Text$1(text.value)];\n }\n visitContainer(container, context) {\n const nodes = [];\n container.children.forEach((node) => nodes.push(...node.visit(this)));\n return nodes;\n }\n visitIcu(icu, context) {\n const nodes = [new Text$1(`{${icu.expressionPlaceholder}, ${icu.type}, `)];\n Object.keys(icu.cases).forEach((c) => {\n nodes.push(new Text$1(`${c} {`), ...icu.cases[c].visit(this), new Text$1(`} `));\n });\n nodes.push(new Text$1(`}`));\n return nodes;\n }\n visitTagPlaceholder(ph, context) {\n const startTagAsText = new Text$1(`<${ph.tag}>`);\n const startEx = new Tag(_EXAMPLE_TAG, {}, [startTagAsText]);\n // TC requires PH to have a non empty EX, and uses the text node to show the \"original\" value.\n const startTagPh = new Tag(_PLACEHOLDER_TAG$3, { name: ph.startName }, [startEx, startTagAsText]);\n if (ph.isVoid) {\n // void tags have no children nor closing tags\n return [startTagPh];\n }\n const closeTagAsText = new Text$1(``);\n const closeEx = new Tag(_EXAMPLE_TAG, {}, [closeTagAsText]);\n // TC requires PH to have a non empty EX, and uses the text node to show the \"original\" value.\n const closeTagPh = new Tag(_PLACEHOLDER_TAG$3, { name: ph.closeName }, [closeEx, closeTagAsText]);\n return [startTagPh, ...this.serialize(ph.children), closeTagPh];\n }\n visitPlaceholder(ph, context) {\n const interpolationAsText = new Text$1(`{{${ph.value}}}`);\n // Example tag needs to be not-empty for TC.\n const exTag = new Tag(_EXAMPLE_TAG, {}, [interpolationAsText]);\n return [\n // TC requires PH to have a non empty EX, and uses the text node to show the \"original\" value.\n new Tag(_PLACEHOLDER_TAG$3, { name: ph.name }, [exTag, interpolationAsText])\n ];\n }\n visitIcuPlaceholder(ph, context) {\n const icuExpression = ph.value.expression;\n const icuType = ph.value.type;\n const icuCases = Object.keys(ph.value.cases).map((value) => value + ' {...}').join(' ');\n const icuAsText = new Text$1(`{${icuExpression}, ${icuType}, ${icuCases}}`);\n const exTag = new Tag(_EXAMPLE_TAG, {}, [icuAsText]);\n return [\n // TC requires PH to have a non empty EX, and uses the text node to show the \"original\" value.\n new Tag(_PLACEHOLDER_TAG$3, { name: ph.name }, [exTag, icuAsText])\n ];\n }\n serialize(nodes) {\n return [].concat(...nodes.map(node => node.visit(this)));\n }\n}\nfunction digest(message) {\n return decimalDigest(message);\n}\n// TC requires at least one non-empty example on placeholders\nclass ExampleVisitor {\n addDefaultExamples(node) {\n node.visit(this);\n return node;\n }\n visitTag(tag) {\n if (tag.name === _PLACEHOLDER_TAG$3) {\n if (!tag.children || tag.children.length == 0) {\n const exText = new Text$1(tag.attrs['name'] || '...');\n tag.children = [new Tag(_EXAMPLE_TAG, {}, [exText])];\n }\n }\n else if (tag.children) {\n tag.children.forEach(node => node.visit(this));\n }\n }\n visitText(text) { }\n visitDeclaration(decl) { }\n visitDoctype(doctype) { }\n}\n// XMB/XTB placeholders can only contain A-Z, 0-9 and _\nfunction toPublicName(internalName) {\n return internalName.toUpperCase().replace(/[^A-Z0-9_]/g, '_');\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/* Closure variables holding messages must be named `MSG_[A-Z0-9]+` */\nconst CLOSURE_TRANSLATION_VAR_PREFIX = 'MSG_';\n/**\n * Prefix for non-`goog.getMsg` i18n-related vars.\n * Note: the prefix uses lowercase characters intentionally due to a Closure behavior that\n * considers variables like `I18N_0` as constants and throws an error when their value changes.\n */\nconst TRANSLATION_VAR_PREFIX = 'i18n_';\n/** Name of the i18n attributes **/\nconst I18N_ATTR = 'i18n';\nconst I18N_ATTR_PREFIX = 'i18n-';\n/** Prefix of var expressions used in ICUs */\nconst I18N_ICU_VAR_PREFIX = 'VAR_';\n/** Prefix of ICU expressions for post processing */\nconst I18N_ICU_MAPPING_PREFIX = 'I18N_EXP_';\n/** Placeholder wrapper for i18n expressions **/\nconst I18N_PLACEHOLDER_SYMBOL = '�';\nfunction isI18nAttribute(name) {\n return name === I18N_ATTR || name.startsWith(I18N_ATTR_PREFIX);\n}\nfunction isI18nRootNode(meta) {\n return meta instanceof Message;\n}\nfunction isSingleI18nIcu(meta) {\n return isI18nRootNode(meta) && meta.nodes.length === 1 && meta.nodes[0] instanceof Icu;\n}\nfunction hasI18nMeta(node) {\n return !!node.i18n;\n}\nfunction hasI18nAttrs(element) {\n return element.attrs.some((attr) => isI18nAttribute(attr.name));\n}\nfunction icuFromI18nMessage(message) {\n return message.nodes[0];\n}\nfunction wrapI18nPlaceholder(content, contextId = 0) {\n const blockId = contextId > 0 ? `:${contextId}` : '';\n return `${I18N_PLACEHOLDER_SYMBOL}${content}${blockId}${I18N_PLACEHOLDER_SYMBOL}`;\n}\nfunction assembleI18nBoundString(strings, bindingStartIndex = 0, contextId = 0) {\n if (!strings.length)\n return '';\n let acc = '';\n const lastIdx = strings.length - 1;\n for (let i = 0; i < lastIdx; i++) {\n acc += `${strings[i]}${wrapI18nPlaceholder(bindingStartIndex + i, contextId)}`;\n }\n acc += strings[lastIdx];\n return acc;\n}\nfunction getSeqNumberGenerator(startsAt = 0) {\n let current = startsAt;\n return () => current++;\n}\nfunction placeholdersToParams(placeholders) {\n const params = {};\n placeholders.forEach((values, key) => {\n params[key] = literal(values.length > 1 ? `[${values.join('|')}]` : values[0]);\n });\n return params;\n}\nfunction updatePlaceholderMap(map, name, ...values) {\n const current = map.get(name) || [];\n current.push(...values);\n map.set(name, current);\n}\nfunction assembleBoundTextPlaceholders(meta, bindingStartIndex = 0, contextId = 0) {\n const startIdx = bindingStartIndex;\n const placeholders = new Map();\n const node = meta instanceof Message ? meta.nodes.find(node => node instanceof Container) : meta;\n if (node) {\n node\n .children\n .filter((child) => child instanceof Placeholder)\n .forEach((child, idx) => {\n const content = wrapI18nPlaceholder(startIdx + idx, contextId);\n updatePlaceholderMap(placeholders, child.name, content);\n });\n }\n return placeholders;\n}\n/**\n * Format the placeholder names in a map of placeholders to expressions.\n *\n * The placeholder names are converted from \"internal\" format (e.g. `START_TAG_DIV_1`) to \"external\"\n * format (e.g. `startTagDiv_1`).\n *\n * @param params A map of placeholder names to expressions.\n * @param useCamelCase whether to camelCase the placeholder name when formatting.\n * @returns A new map of formatted placeholder names to expressions.\n */\nfunction i18nFormatPlaceholderNames(params = {}, useCamelCase) {\n const _params = {};\n if (params && Object.keys(params).length) {\n Object.keys(params).forEach(key => _params[formatI18nPlaceholderName(key, useCamelCase)] = params[key]);\n }\n return _params;\n}\n/**\n * Converts internal placeholder names to public-facing format\n * (for example to use in goog.getMsg call).\n * Example: `START_TAG_DIV_1` is converted to `startTagDiv_1`.\n *\n * @param name The placeholder name that should be formatted\n * @returns Formatted placeholder name\n */\nfunction formatI18nPlaceholderName(name, useCamelCase = true) {\n const publicName = toPublicName(name);\n if (!useCamelCase) {\n return publicName;\n }\n const chunks = publicName.split('_');\n if (chunks.length === 1) {\n // if no \"_\" found - just lowercase the value\n return name.toLowerCase();\n }\n let postfix;\n // eject last element if it's a number\n if (/^\\d+$/.test(chunks[chunks.length - 1])) {\n postfix = chunks.pop();\n }\n let raw = chunks.shift().toLowerCase();\n if (chunks.length) {\n raw += chunks.map(c => c.charAt(0).toUpperCase() + c.slice(1).toLowerCase()).join('');\n }\n return postfix ? `${raw}_${postfix}` : raw;\n}\n/**\n * Generates a prefix for translation const name.\n *\n * @param extra Additional local prefix that should be injected into translation var name\n * @returns Complete translation const prefix\n */\nfunction getTranslationConstPrefix(extra) {\n return `${CLOSURE_TRANSLATION_VAR_PREFIX}${extra}`.toUpperCase();\n}\n/**\n * Generate AST to declare a variable. E.g. `var I18N_1;`.\n * @param variable the name of the variable to declare.\n */\nfunction declareI18nVariable(variable) {\n return new DeclareVarStmt(variable.name, undefined, INFERRED_TYPE, undefined, variable.sourceSpan);\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Checks whether an object key contains potentially unsafe chars, thus the key should be wrapped in\n * quotes. Note: we do not wrap all keys into quotes, as it may have impact on minification and may\n * bot work in some cases when object keys are mangled by minifier.\n *\n * TODO(FW-1136): this is a temporary solution, we need to come up with a better way of working with\n * inputs that contain potentially unsafe chars.\n */\nconst UNSAFE_OBJECT_KEY_NAME_REGEXP = /[-.]/;\n/** Name of the temporary to use during data binding */\nconst TEMPORARY_NAME = '_t';\n/** Name of the context parameter passed into a template function */\nconst CONTEXT_NAME = 'ctx';\n/** Name of the RenderFlag passed into a template function */\nconst RENDER_FLAGS = 'rf';\n/** The prefix reference variables */\nconst REFERENCE_PREFIX = '_r';\n/** The name of the implicit context reference */\nconst IMPLICIT_REFERENCE = '$implicit';\n/** Non bindable attribute name **/\nconst NON_BINDABLE_ATTR = 'ngNonBindable';\n/** Name for the variable keeping track of the context returned by `ɵɵrestoreView`. */\nconst RESTORED_VIEW_CONTEXT_NAME = 'restoredCtx';\n/**\n * Maximum length of a single instruction chain. Because our output AST uses recursion, we're\n * limited in how many expressions we can nest before we reach the call stack limit. This\n * length is set very conservatively in order to reduce the chance of problems.\n */\nconst MAX_CHAIN_LENGTH = 500;\n/** Instructions that support chaining. */\nconst CHAINABLE_INSTRUCTIONS = new Set([\n Identifiers.element,\n Identifiers.elementStart,\n Identifiers.elementEnd,\n Identifiers.elementContainer,\n Identifiers.elementContainerStart,\n Identifiers.elementContainerEnd,\n Identifiers.i18nExp,\n Identifiers.listener,\n Identifiers.classProp,\n Identifiers.syntheticHostListener,\n Identifiers.hostProperty,\n Identifiers.syntheticHostProperty,\n Identifiers.property,\n Identifiers.propertyInterpolate1,\n Identifiers.propertyInterpolate2,\n Identifiers.propertyInterpolate3,\n Identifiers.propertyInterpolate4,\n Identifiers.propertyInterpolate5,\n Identifiers.propertyInterpolate6,\n Identifiers.propertyInterpolate7,\n Identifiers.propertyInterpolate8,\n Identifiers.propertyInterpolateV,\n Identifiers.attribute,\n Identifiers.attributeInterpolate1,\n Identifiers.attributeInterpolate2,\n Identifiers.attributeInterpolate3,\n Identifiers.attributeInterpolate4,\n Identifiers.attributeInterpolate5,\n Identifiers.attributeInterpolate6,\n Identifiers.attributeInterpolate7,\n Identifiers.attributeInterpolate8,\n Identifiers.attributeInterpolateV,\n Identifiers.styleProp,\n Identifiers.stylePropInterpolate1,\n Identifiers.stylePropInterpolate2,\n Identifiers.stylePropInterpolate3,\n Identifiers.stylePropInterpolate4,\n Identifiers.stylePropInterpolate5,\n Identifiers.stylePropInterpolate6,\n Identifiers.stylePropInterpolate7,\n Identifiers.stylePropInterpolate8,\n Identifiers.stylePropInterpolateV,\n Identifiers.textInterpolate,\n Identifiers.textInterpolate1,\n Identifiers.textInterpolate2,\n Identifiers.textInterpolate3,\n Identifiers.textInterpolate4,\n Identifiers.textInterpolate5,\n Identifiers.textInterpolate6,\n Identifiers.textInterpolate7,\n Identifiers.textInterpolate8,\n Identifiers.textInterpolateV,\n]);\n/** Generates a call to a single instruction. */\nfunction invokeInstruction(span, reference, params) {\n return importExpr(reference, null, span).callFn(params, span);\n}\n/**\n * Creates an allocator for a temporary variable.\n *\n * A variable declaration is added to the statements the first time the allocator is invoked.\n */\nfunction temporaryAllocator(statements, name) {\n let temp = null;\n return () => {\n if (!temp) {\n statements.push(new DeclareVarStmt(TEMPORARY_NAME, undefined, DYNAMIC_TYPE));\n temp = variable(name);\n }\n return temp;\n };\n}\nfunction invalid(arg) {\n throw new Error(`Invalid state: Visitor ${this.constructor.name} doesn't handle ${arg.constructor.name}`);\n}\nfunction asLiteral(value) {\n if (Array.isArray(value)) {\n return literalArr(value.map(asLiteral));\n }\n return literal(value, INFERRED_TYPE);\n}\nfunction conditionallyCreateMapObjectLiteral(keys, keepDeclared) {\n if (Object.getOwnPropertyNames(keys).length > 0) {\n return mapToExpression(keys, keepDeclared);\n }\n return null;\n}\nfunction mapToExpression(map, keepDeclared) {\n return literalMap(Object.getOwnPropertyNames(map).map(key => {\n // canonical syntax: `dirProp: publicProp`\n // if there is no `:`, use dirProp = elProp\n const value = map[key];\n let declaredName;\n let publicName;\n let minifiedName;\n let needsDeclaredName;\n if (Array.isArray(value)) {\n [publicName, declaredName] = value;\n minifiedName = key;\n needsDeclaredName = publicName !== declaredName;\n }\n else {\n [declaredName, publicName] = splitAtColon(key, [key, value]);\n minifiedName = declaredName;\n // Only include the declared name if extracted from the key, i.e. the key contains a colon.\n // Otherwise the declared name should be omitted even if it is different from the public name,\n // as it may have already been minified.\n needsDeclaredName = publicName !== declaredName && key.includes(':');\n }\n return {\n key: minifiedName,\n // put quotes around keys that contain potentially unsafe characters\n quoted: UNSAFE_OBJECT_KEY_NAME_REGEXP.test(minifiedName),\n value: (keepDeclared && needsDeclaredName) ?\n literalArr([asLiteral(publicName), asLiteral(declaredName)]) :\n asLiteral(publicName)\n };\n }));\n}\n/**\n * Remove trailing null nodes as they are implied.\n */\nfunction trimTrailingNulls(parameters) {\n while (isNull(parameters[parameters.length - 1])) {\n parameters.pop();\n }\n return parameters;\n}\nfunction getQueryPredicate(query, constantPool) {\n if (Array.isArray(query.predicate)) {\n let predicate = [];\n query.predicate.forEach((selector) => {\n // Each item in predicates array may contain strings with comma-separated refs\n // (for ex. 'ref, ref1, ..., refN'), thus we extract individual refs and store them\n // as separate array entities\n const selectors = selector.split(',').map(token => literal(token.trim()));\n predicate.push(...selectors);\n });\n return constantPool.getConstLiteral(literalArr(predicate), true);\n }\n else {\n // The original predicate may have been wrapped in a `forwardRef()` call.\n switch (query.predicate.forwardRef) {\n case 0 /* None */:\n case 2 /* Unwrapped */:\n return query.predicate.expression;\n case 1 /* Wrapped */:\n return importExpr(Identifiers.resolveForwardRef).callFn([query.predicate.expression]);\n }\n }\n}\n/**\n * A representation for an object literal used during codegen of definition objects. The generic\n * type `T` allows to reference a documented type of the generated structure, such that the\n * property names that are set can be resolved to their documented declaration.\n */\nclass DefinitionMap {\n constructor() {\n this.values = [];\n }\n set(key, value) {\n if (value) {\n this.values.push({ key: key, value, quoted: false });\n }\n }\n toLiteralMap() {\n return literalMap(this.values);\n }\n}\n/**\n * Extract a map of properties to values for a given element or template node, which can be used\n * by the directive matching machinery.\n *\n * @param elOrTpl the element or template in question\n * @return an object set up for directive matching. For attributes on the element/template, this\n * object maps a property name to its (static) value. For any bindings, this map simply maps the\n * property name to an empty string.\n */\nfunction getAttrsForDirectiveMatching(elOrTpl) {\n const attributesMap = {};\n if (elOrTpl instanceof Template && elOrTpl.tagName !== 'ng-template') {\n elOrTpl.templateAttrs.forEach(a => attributesMap[a.name] = '');\n }\n else {\n elOrTpl.attributes.forEach(a => {\n if (!isI18nAttribute(a.name)) {\n attributesMap[a.name] = a.value;\n }\n });\n elOrTpl.inputs.forEach(i => {\n attributesMap[i.name] = '';\n });\n elOrTpl.outputs.forEach(o => {\n attributesMap[o.name] = '';\n });\n }\n return attributesMap;\n}\n/**\n * Gets the number of arguments expected to be passed to a generated instruction in the case of\n * interpolation instructions.\n * @param interpolation An interpolation ast\n */\nfunction getInterpolationArgsLength(interpolation) {\n const { expressions, strings } = interpolation;\n if (expressions.length === 1 && strings.length === 2 && strings[0] === '' && strings[1] === '') {\n // If the interpolation has one interpolated value, but the prefix and suffix are both empty\n // strings, we only pass one argument, to a special instruction like `propertyInterpolate` or\n // `textInterpolate`.\n return 1;\n }\n else {\n return expressions.length + strings.length;\n }\n}\n/**\n * Generates the final instruction call statements based on the passed in configuration.\n * Will try to chain instructions as much as possible, if chaining is supported.\n */\nfunction getInstructionStatements(instructions) {\n const statements = [];\n let pendingExpression = null;\n let pendingExpressionType = null;\n let chainLength = 0;\n for (const current of instructions) {\n const resolvedParams = (typeof current.paramsOrFn === 'function' ? current.paramsOrFn() : current.paramsOrFn) ??\n [];\n const params = Array.isArray(resolvedParams) ? resolvedParams : [resolvedParams];\n // If the current instruction is the same as the previous one\n // and it can be chained, add another call to the chain.\n if (chainLength < MAX_CHAIN_LENGTH && pendingExpressionType === current.reference &&\n CHAINABLE_INSTRUCTIONS.has(pendingExpressionType)) {\n // We'll always have a pending expression when there's a pending expression type.\n pendingExpression = pendingExpression.callFn(params, pendingExpression.sourceSpan);\n chainLength++;\n }\n else {\n if (pendingExpression !== null) {\n statements.push(pendingExpression.toStmt());\n }\n pendingExpression = invokeInstruction(current.span, current.reference, params);\n pendingExpressionType = current.reference;\n chainLength = 0;\n }\n }\n // Since the current instruction adds the previous one to the statements,\n // we may be left with the final one at the end that is still pending.\n if (pendingExpression !== null) {\n statements.push(pendingExpression.toStmt());\n }\n return statements;\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction compileInjectable(meta, resolveForwardRefs) {\n let result = null;\n const factoryMeta = {\n name: meta.name,\n type: meta.type,\n internalType: meta.internalType,\n typeArgumentCount: meta.typeArgumentCount,\n deps: [],\n target: FactoryTarget$1.Injectable,\n };\n if (meta.useClass !== undefined) {\n // meta.useClass has two modes of operation. Either deps are specified, in which case `new` is\n // used to instantiate the class with dependencies injected, or deps are not specified and\n // the factory of the class is used to instantiate it.\n //\n // A special case exists for useClass: Type where Type is the injectable type itself and no\n // deps are specified, in which case 'useClass' is effectively ignored.\n const useClassOnSelf = meta.useClass.expression.isEquivalent(meta.internalType);\n let deps = undefined;\n if (meta.deps !== undefined) {\n deps = meta.deps;\n }\n if (deps !== undefined) {\n // factory: () => new meta.useClass(...deps)\n result = compileFactoryFunction({\n ...factoryMeta,\n delegate: meta.useClass.expression,\n delegateDeps: deps,\n delegateType: R3FactoryDelegateType.Class,\n });\n }\n else if (useClassOnSelf) {\n result = compileFactoryFunction(factoryMeta);\n }\n else {\n result = {\n statements: [],\n expression: delegateToFactory(meta.type.value, meta.useClass.expression, resolveForwardRefs)\n };\n }\n }\n else if (meta.useFactory !== undefined) {\n if (meta.deps !== undefined) {\n result = compileFactoryFunction({\n ...factoryMeta,\n delegate: meta.useFactory,\n delegateDeps: meta.deps || [],\n delegateType: R3FactoryDelegateType.Function,\n });\n }\n else {\n result = {\n statements: [],\n expression: fn([], [new ReturnStatement(meta.useFactory.callFn([]))])\n };\n }\n }\n else if (meta.useValue !== undefined) {\n // Note: it's safe to use `meta.useValue` instead of the `USE_VALUE in meta` check used for\n // client code because meta.useValue is an Expression which will be defined even if the actual\n // value is undefined.\n result = compileFactoryFunction({\n ...factoryMeta,\n expression: meta.useValue.expression,\n });\n }\n else if (meta.useExisting !== undefined) {\n // useExisting is an `inject` call on the existing token.\n result = compileFactoryFunction({\n ...factoryMeta,\n expression: importExpr(Identifiers.inject).callFn([meta.useExisting.expression]),\n });\n }\n else {\n result = {\n statements: [],\n expression: delegateToFactory(meta.type.value, meta.internalType, resolveForwardRefs)\n };\n }\n const token = meta.internalType;\n const injectableProps = new DefinitionMap();\n injectableProps.set('token', token);\n injectableProps.set('factory', result.expression);\n // Only generate providedIn property if it has a non-null value\n if (meta.providedIn.expression.value !== null) {\n injectableProps.set('providedIn', convertFromMaybeForwardRefExpression(meta.providedIn));\n }\n const expression = importExpr(Identifiers.ɵɵdefineInjectable)\n .callFn([injectableProps.toLiteralMap()], undefined, true);\n return {\n expression,\n type: createInjectableType(meta),\n statements: result.statements,\n };\n}\nfunction createInjectableType(meta) {\n return new ExpressionType(importExpr(Identifiers.InjectableDeclaration, [typeWithParameters(meta.type.type, meta.typeArgumentCount)]));\n}\nfunction delegateToFactory(type, internalType, unwrapForwardRefs) {\n if (type.node === internalType.node) {\n // The types are the same, so we can simply delegate directly to the type's factory.\n // ```\n // factory: type.ɵfac\n // ```\n return internalType.prop('ɵfac');\n }\n if (!unwrapForwardRefs) {\n // The type is not wrapped in a `forwardRef()`, so we create a simple factory function that\n // accepts a sub-type as an argument.\n // ```\n // factory: function(t) { return internalType.ɵfac(t); }\n // ```\n return createFactoryFunction(internalType);\n }\n // The internalType is actually wrapped in a `forwardRef()` so we need to resolve that before\n // calling its factory.\n // ```\n // factory: function(t) { return core.resolveForwardRef(type).ɵfac(t); }\n // ```\n const unwrappedType = importExpr(Identifiers.resolveForwardRef).callFn([internalType]);\n return createFactoryFunction(unwrappedType);\n}\nfunction createFactoryFunction(type) {\n return fn([new FnParam('t', DYNAMIC_TYPE)], [new ReturnStatement(type.prop('ɵfac').callFn([variable('t')]))]);\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst UNUSABLE_INTERPOLATION_REGEXPS = [\n /^\\s*$/,\n /[<>]/,\n /^[{}]$/,\n /&(#|[a-z])/i,\n /^\\/\\//, // comment\n];\nfunction assertInterpolationSymbols(identifier, value) {\n if (value != null && !(Array.isArray(value) && value.length == 2)) {\n throw new Error(`Expected '${identifier}' to be an array, [start, end].`);\n }\n else if (value != null) {\n const start = value[0];\n const end = value[1];\n // Check for unusable interpolation symbols\n UNUSABLE_INTERPOLATION_REGEXPS.forEach(regexp => {\n if (regexp.test(start) || regexp.test(end)) {\n throw new Error(`['${start}', '${end}'] contains unusable interpolation symbol.`);\n }\n });\n }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass InterpolationConfig {\n constructor(start, end) {\n this.start = start;\n this.end = end;\n }\n static fromArray(markers) {\n if (!markers) {\n return DEFAULT_INTERPOLATION_CONFIG;\n }\n assertInterpolationSymbols('interpolation', markers);\n return new InterpolationConfig(markers[0], markers[1]);\n }\n}\nconst DEFAULT_INTERPOLATION_CONFIG = new InterpolationConfig('{{', '}}');\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst $EOF = 0;\nconst $BSPACE = 8;\nconst $TAB = 9;\nconst $LF = 10;\nconst $VTAB = 11;\nconst $FF = 12;\nconst $CR = 13;\nconst $SPACE = 32;\nconst $BANG = 33;\nconst $DQ = 34;\nconst $HASH = 35;\nconst $$ = 36;\nconst $PERCENT = 37;\nconst $AMPERSAND = 38;\nconst $SQ = 39;\nconst $LPAREN = 40;\nconst $RPAREN = 41;\nconst $STAR = 42;\nconst $PLUS = 43;\nconst $COMMA = 44;\nconst $MINUS = 45;\nconst $PERIOD = 46;\nconst $SLASH = 47;\nconst $COLON = 58;\nconst $SEMICOLON = 59;\nconst $LT = 60;\nconst $EQ = 61;\nconst $GT = 62;\nconst $QUESTION = 63;\nconst $0 = 48;\nconst $7 = 55;\nconst $9 = 57;\nconst $A = 65;\nconst $E = 69;\nconst $F = 70;\nconst $X = 88;\nconst $Z = 90;\nconst $LBRACKET = 91;\nconst $BACKSLASH = 92;\nconst $RBRACKET = 93;\nconst $CARET = 94;\nconst $_ = 95;\nconst $a = 97;\nconst $b = 98;\nconst $e = 101;\nconst $f = 102;\nconst $n = 110;\nconst $r = 114;\nconst $t = 116;\nconst $u = 117;\nconst $v = 118;\nconst $x = 120;\nconst $z = 122;\nconst $LBRACE = 123;\nconst $BAR = 124;\nconst $RBRACE = 125;\nconst $NBSP = 160;\nconst $PIPE = 124;\nconst $TILDA = 126;\nconst $AT = 64;\nconst $BT = 96;\nfunction isWhitespace(code) {\n return (code >= $TAB && code <= $SPACE) || (code == $NBSP);\n}\nfunction isDigit(code) {\n return $0 <= code && code <= $9;\n}\nfunction isAsciiLetter(code) {\n return code >= $a && code <= $z || code >= $A && code <= $Z;\n}\nfunction isAsciiHexDigit(code) {\n return code >= $a && code <= $f || code >= $A && code <= $F || isDigit(code);\n}\nfunction isNewLine(code) {\n return code === $LF || code === $CR;\n}\nfunction isOctalDigit(code) {\n return $0 <= code && code <= $7;\n}\nfunction isQuote(code) {\n return code === $SQ || code === $DQ || code === $BT;\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass ParseLocation {\n constructor(file, offset, line, col) {\n this.file = file;\n this.offset = offset;\n this.line = line;\n this.col = col;\n }\n toString() {\n return this.offset != null ? `${this.file.url}@${this.line}:${this.col}` : this.file.url;\n }\n moveBy(delta) {\n const source = this.file.content;\n const len = source.length;\n let offset = this.offset;\n let line = this.line;\n let col = this.col;\n while (offset > 0 && delta < 0) {\n offset--;\n delta++;\n const ch = source.charCodeAt(offset);\n if (ch == $LF) {\n line--;\n const priorLine = source.substr(0, offset - 1).lastIndexOf(String.fromCharCode($LF));\n col = priorLine > 0 ? offset - priorLine : offset;\n }\n else {\n col--;\n }\n }\n while (offset < len && delta > 0) {\n const ch = source.charCodeAt(offset);\n offset++;\n delta--;\n if (ch == $LF) {\n line++;\n col = 0;\n }\n else {\n col++;\n }\n }\n return new ParseLocation(this.file, offset, line, col);\n }\n // Return the source around the location\n // Up to `maxChars` or `maxLines` on each side of the location\n getContext(maxChars, maxLines) {\n const content = this.file.content;\n let startOffset = this.offset;\n if (startOffset != null) {\n if (startOffset > content.length - 1) {\n startOffset = content.length - 1;\n }\n let endOffset = startOffset;\n let ctxChars = 0;\n let ctxLines = 0;\n while (ctxChars < maxChars && startOffset > 0) {\n startOffset--;\n ctxChars++;\n if (content[startOffset] == '\\n') {\n if (++ctxLines == maxLines) {\n break;\n }\n }\n }\n ctxChars = 0;\n ctxLines = 0;\n while (ctxChars < maxChars && endOffset < content.length - 1) {\n endOffset++;\n ctxChars++;\n if (content[endOffset] == '\\n') {\n if (++ctxLines == maxLines) {\n break;\n }\n }\n }\n return {\n before: content.substring(startOffset, this.offset),\n after: content.substring(this.offset, endOffset + 1),\n };\n }\n return null;\n }\n}\nclass ParseSourceFile {\n constructor(content, url) {\n this.content = content;\n this.url = url;\n }\n}\nclass ParseSourceSpan {\n /**\n * Create an object that holds information about spans of tokens/nodes captured during\n * lexing/parsing of text.\n *\n * @param start\n * The location of the start of the span (having skipped leading trivia).\n * Skipping leading trivia makes source-spans more \"user friendly\", since things like HTML\n * elements will appear to begin at the start of the opening tag, rather than at the start of any\n * leading trivia, which could include newlines.\n *\n * @param end\n * The location of the end of the span.\n *\n * @param fullStart\n * The start of the token without skipping the leading trivia.\n * This is used by tooling that splits tokens further, such as extracting Angular interpolations\n * from text tokens. Such tooling creates new source-spans relative to the original token's\n * source-span. If leading trivia characters have been skipped then the new source-spans may be\n * incorrectly offset.\n *\n * @param details\n * Additional information (such as identifier names) that should be associated with the span.\n */\n constructor(start, end, fullStart = start, details = null) {\n this.start = start;\n this.end = end;\n this.fullStart = fullStart;\n this.details = details;\n }\n toString() {\n return this.start.file.content.substring(this.start.offset, this.end.offset);\n }\n}\nvar ParseErrorLevel;\n(function (ParseErrorLevel) {\n ParseErrorLevel[ParseErrorLevel[\"WARNING\"] = 0] = \"WARNING\";\n ParseErrorLevel[ParseErrorLevel[\"ERROR\"] = 1] = \"ERROR\";\n})(ParseErrorLevel || (ParseErrorLevel = {}));\nclass ParseError {\n constructor(span, msg, level = ParseErrorLevel.ERROR) {\n this.span = span;\n this.msg = msg;\n this.level = level;\n }\n contextualMessage() {\n const ctx = this.span.start.getContext(100, 3);\n return ctx ? `${this.msg} (\"${ctx.before}[${ParseErrorLevel[this.level]} ->]${ctx.after}\")` :\n this.msg;\n }\n toString() {\n const details = this.span.details ? `, ${this.span.details}` : '';\n return `${this.contextualMessage()}: ${this.span.start}${details}`;\n }\n}\n/**\n * Generates Source Span object for a given R3 Type for JIT mode.\n *\n * @param kind Component or Directive.\n * @param typeName name of the Component or Directive.\n * @param sourceUrl reference to Component or Directive source.\n * @returns instance of ParseSourceSpan that represent a given Component or Directive.\n */\nfunction r3JitTypeSourceSpan(kind, typeName, sourceUrl) {\n const sourceFileName = `in ${kind} ${typeName} in ${sourceUrl}`;\n const sourceFile = new ParseSourceFile('', sourceFileName);\n return new ParseSourceSpan(new ParseLocation(sourceFile, -1, -1, -1), new ParseLocation(sourceFile, -1, -1, -1));\n}\nlet _anonymousTypeIndex = 0;\nfunction identifierName(compileIdentifier) {\n if (!compileIdentifier || !compileIdentifier.reference) {\n return null;\n }\n const ref = compileIdentifier.reference;\n if (ref['__anonymousType']) {\n return ref['__anonymousType'];\n }\n if (ref['__forward_ref__']) {\n // We do not want to try to stringify a `forwardRef()` function because that would cause the\n // inner function to be evaluated too early, defeating the whole point of the `forwardRef`.\n return '__forward_ref__';\n }\n let identifier = stringify(ref);\n if (identifier.indexOf('(') >= 0) {\n // case: anonymous functions!\n identifier = `anonymous_${_anonymousTypeIndex++}`;\n ref['__anonymousType'] = identifier;\n }\n else {\n identifier = sanitizeIdentifier(identifier);\n }\n return identifier;\n}\nfunction sanitizeIdentifier(name) {\n return name.replace(/\\W/g, '_');\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * In TypeScript, tagged template functions expect a \"template object\", which is an array of\n * \"cooked\" strings plus a `raw` property that contains an array of \"raw\" strings. This is\n * typically constructed with a function called `__makeTemplateObject(cooked, raw)`, but it may not\n * be available in all environments.\n *\n * This is a JavaScript polyfill that uses __makeTemplateObject when it's available, but otherwise\n * creates an inline helper with the same functionality.\n *\n * In the inline function, if `Object.defineProperty` is available we use that to attach the `raw`\n * array.\n */\nconst makeTemplateObjectPolyfill = '(this&&this.__makeTemplateObject||function(e,t){return Object.defineProperty?Object.defineProperty(e,\"raw\",{value:t}):e.raw=t,e})';\nclass AbstractJsEmitterVisitor extends AbstractEmitterVisitor {\n constructor() {\n super(false);\n }\n visitWrappedNodeExpr(ast, ctx) {\n throw new Error('Cannot emit a WrappedNodeExpr in Javascript.');\n }\n visitDeclareVarStmt(stmt, ctx) {\n ctx.print(stmt, `var ${stmt.name}`);\n if (stmt.value) {\n ctx.print(stmt, ' = ');\n stmt.value.visitExpression(this, ctx);\n }\n ctx.println(stmt, `;`);\n return null;\n }\n visitTaggedTemplateExpr(ast, ctx) {\n // The following convoluted piece of code is effectively the downlevelled equivalent of\n // ```\n // tag`...`\n // ```\n // which is effectively like:\n // ```\n // tag(__makeTemplateObject(cooked, raw), expression1, expression2, ...);\n // ```\n const elements = ast.template.elements;\n ast.tag.visitExpression(this, ctx);\n ctx.print(ast, `(${makeTemplateObjectPolyfill}(`);\n ctx.print(ast, `[${elements.map(part => escapeIdentifier(part.text, false)).join(', ')}], `);\n ctx.print(ast, `[${elements.map(part => escapeIdentifier(part.rawText, false)).join(', ')}])`);\n ast.template.expressions.forEach(expression => {\n ctx.print(ast, ', ');\n expression.visitExpression(this, ctx);\n });\n ctx.print(ast, ')');\n return null;\n }\n visitFunctionExpr(ast, ctx) {\n ctx.print(ast, `function${ast.name ? ' ' + ast.name : ''}(`);\n this._visitParams(ast.params, ctx);\n ctx.println(ast, `) {`);\n ctx.incIndent();\n this.visitAllStatements(ast.statements, ctx);\n ctx.decIndent();\n ctx.print(ast, `}`);\n return null;\n }\n visitDeclareFunctionStmt(stmt, ctx) {\n ctx.print(stmt, `function ${stmt.name}(`);\n this._visitParams(stmt.params, ctx);\n ctx.println(stmt, `) {`);\n ctx.incIndent();\n this.visitAllStatements(stmt.statements, ctx);\n ctx.decIndent();\n ctx.println(stmt, `}`);\n return null;\n }\n visitLocalizedString(ast, ctx) {\n // The following convoluted piece of code is effectively the downlevelled equivalent of\n // ```\n // $localize `...`\n // ```\n // which is effectively like:\n // ```\n // $localize(__makeTemplateObject(cooked, raw), expression1, expression2, ...);\n // ```\n ctx.print(ast, `$localize(${makeTemplateObjectPolyfill}(`);\n const parts = [ast.serializeI18nHead()];\n for (let i = 1; i < ast.messageParts.length; i++) {\n parts.push(ast.serializeI18nTemplatePart(i));\n }\n ctx.print(ast, `[${parts.map(part => escapeIdentifier(part.cooked, false)).join(', ')}], `);\n ctx.print(ast, `[${parts.map(part => escapeIdentifier(part.raw, false)).join(', ')}])`);\n ast.expressions.forEach(expression => {\n ctx.print(ast, ', ');\n expression.visitExpression(this, ctx);\n });\n ctx.print(ast, ')');\n return null;\n }\n _visitParams(params, ctx) {\n this.visitAllObjects(param => ctx.print(null, param.name), params, ctx, ',');\n }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * The Trusted Types policy, or null if Trusted Types are not\n * enabled/supported, or undefined if the policy has not been created yet.\n */\nlet policy;\n/**\n * Returns the Trusted Types policy, or null if Trusted Types are not\n * enabled/supported. The first call to this function will create the policy.\n */\nfunction getPolicy() {\n if (policy === undefined) {\n policy = null;\n if (_global.trustedTypes) {\n try {\n policy =\n _global.trustedTypes.createPolicy('angular#unsafe-jit', {\n createScript: (s) => s,\n });\n }\n catch {\n // trustedTypes.createPolicy throws if called with a name that is\n // already registered, even in report-only mode. Until the API changes,\n // catch the error not to break the applications functionally. In such\n // cases, the code will fall back to using strings.\n }\n }\n }\n return policy;\n}\n/**\n * Unsafely promote a string to a TrustedScript, falling back to strings when\n * Trusted Types are not available.\n * @security In particular, it must be assured that the provided string will\n * never cause an XSS vulnerability if used in a context that will be\n * interpreted and executed as a script by a browser, e.g. when calling eval.\n */\nfunction trustedScriptFromString(script) {\n return getPolicy()?.createScript(script) || script;\n}\n/**\n * Unsafely call the Function constructor with the given string arguments.\n * @security This is a security-sensitive function; any use of this function\n * must go through security review. In particular, it must be assured that it\n * is only called from the JIT compiler, as use in other code can lead to XSS\n * vulnerabilities.\n */\nfunction newTrustedFunctionForJIT(...args) {\n if (!_global.trustedTypes) {\n // In environments that don't support Trusted Types, fall back to the most\n // straightforward implementation:\n return new Function(...args);\n }\n // Chrome currently does not support passing TrustedScript to the Function\n // constructor. The following implements the workaround proposed on the page\n // below, where the Chromium bug is also referenced:\n // https://github.com/w3c/webappsec-trusted-types/wiki/Trusted-Types-for-function-constructor\n const fnArgs = args.slice(0, -1).join(',');\n const fnBody = args[args.length - 1];\n const body = `(function anonymous(${fnArgs}\n) { ${fnBody}\n})`;\n // Using eval directly confuses the compiler and prevents this module from\n // being stripped out of JS binaries even if not used. The global['eval']\n // indirection fixes that.\n const fn = _global['eval'](trustedScriptFromString(body));\n if (fn.bind === undefined) {\n // Workaround for a browser bug that only exists in Chrome 83, where passing\n // a TrustedScript to eval just returns the TrustedScript back without\n // evaluating it. In that case, fall back to the most straightforward\n // implementation:\n return new Function(...args);\n }\n // To completely mimic the behavior of calling \"new Function\", two more\n // things need to happen:\n // 1. Stringifying the resulting function should return its source code\n fn.toString = () => body;\n // 2. When calling the resulting function, `this` should refer to `global`\n return fn.bind(_global);\n // When Trusted Types support in Function constructors is widely available,\n // the implementation of this function can be simplified to:\n // return new Function(...args.map(a => trustedScriptFromString(a)));\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A helper class to manage the evaluation of JIT generated code.\n */\nclass JitEvaluator {\n /**\n *\n * @param sourceUrl The URL of the generated code.\n * @param statements An array of Angular statement AST nodes to be evaluated.\n * @param refResolver Resolves `o.ExternalReference`s into values.\n * @param createSourceMaps If true then create a source-map for the generated code and include it\n * inline as a source-map comment.\n * @returns A map of all the variables in the generated code.\n */\n evaluateStatements(sourceUrl, statements, refResolver, createSourceMaps) {\n const converter = new JitEmitterVisitor(refResolver);\n const ctx = EmitterVisitorContext.createRoot();\n // Ensure generated code is in strict mode\n if (statements.length > 0 && !isUseStrictStatement(statements[0])) {\n statements = [\n literal('use strict').toStmt(),\n ...statements,\n ];\n }\n converter.visitAllStatements(statements, ctx);\n converter.createReturnStmt(ctx);\n return this.evaluateCode(sourceUrl, ctx, converter.getArgs(), createSourceMaps);\n }\n /**\n * Evaluate a piece of JIT generated code.\n * @param sourceUrl The URL of this generated code.\n * @param ctx A context object that contains an AST of the code to be evaluated.\n * @param vars A map containing the names and values of variables that the evaluated code might\n * reference.\n * @param createSourceMap If true then create a source-map for the generated code and include it\n * inline as a source-map comment.\n * @returns The result of evaluating the code.\n */\n evaluateCode(sourceUrl, ctx, vars, createSourceMap) {\n let fnBody = `\"use strict\";${ctx.toSource()}\\n//# sourceURL=${sourceUrl}`;\n const fnArgNames = [];\n const fnArgValues = [];\n for (const argName in vars) {\n fnArgValues.push(vars[argName]);\n fnArgNames.push(argName);\n }\n if (createSourceMap) {\n // using `new Function(...)` generates a header, 1 line of no arguments, 2 lines otherwise\n // E.g. ```\n // function anonymous(a,b,c\n // /**/) { ... }```\n // We don't want to hard code this fact, so we auto detect it via an empty function first.\n const emptyFn = newTrustedFunctionForJIT(...fnArgNames.concat('return null;')).toString();\n const headerLines = emptyFn.slice(0, emptyFn.indexOf('return null;')).split('\\n').length - 1;\n fnBody += `\\n${ctx.toSourceMapGenerator(sourceUrl, headerLines).toJsComment()}`;\n }\n const fn = newTrustedFunctionForJIT(...fnArgNames.concat(fnBody));\n return this.executeFunction(fn, fnArgValues);\n }\n /**\n * Execute a JIT generated function by calling it.\n *\n * This method can be overridden in tests to capture the functions that are generated\n * by this `JitEvaluator` class.\n *\n * @param fn A function to execute.\n * @param args The arguments to pass to the function being executed.\n * @returns The return value of the executed function.\n */\n executeFunction(fn, args) {\n return fn(...args);\n }\n}\n/**\n * An Angular AST visitor that converts AST nodes into executable JavaScript code.\n */\nclass JitEmitterVisitor extends AbstractJsEmitterVisitor {\n constructor(refResolver) {\n super();\n this.refResolver = refResolver;\n this._evalArgNames = [];\n this._evalArgValues = [];\n this._evalExportedVars = [];\n }\n createReturnStmt(ctx) {\n const stmt = new ReturnStatement(new LiteralMapExpr(this._evalExportedVars.map(resultVar => new LiteralMapEntry(resultVar, variable(resultVar), false))));\n stmt.visitStatement(this, ctx);\n }\n getArgs() {\n const result = {};\n for (let i = 0; i < this._evalArgNames.length; i++) {\n result[this._evalArgNames[i]] = this._evalArgValues[i];\n }\n return result;\n }\n visitExternalExpr(ast, ctx) {\n this._emitReferenceToExternal(ast, this.refResolver.resolveExternalReference(ast.value), ctx);\n return null;\n }\n visitWrappedNodeExpr(ast, ctx) {\n this._emitReferenceToExternal(ast, ast.node, ctx);\n return null;\n }\n visitDeclareVarStmt(stmt, ctx) {\n if (stmt.hasModifier(StmtModifier.Exported)) {\n this._evalExportedVars.push(stmt.name);\n }\n return super.visitDeclareVarStmt(stmt, ctx);\n }\n visitDeclareFunctionStmt(stmt, ctx) {\n if (stmt.hasModifier(StmtModifier.Exported)) {\n this._evalExportedVars.push(stmt.name);\n }\n return super.visitDeclareFunctionStmt(stmt, ctx);\n }\n _emitReferenceToExternal(ast, value, ctx) {\n let id = this._evalArgValues.indexOf(value);\n if (id === -1) {\n id = this._evalArgValues.length;\n this._evalArgValues.push(value);\n const name = identifierName({ reference: value }) || 'val';\n this._evalArgNames.push(`jit_${name}_${id}`);\n }\n ctx.print(ast, this._evalArgNames[id]);\n }\n}\nfunction isUseStrictStatement(statement) {\n return statement.isEquivalent(literal('use strict').toStmt());\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction compileInjector(meta) {\n const definitionMap = new DefinitionMap();\n if (meta.providers !== null) {\n definitionMap.set('providers', meta.providers);\n }\n if (meta.imports.length > 0) {\n definitionMap.set('imports', literalArr(meta.imports));\n }\n const expression = importExpr(Identifiers.defineInjector).callFn([definitionMap.toLiteralMap()], undefined, true);\n const type = createInjectorType(meta);\n return { expression, type, statements: [] };\n}\nfunction createInjectorType(meta) {\n return new ExpressionType(importExpr(Identifiers.InjectorDeclaration, [new ExpressionType(meta.type.type)]));\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Implementation of `CompileReflector` which resolves references to @angular/core\n * symbols at runtime, according to a consumer-provided mapping.\n *\n * Only supports `resolveExternalReference`, all other methods throw.\n */\nclass R3JitReflector {\n constructor(context) {\n this.context = context;\n }\n resolveExternalReference(ref) {\n // This reflector only handles @angular/core imports.\n if (ref.moduleName !== '@angular/core') {\n throw new Error(`Cannot resolve external reference to ${ref.moduleName}, only references to @angular/core are supported.`);\n }\n if (!this.context.hasOwnProperty(ref.name)) {\n throw new Error(`No value provided for @angular/core symbol '${ref.name}'.`);\n }\n return this.context[ref.name];\n }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Construct an `R3NgModuleDef` for the given `R3NgModuleMetadata`.\n */\nfunction compileNgModule(meta) {\n const { internalType, bootstrap, declarations, imports, exports, schemas, containsForwardDecls, emitInline, id } = meta;\n const statements = [];\n const definitionMap = new DefinitionMap();\n definitionMap.set('type', internalType);\n if (bootstrap.length > 0) {\n definitionMap.set('bootstrap', refsToArray(bootstrap, containsForwardDecls));\n }\n // If requested to emit scope information inline, pass the `declarations`, `imports` and `exports`\n // to the `ɵɵdefineNgModule()` call. The JIT compilation uses this.\n if (emitInline) {\n if (declarations.length > 0) {\n definitionMap.set('declarations', refsToArray(declarations, containsForwardDecls));\n }\n if (imports.length > 0) {\n definitionMap.set('imports', refsToArray(imports, containsForwardDecls));\n }\n if (exports.length > 0) {\n definitionMap.set('exports', refsToArray(exports, containsForwardDecls));\n }\n }\n // If not emitting inline, the scope information is not passed into `ɵɵdefineNgModule` as it would\n // prevent tree-shaking of the declarations, imports and exports references.\n else {\n const setNgModuleScopeCall = generateSetNgModuleScopeCall(meta);\n if (setNgModuleScopeCall !== null) {\n statements.push(setNgModuleScopeCall);\n }\n }\n if (schemas !== null && schemas.length > 0) {\n definitionMap.set('schemas', literalArr(schemas.map(ref => ref.value)));\n }\n if (id !== null) {\n definitionMap.set('id', id);\n }\n const expression = importExpr(Identifiers.defineNgModule).callFn([definitionMap.toLiteralMap()], undefined, true);\n const type = createNgModuleType(meta);\n return { expression, type, statements };\n}\n/**\n * This function is used in JIT mode to generate the call to `ɵɵdefineNgModule()` from a call to\n * `ɵɵngDeclareNgModule()`.\n */\nfunction compileNgModuleDeclarationExpression(meta) {\n const definitionMap = new DefinitionMap();\n definitionMap.set('type', new WrappedNodeExpr(meta.type));\n if (meta.bootstrap !== undefined) {\n definitionMap.set('bootstrap', new WrappedNodeExpr(meta.bootstrap));\n }\n if (meta.declarations !== undefined) {\n definitionMap.set('declarations', new WrappedNodeExpr(meta.declarations));\n }\n if (meta.imports !== undefined) {\n definitionMap.set('imports', new WrappedNodeExpr(meta.imports));\n }\n if (meta.exports !== undefined) {\n definitionMap.set('exports', new WrappedNodeExpr(meta.exports));\n }\n if (meta.schemas !== undefined) {\n definitionMap.set('schemas', new WrappedNodeExpr(meta.schemas));\n }\n if (meta.id !== undefined) {\n definitionMap.set('id', new WrappedNodeExpr(meta.id));\n }\n return importExpr(Identifiers.defineNgModule).callFn([definitionMap.toLiteralMap()]);\n}\nfunction createNgModuleType({ type: moduleType, declarations, imports, exports }) {\n return new ExpressionType(importExpr(Identifiers.NgModuleDeclaration, [\n new ExpressionType(moduleType.type), tupleTypeOf(declarations), tupleTypeOf(imports),\n tupleTypeOf(exports)\n ]));\n}\n/**\n * Generates a function call to `ɵɵsetNgModuleScope` with all necessary information so that the\n * transitive module scope can be computed during runtime in JIT mode. This call is marked pure\n * such that the references to declarations, imports and exports may be elided causing these\n * symbols to become tree-shakeable.\n */\nfunction generateSetNgModuleScopeCall(meta) {\n const { adjacentType: moduleType, declarations, imports, exports, containsForwardDecls } = meta;\n const scopeMap = new DefinitionMap();\n if (declarations.length > 0) {\n scopeMap.set('declarations', refsToArray(declarations, containsForwardDecls));\n }\n if (imports.length > 0) {\n scopeMap.set('imports', refsToArray(imports, containsForwardDecls));\n }\n if (exports.length > 0) {\n scopeMap.set('exports', refsToArray(exports, containsForwardDecls));\n }\n if (Object.keys(scopeMap.values).length === 0) {\n return null;\n }\n // setNgModuleScope(...)\n const fnCall = new InvokeFunctionExpr(\n /* fn */ importExpr(Identifiers.setNgModuleScope), \n /* args */ [moduleType, scopeMap.toLiteralMap()]);\n // (ngJitMode guard) && setNgModuleScope(...)\n const guardedCall = jitOnlyGuardedExpression(fnCall);\n // function() { (ngJitMode guard) && setNgModuleScope(...); }\n const iife = new FunctionExpr(\n /* params */ [], \n /* statements */ [guardedCall.toStmt()]);\n // (function() { (ngJitMode guard) && setNgModuleScope(...); })()\n const iifeCall = new InvokeFunctionExpr(\n /* fn */ iife, \n /* args */ []);\n return iifeCall.toStmt();\n}\nfunction tupleTypeOf(exp) {\n const types = exp.map(ref => typeofExpr(ref.type));\n return exp.length > 0 ? expressionType(literalArr(types)) : NONE_TYPE;\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction compilePipeFromMetadata(metadata) {\n const definitionMapValues = [];\n // e.g. `name: 'myPipe'`\n definitionMapValues.push({ key: 'name', value: literal(metadata.pipeName), quoted: false });\n // e.g. `type: MyPipe`\n definitionMapValues.push({ key: 'type', value: metadata.type.value, quoted: false });\n // e.g. `pure: true`\n definitionMapValues.push({ key: 'pure', value: literal(metadata.pure), quoted: false });\n const expression = importExpr(Identifiers.definePipe).callFn([literalMap(definitionMapValues)], undefined, true);\n const type = createPipeType(metadata);\n return { expression, type, statements: [] };\n}\nfunction createPipeType(metadata) {\n return new ExpressionType(importExpr(Identifiers.PipeDeclaration, [\n typeWithParameters(metadata.type.type, metadata.typeArgumentCount),\n new ExpressionType(new LiteralExpr(metadata.pipeName)),\n ]));\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass ParserError {\n constructor(message, input, errLocation, ctxLocation) {\n this.input = input;\n this.errLocation = errLocation;\n this.ctxLocation = ctxLocation;\n this.message = `Parser Error: ${message} ${errLocation} [${input}] in ${ctxLocation}`;\n }\n}\nclass ParseSpan {\n constructor(start, end) {\n this.start = start;\n this.end = end;\n }\n toAbsolute(absoluteOffset) {\n return new AbsoluteSourceSpan(absoluteOffset + this.start, absoluteOffset + this.end);\n }\n}\nclass AST {\n constructor(span, \n /**\n * Absolute location of the expression AST in a source code file.\n */\n sourceSpan) {\n this.span = span;\n this.sourceSpan = sourceSpan;\n }\n toString() {\n return 'AST';\n }\n}\nclass ASTWithName extends AST {\n constructor(span, sourceSpan, nameSpan) {\n super(span, sourceSpan);\n this.nameSpan = nameSpan;\n }\n}\n/**\n * Represents a quoted expression of the form:\n *\n * quote = prefix `:` uninterpretedExpression\n * prefix = identifier\n * uninterpretedExpression = arbitrary string\n *\n * A quoted expression is meant to be pre-processed by an AST transformer that\n * converts it into another AST that no longer contains quoted expressions.\n * It is meant to allow third-party developers to extend Angular template\n * expression language. The `uninterpretedExpression` part of the quote is\n * therefore not interpreted by the Angular's own expression parser.\n */\nclass Quote extends AST {\n constructor(span, sourceSpan, prefix, uninterpretedExpression, location) {\n super(span, sourceSpan);\n this.prefix = prefix;\n this.uninterpretedExpression = uninterpretedExpression;\n this.location = location;\n }\n visit(visitor, context = null) {\n return visitor.visitQuote(this, context);\n }\n toString() {\n return 'Quote';\n }\n}\nclass EmptyExpr extends AST {\n visit(visitor, context = null) {\n // do nothing\n }\n}\nclass ImplicitReceiver extends AST {\n visit(visitor, context = null) {\n return visitor.visitImplicitReceiver(this, context);\n }\n}\n/**\n * Receiver when something is accessed through `this` (e.g. `this.foo`). Note that this class\n * inherits from `ImplicitReceiver`, because accessing something through `this` is treated the\n * same as accessing it implicitly inside of an Angular template (e.g. `[attr.title]=\"this.title\"`\n * is the same as `[attr.title]=\"title\"`.). Inheriting allows for the `this` accesses to be treated\n * the same as implicit ones, except for a couple of exceptions like `$event` and `$any`.\n * TODO: we should find a way for this class not to extend from `ImplicitReceiver` in the future.\n */\nclass ThisReceiver extends ImplicitReceiver {\n visit(visitor, context = null) {\n return visitor.visitThisReceiver?.(this, context);\n }\n}\n/**\n * Multiple expressions separated by a semicolon.\n */\nclass Chain extends AST {\n constructor(span, sourceSpan, expressions) {\n super(span, sourceSpan);\n this.expressions = expressions;\n }\n visit(visitor, context = null) {\n return visitor.visitChain(this, context);\n }\n}\nclass Conditional extends AST {\n constructor(span, sourceSpan, condition, trueExp, falseExp) {\n super(span, sourceSpan);\n this.condition = condition;\n this.trueExp = trueExp;\n this.falseExp = falseExp;\n }\n visit(visitor, context = null) {\n return visitor.visitConditional(this, context);\n }\n}\nclass PropertyRead extends ASTWithName {\n constructor(span, sourceSpan, nameSpan, receiver, name) {\n super(span, sourceSpan, nameSpan);\n this.receiver = receiver;\n this.name = name;\n }\n visit(visitor, context = null) {\n return visitor.visitPropertyRead(this, context);\n }\n}\nclass PropertyWrite extends ASTWithName {\n constructor(span, sourceSpan, nameSpan, receiver, name, value) {\n super(span, sourceSpan, nameSpan);\n this.receiver = receiver;\n this.name = name;\n this.value = value;\n }\n visit(visitor, context = null) {\n return visitor.visitPropertyWrite(this, context);\n }\n}\nclass SafePropertyRead extends ASTWithName {\n constructor(span, sourceSpan, nameSpan, receiver, name) {\n super(span, sourceSpan, nameSpan);\n this.receiver = receiver;\n this.name = name;\n }\n visit(visitor, context = null) {\n return visitor.visitSafePropertyRead(this, context);\n }\n}\nclass KeyedRead extends AST {\n constructor(span, sourceSpan, receiver, key) {\n super(span, sourceSpan);\n this.receiver = receiver;\n this.key = key;\n }\n visit(visitor, context = null) {\n return visitor.visitKeyedRead(this, context);\n }\n}\nclass SafeKeyedRead extends AST {\n constructor(span, sourceSpan, receiver, key) {\n super(span, sourceSpan);\n this.receiver = receiver;\n this.key = key;\n }\n visit(visitor, context = null) {\n return visitor.visitSafeKeyedRead(this, context);\n }\n}\nclass KeyedWrite extends AST {\n constructor(span, sourceSpan, receiver, key, value) {\n super(span, sourceSpan);\n this.receiver = receiver;\n this.key = key;\n this.value = value;\n }\n visit(visitor, context = null) {\n return visitor.visitKeyedWrite(this, context);\n }\n}\nclass BindingPipe extends ASTWithName {\n constructor(span, sourceSpan, exp, name, args, nameSpan) {\n super(span, sourceSpan, nameSpan);\n this.exp = exp;\n this.name = name;\n this.args = args;\n }\n visit(visitor, context = null) {\n return visitor.visitPipe(this, context);\n }\n}\nclass LiteralPrimitive extends AST {\n constructor(span, sourceSpan, value) {\n super(span, sourceSpan);\n this.value = value;\n }\n visit(visitor, context = null) {\n return visitor.visitLiteralPrimitive(this, context);\n }\n}\nclass LiteralArray extends AST {\n constructor(span, sourceSpan, expressions) {\n super(span, sourceSpan);\n this.expressions = expressions;\n }\n visit(visitor, context = null) {\n return visitor.visitLiteralArray(this, context);\n }\n}\nclass LiteralMap extends AST {\n constructor(span, sourceSpan, keys, values) {\n super(span, sourceSpan);\n this.keys = keys;\n this.values = values;\n }\n visit(visitor, context = null) {\n return visitor.visitLiteralMap(this, context);\n }\n}\nclass Interpolation extends AST {\n constructor(span, sourceSpan, strings, expressions) {\n super(span, sourceSpan);\n this.strings = strings;\n this.expressions = expressions;\n }\n visit(visitor, context = null) {\n return visitor.visitInterpolation(this, context);\n }\n}\nclass Binary extends AST {\n constructor(span, sourceSpan, operation, left, right) {\n super(span, sourceSpan);\n this.operation = operation;\n this.left = left;\n this.right = right;\n }\n visit(visitor, context = null) {\n return visitor.visitBinary(this, context);\n }\n}\n/**\n * For backwards compatibility reasons, `Unary` inherits from `Binary` and mimics the binary AST\n * node that was originally used. This inheritance relation can be deleted in some future major,\n * after consumers have been given a chance to fully support Unary.\n */\nclass Unary extends Binary {\n /**\n * During the deprecation period this constructor is private, to avoid consumers from creating\n * a `Unary` with the fallback properties for `Binary`.\n */\n constructor(span, sourceSpan, operator, expr, binaryOp, binaryLeft, binaryRight) {\n super(span, sourceSpan, binaryOp, binaryLeft, binaryRight);\n this.operator = operator;\n this.expr = expr;\n // Redeclare the properties that are inherited from `Binary` as `never`, as consumers should not\n // depend on these fields when operating on `Unary`.\n this.left = null;\n this.right = null;\n this.operation = null;\n }\n /**\n * Creates a unary minus expression \"-x\", represented as `Binary` using \"0 - x\".\n */\n static createMinus(span, sourceSpan, expr) {\n return new Unary(span, sourceSpan, '-', expr, '-', new LiteralPrimitive(span, sourceSpan, 0), expr);\n }\n /**\n * Creates a unary plus expression \"+x\", represented as `Binary` using \"x - 0\".\n */\n static createPlus(span, sourceSpan, expr) {\n return new Unary(span, sourceSpan, '+', expr, '-', expr, new LiteralPrimitive(span, sourceSpan, 0));\n }\n visit(visitor, context = null) {\n if (visitor.visitUnary !== undefined) {\n return visitor.visitUnary(this, context);\n }\n return visitor.visitBinary(this, context);\n }\n}\nclass PrefixNot extends AST {\n constructor(span, sourceSpan, expression) {\n super(span, sourceSpan);\n this.expression = expression;\n }\n visit(visitor, context = null) {\n return visitor.visitPrefixNot(this, context);\n }\n}\nclass NonNullAssert extends AST {\n constructor(span, sourceSpan, expression) {\n super(span, sourceSpan);\n this.expression = expression;\n }\n visit(visitor, context = null) {\n return visitor.visitNonNullAssert(this, context);\n }\n}\nclass Call extends AST {\n constructor(span, sourceSpan, receiver, args, argumentSpan) {\n super(span, sourceSpan);\n this.receiver = receiver;\n this.args = args;\n this.argumentSpan = argumentSpan;\n }\n visit(visitor, context = null) {\n return visitor.visitCall(this, context);\n }\n}\nclass SafeCall extends AST {\n constructor(span, sourceSpan, receiver, args, argumentSpan) {\n super(span, sourceSpan);\n this.receiver = receiver;\n this.args = args;\n this.argumentSpan = argumentSpan;\n }\n visit(visitor, context = null) {\n return visitor.visitSafeCall(this, context);\n }\n}\n/**\n * Records the absolute position of a text span in a source file, where `start` and `end` are the\n * starting and ending byte offsets, respectively, of the text span in a source file.\n */\nclass AbsoluteSourceSpan {\n constructor(start, end) {\n this.start = start;\n this.end = end;\n }\n}\nclass ASTWithSource extends AST {\n constructor(ast, source, location, absoluteOffset, errors) {\n super(new ParseSpan(0, source === null ? 0 : source.length), new AbsoluteSourceSpan(absoluteOffset, source === null ? absoluteOffset : absoluteOffset + source.length));\n this.ast = ast;\n this.source = source;\n this.location = location;\n this.errors = errors;\n }\n visit(visitor, context = null) {\n if (visitor.visitASTWithSource) {\n return visitor.visitASTWithSource(this, context);\n }\n return this.ast.visit(visitor, context);\n }\n toString() {\n return `${this.source} in ${this.location}`;\n }\n}\nclass VariableBinding {\n /**\n * @param sourceSpan entire span of the binding.\n * @param key name of the LHS along with its span.\n * @param value optional value for the RHS along with its span.\n */\n constructor(sourceSpan, key, value) {\n this.sourceSpan = sourceSpan;\n this.key = key;\n this.value = value;\n }\n}\nclass ExpressionBinding {\n /**\n * @param sourceSpan entire span of the binding.\n * @param key binding name, like ngForOf, ngForTrackBy, ngIf, along with its\n * span. Note that the length of the span may not be the same as\n * `key.source.length`. For example,\n * 1. key.source = ngFor, key.span is for \"ngFor\"\n * 2. key.source = ngForOf, key.span is for \"of\"\n * 3. key.source = ngForTrackBy, key.span is for \"trackBy\"\n * @param value optional expression for the RHS.\n */\n constructor(sourceSpan, key, value) {\n this.sourceSpan = sourceSpan;\n this.key = key;\n this.value = value;\n }\n}\nclass RecursiveAstVisitor {\n visit(ast, context) {\n // The default implementation just visits every node.\n // Classes that extend RecursiveAstVisitor should override this function\n // to selectively visit the specified node.\n ast.visit(this, context);\n }\n visitUnary(ast, context) {\n this.visit(ast.expr, context);\n }\n visitBinary(ast, context) {\n this.visit(ast.left, context);\n this.visit(ast.right, context);\n }\n visitChain(ast, context) {\n this.visitAll(ast.expressions, context);\n }\n visitConditional(ast, context) {\n this.visit(ast.condition, context);\n this.visit(ast.trueExp, context);\n this.visit(ast.falseExp, context);\n }\n visitPipe(ast, context) {\n this.visit(ast.exp, context);\n this.visitAll(ast.args, context);\n }\n visitImplicitReceiver(ast, context) { }\n visitThisReceiver(ast, context) { }\n visitInterpolation(ast, context) {\n this.visitAll(ast.expressions, context);\n }\n visitKeyedRead(ast, context) {\n this.visit(ast.receiver, context);\n this.visit(ast.key, context);\n }\n visitKeyedWrite(ast, context) {\n this.visit(ast.receiver, context);\n this.visit(ast.key, context);\n this.visit(ast.value, context);\n }\n visitLiteralArray(ast, context) {\n this.visitAll(ast.expressions, context);\n }\n visitLiteralMap(ast, context) {\n this.visitAll(ast.values, context);\n }\n visitLiteralPrimitive(ast, context) { }\n visitPrefixNot(ast, context) {\n this.visit(ast.expression, context);\n }\n visitNonNullAssert(ast, context) {\n this.visit(ast.expression, context);\n }\n visitPropertyRead(ast, context) {\n this.visit(ast.receiver, context);\n }\n visitPropertyWrite(ast, context) {\n this.visit(ast.receiver, context);\n this.visit(ast.value, context);\n }\n visitSafePropertyRead(ast, context) {\n this.visit(ast.receiver, context);\n }\n visitSafeKeyedRead(ast, context) {\n this.visit(ast.receiver, context);\n this.visit(ast.key, context);\n }\n visitCall(ast, context) {\n this.visit(ast.receiver, context);\n this.visitAll(ast.args, context);\n }\n visitSafeCall(ast, context) {\n this.visit(ast.receiver, context);\n this.visitAll(ast.args, context);\n }\n visitQuote(ast, context) { }\n // This is not part of the AstVisitor interface, just a helper method\n visitAll(asts, context) {\n for (const ast of asts) {\n this.visit(ast, context);\n }\n }\n}\nclass AstTransformer {\n visitImplicitReceiver(ast, context) {\n return ast;\n }\n visitThisReceiver(ast, context) {\n return ast;\n }\n visitInterpolation(ast, context) {\n return new Interpolation(ast.span, ast.sourceSpan, ast.strings, this.visitAll(ast.expressions));\n }\n visitLiteralPrimitive(ast, context) {\n return new LiteralPrimitive(ast.span, ast.sourceSpan, ast.value);\n }\n visitPropertyRead(ast, context) {\n return new PropertyRead(ast.span, ast.sourceSpan, ast.nameSpan, ast.receiver.visit(this), ast.name);\n }\n visitPropertyWrite(ast, context) {\n return new PropertyWrite(ast.span, ast.sourceSpan, ast.nameSpan, ast.receiver.visit(this), ast.name, ast.value.visit(this));\n }\n visitSafePropertyRead(ast, context) {\n return new SafePropertyRead(ast.span, ast.sourceSpan, ast.nameSpan, ast.receiver.visit(this), ast.name);\n }\n visitLiteralArray(ast, context) {\n return new LiteralArray(ast.span, ast.sourceSpan, this.visitAll(ast.expressions));\n }\n visitLiteralMap(ast, context) {\n return new LiteralMap(ast.span, ast.sourceSpan, ast.keys, this.visitAll(ast.values));\n }\n visitUnary(ast, context) {\n switch (ast.operator) {\n case '+':\n return Unary.createPlus(ast.span, ast.sourceSpan, ast.expr.visit(this));\n case '-':\n return Unary.createMinus(ast.span, ast.sourceSpan, ast.expr.visit(this));\n default:\n throw new Error(`Unknown unary operator ${ast.operator}`);\n }\n }\n visitBinary(ast, context) {\n return new Binary(ast.span, ast.sourceSpan, ast.operation, ast.left.visit(this), ast.right.visit(this));\n }\n visitPrefixNot(ast, context) {\n return new PrefixNot(ast.span, ast.sourceSpan, ast.expression.visit(this));\n }\n visitNonNullAssert(ast, context) {\n return new NonNullAssert(ast.span, ast.sourceSpan, ast.expression.visit(this));\n }\n visitConditional(ast, context) {\n return new Conditional(ast.span, ast.sourceSpan, ast.condition.visit(this), ast.trueExp.visit(this), ast.falseExp.visit(this));\n }\n visitPipe(ast, context) {\n return new BindingPipe(ast.span, ast.sourceSpan, ast.exp.visit(this), ast.name, this.visitAll(ast.args), ast.nameSpan);\n }\n visitKeyedRead(ast, context) {\n return new KeyedRead(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.key.visit(this));\n }\n visitKeyedWrite(ast, context) {\n return new KeyedWrite(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.key.visit(this), ast.value.visit(this));\n }\n visitCall(ast, context) {\n return new Call(ast.span, ast.sourceSpan, ast.receiver.visit(this), this.visitAll(ast.args), ast.argumentSpan);\n }\n visitSafeCall(ast, context) {\n return new SafeCall(ast.span, ast.sourceSpan, ast.receiver.visit(this), this.visitAll(ast.args), ast.argumentSpan);\n }\n visitAll(asts) {\n const res = [];\n for (let i = 0; i < asts.length; ++i) {\n res[i] = asts[i].visit(this);\n }\n return res;\n }\n visitChain(ast, context) {\n return new Chain(ast.span, ast.sourceSpan, this.visitAll(ast.expressions));\n }\n visitQuote(ast, context) {\n return new Quote(ast.span, ast.sourceSpan, ast.prefix, ast.uninterpretedExpression, ast.location);\n }\n visitSafeKeyedRead(ast, context) {\n return new SafeKeyedRead(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.key.visit(this));\n }\n}\n// A transformer that only creates new nodes if the transformer makes a change or\n// a change is made a child node.\nclass AstMemoryEfficientTransformer {\n visitImplicitReceiver(ast, context) {\n return ast;\n }\n visitThisReceiver(ast, context) {\n return ast;\n }\n visitInterpolation(ast, context) {\n const expressions = this.visitAll(ast.expressions);\n if (expressions !== ast.expressions)\n return new Interpolation(ast.span, ast.sourceSpan, ast.strings, expressions);\n return ast;\n }\n visitLiteralPrimitive(ast, context) {\n return ast;\n }\n visitPropertyRead(ast, context) {\n const receiver = ast.receiver.visit(this);\n if (receiver !== ast.receiver) {\n return new PropertyRead(ast.span, ast.sourceSpan, ast.nameSpan, receiver, ast.name);\n }\n return ast;\n }\n visitPropertyWrite(ast, context) {\n const receiver = ast.receiver.visit(this);\n const value = ast.value.visit(this);\n if (receiver !== ast.receiver || value !== ast.value) {\n return new PropertyWrite(ast.span, ast.sourceSpan, ast.nameSpan, receiver, ast.name, value);\n }\n return ast;\n }\n visitSafePropertyRead(ast, context) {\n const receiver = ast.receiver.visit(this);\n if (receiver !== ast.receiver) {\n return new SafePropertyRead(ast.span, ast.sourceSpan, ast.nameSpan, receiver, ast.name);\n }\n return ast;\n }\n visitLiteralArray(ast, context) {\n const expressions = this.visitAll(ast.expressions);\n if (expressions !== ast.expressions) {\n return new LiteralArray(ast.span, ast.sourceSpan, expressions);\n }\n return ast;\n }\n visitLiteralMap(ast, context) {\n const values = this.visitAll(ast.values);\n if (values !== ast.values) {\n return new LiteralMap(ast.span, ast.sourceSpan, ast.keys, values);\n }\n return ast;\n }\n visitUnary(ast, context) {\n const expr = ast.expr.visit(this);\n if (expr !== ast.expr) {\n switch (ast.operator) {\n case '+':\n return Unary.createPlus(ast.span, ast.sourceSpan, expr);\n case '-':\n return Unary.createMinus(ast.span, ast.sourceSpan, expr);\n default:\n throw new Error(`Unknown unary operator ${ast.operator}`);\n }\n }\n return ast;\n }\n visitBinary(ast, context) {\n const left = ast.left.visit(this);\n const right = ast.right.visit(this);\n if (left !== ast.left || right !== ast.right) {\n return new Binary(ast.span, ast.sourceSpan, ast.operation, left, right);\n }\n return ast;\n }\n visitPrefixNot(ast, context) {\n const expression = ast.expression.visit(this);\n if (expression !== ast.expression) {\n return new PrefixNot(ast.span, ast.sourceSpan, expression);\n }\n return ast;\n }\n visitNonNullAssert(ast, context) {\n const expression = ast.expression.visit(this);\n if (expression !== ast.expression) {\n return new NonNullAssert(ast.span, ast.sourceSpan, expression);\n }\n return ast;\n }\n visitConditional(ast, context) {\n const condition = ast.condition.visit(this);\n const trueExp = ast.trueExp.visit(this);\n const falseExp = ast.falseExp.visit(this);\n if (condition !== ast.condition || trueExp !== ast.trueExp || falseExp !== ast.falseExp) {\n return new Conditional(ast.span, ast.sourceSpan, condition, trueExp, falseExp);\n }\n return ast;\n }\n visitPipe(ast, context) {\n const exp = ast.exp.visit(this);\n const args = this.visitAll(ast.args);\n if (exp !== ast.exp || args !== ast.args) {\n return new BindingPipe(ast.span, ast.sourceSpan, exp, ast.name, args, ast.nameSpan);\n }\n return ast;\n }\n visitKeyedRead(ast, context) {\n const obj = ast.receiver.visit(this);\n const key = ast.key.visit(this);\n if (obj !== ast.receiver || key !== ast.key) {\n return new KeyedRead(ast.span, ast.sourceSpan, obj, key);\n }\n return ast;\n }\n visitKeyedWrite(ast, context) {\n const obj = ast.receiver.visit(this);\n const key = ast.key.visit(this);\n const value = ast.value.visit(this);\n if (obj !== ast.receiver || key !== ast.key || value !== ast.value) {\n return new KeyedWrite(ast.span, ast.sourceSpan, obj, key, value);\n }\n return ast;\n }\n visitAll(asts) {\n const res = [];\n let modified = false;\n for (let i = 0; i < asts.length; ++i) {\n const original = asts[i];\n const value = original.visit(this);\n res[i] = value;\n modified = modified || value !== original;\n }\n return modified ? res : asts;\n }\n visitChain(ast, context) {\n const expressions = this.visitAll(ast.expressions);\n if (expressions !== ast.expressions) {\n return new Chain(ast.span, ast.sourceSpan, expressions);\n }\n return ast;\n }\n visitCall(ast, context) {\n const receiver = ast.receiver.visit(this);\n const args = this.visitAll(ast.args);\n if (receiver !== ast.receiver || args !== ast.args) {\n return new Call(ast.span, ast.sourceSpan, receiver, args, ast.argumentSpan);\n }\n return ast;\n }\n visitSafeCall(ast, context) {\n const receiver = ast.receiver.visit(this);\n const args = this.visitAll(ast.args);\n if (receiver !== ast.receiver || args !== ast.args) {\n return new SafeCall(ast.span, ast.sourceSpan, receiver, args, ast.argumentSpan);\n }\n return ast;\n }\n visitQuote(ast, context) {\n return ast;\n }\n visitSafeKeyedRead(ast, context) {\n const obj = ast.receiver.visit(this);\n const key = ast.key.visit(this);\n if (obj !== ast.receiver || key !== ast.key) {\n return new SafeKeyedRead(ast.span, ast.sourceSpan, obj, key);\n }\n return ast;\n }\n}\n// Bindings\nclass ParsedProperty {\n constructor(name, expression, type, sourceSpan, keySpan, valueSpan) {\n this.name = name;\n this.expression = expression;\n this.type = type;\n this.sourceSpan = sourceSpan;\n this.keySpan = keySpan;\n this.valueSpan = valueSpan;\n this.isLiteral = this.type === ParsedPropertyType.LITERAL_ATTR;\n this.isAnimation = this.type === ParsedPropertyType.ANIMATION;\n }\n}\nvar ParsedPropertyType;\n(function (ParsedPropertyType) {\n ParsedPropertyType[ParsedPropertyType[\"DEFAULT\"] = 0] = \"DEFAULT\";\n ParsedPropertyType[ParsedPropertyType[\"LITERAL_ATTR\"] = 1] = \"LITERAL_ATTR\";\n ParsedPropertyType[ParsedPropertyType[\"ANIMATION\"] = 2] = \"ANIMATION\";\n})(ParsedPropertyType || (ParsedPropertyType = {}));\nclass ParsedEvent {\n // Regular events have a target\n // Animation events have a phase\n constructor(name, targetOrPhase, type, handler, sourceSpan, handlerSpan, keySpan) {\n this.name = name;\n this.targetOrPhase = targetOrPhase;\n this.type = type;\n this.handler = handler;\n this.sourceSpan = sourceSpan;\n this.handlerSpan = handlerSpan;\n this.keySpan = keySpan;\n }\n}\n/**\n * ParsedVariable represents a variable declaration in a microsyntax expression.\n */\nclass ParsedVariable {\n constructor(name, value, sourceSpan, keySpan, valueSpan) {\n this.name = name;\n this.value = value;\n this.sourceSpan = sourceSpan;\n this.keySpan = keySpan;\n this.valueSpan = valueSpan;\n }\n}\nclass BoundElementProperty {\n constructor(name, type, securityContext, value, unit, sourceSpan, keySpan, valueSpan) {\n this.name = name;\n this.type = type;\n this.securityContext = securityContext;\n this.value = value;\n this.unit = unit;\n this.sourceSpan = sourceSpan;\n this.keySpan = keySpan;\n this.valueSpan = valueSpan;\n }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass EventHandlerVars {\n}\nEventHandlerVars.event = variable('$event');\n/**\n * Converts the given expression AST into an executable output AST, assuming the expression is\n * used in an action binding (e.g. an event handler).\n */\nfunction convertActionBinding(localResolver, implicitReceiver, action, bindingId, baseSourceSpan, implicitReceiverAccesses, globals) {\n if (!localResolver) {\n localResolver = new DefaultLocalResolver(globals);\n }\n const actionWithoutBuiltins = convertPropertyBindingBuiltins({\n createLiteralArrayConverter: (argCount) => {\n // Note: no caching for literal arrays in actions.\n return (args) => literalArr(args);\n },\n createLiteralMapConverter: (keys) => {\n // Note: no caching for literal maps in actions.\n return (values) => {\n const entries = keys.map((k, i) => ({\n key: k.key,\n value: values[i],\n quoted: k.quoted,\n }));\n return literalMap(entries);\n };\n },\n createPipeConverter: (name) => {\n throw new Error(`Illegal State: Actions are not allowed to contain pipes. Pipe: ${name}`);\n }\n }, action);\n const visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId, /* supportsInterpolation */ false, baseSourceSpan, implicitReceiverAccesses);\n const actionStmts = [];\n flattenStatements(actionWithoutBuiltins.visit(visitor, _Mode.Statement), actionStmts);\n prependTemporaryDecls(visitor.temporaryCount, bindingId, actionStmts);\n if (visitor.usesImplicitReceiver) {\n localResolver.notifyImplicitReceiverUse();\n }\n const lastIndex = actionStmts.length - 1;\n if (lastIndex >= 0) {\n const lastStatement = actionStmts[lastIndex];\n // Ensure that the value of the last expression statement is returned\n if (lastStatement instanceof ExpressionStatement) {\n actionStmts[lastIndex] = new ReturnStatement(lastStatement.expr);\n }\n }\n return actionStmts;\n}\nfunction convertPropertyBindingBuiltins(converterFactory, ast) {\n return convertBuiltins(converterFactory, ast);\n}\nclass ConvertPropertyBindingResult {\n constructor(stmts, currValExpr) {\n this.stmts = stmts;\n this.currValExpr = currValExpr;\n }\n}\n/**\n * Converts the given expression AST into an executable output AST, assuming the expression\n * is used in property binding. The expression has to be preprocessed via\n * `convertPropertyBindingBuiltins`.\n */\nfunction convertPropertyBinding(localResolver, implicitReceiver, expressionWithoutBuiltins, bindingId) {\n if (!localResolver) {\n localResolver = new DefaultLocalResolver();\n }\n const visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId, /* supportsInterpolation */ false);\n const outputExpr = expressionWithoutBuiltins.visit(visitor, _Mode.Expression);\n const stmts = getStatementsFromVisitor(visitor, bindingId);\n if (visitor.usesImplicitReceiver) {\n localResolver.notifyImplicitReceiverUse();\n }\n return new ConvertPropertyBindingResult(stmts, outputExpr);\n}\n/**\n * Given some expression, such as a binding or interpolation expression, and a context expression to\n * look values up on, visit each facet of the given expression resolving values from the context\n * expression such that a list of arguments can be derived from the found values that can be used as\n * arguments to an external update instruction.\n *\n * @param localResolver The resolver to use to look up expressions by name appropriately\n * @param contextVariableExpression The expression representing the context variable used to create\n * the final argument expressions\n * @param expressionWithArgumentsToExtract The expression to visit to figure out what values need to\n * be resolved and what arguments list to build.\n * @param bindingId A name prefix used to create temporary variable names if they're needed for the\n * arguments generated\n * @returns An array of expressions that can be passed as arguments to instruction expressions like\n * `o.importExpr(R3.propertyInterpolate).callFn(result)`\n */\nfunction convertUpdateArguments(localResolver, contextVariableExpression, expressionWithArgumentsToExtract, bindingId) {\n const visitor = new _AstToIrVisitor(localResolver, contextVariableExpression, bindingId, /* supportsInterpolation */ true);\n const outputExpr = visitor.visitInterpolation(expressionWithArgumentsToExtract, _Mode.Expression);\n if (visitor.usesImplicitReceiver) {\n localResolver.notifyImplicitReceiverUse();\n }\n const stmts = getStatementsFromVisitor(visitor, bindingId);\n const args = outputExpr.args;\n return { stmts, args };\n}\nfunction getStatementsFromVisitor(visitor, bindingId) {\n const stmts = [];\n for (let i = 0; i < visitor.temporaryCount; i++) {\n stmts.push(temporaryDeclaration(bindingId, i));\n }\n return stmts;\n}\nfunction convertBuiltins(converterFactory, ast) {\n const visitor = new _BuiltinAstConverter(converterFactory);\n return ast.visit(visitor);\n}\nfunction temporaryName(bindingId, temporaryNumber) {\n return `tmp_${bindingId}_${temporaryNumber}`;\n}\nfunction temporaryDeclaration(bindingId, temporaryNumber) {\n return new DeclareVarStmt(temporaryName(bindingId, temporaryNumber));\n}\nfunction prependTemporaryDecls(temporaryCount, bindingId, statements) {\n for (let i = temporaryCount - 1; i >= 0; i--) {\n statements.unshift(temporaryDeclaration(bindingId, i));\n }\n}\nvar _Mode;\n(function (_Mode) {\n _Mode[_Mode[\"Statement\"] = 0] = \"Statement\";\n _Mode[_Mode[\"Expression\"] = 1] = \"Expression\";\n})(_Mode || (_Mode = {}));\nfunction ensureStatementMode(mode, ast) {\n if (mode !== _Mode.Statement) {\n throw new Error(`Expected a statement, but saw ${ast}`);\n }\n}\nfunction ensureExpressionMode(mode, ast) {\n if (mode !== _Mode.Expression) {\n throw new Error(`Expected an expression, but saw ${ast}`);\n }\n}\nfunction convertToStatementIfNeeded(mode, expr) {\n if (mode === _Mode.Statement) {\n return expr.toStmt();\n }\n else {\n return expr;\n }\n}\nclass _BuiltinAstConverter extends AstTransformer {\n constructor(_converterFactory) {\n super();\n this._converterFactory = _converterFactory;\n }\n visitPipe(ast, context) {\n const args = [ast.exp, ...ast.args].map(ast => ast.visit(this, context));\n return new BuiltinFunctionCall(ast.span, ast.sourceSpan, args, this._converterFactory.createPipeConverter(ast.name, args.length));\n }\n visitLiteralArray(ast, context) {\n const args = ast.expressions.map(ast => ast.visit(this, context));\n return new BuiltinFunctionCall(ast.span, ast.sourceSpan, args, this._converterFactory.createLiteralArrayConverter(ast.expressions.length));\n }\n visitLiteralMap(ast, context) {\n const args = ast.values.map(ast => ast.visit(this, context));\n return new BuiltinFunctionCall(ast.span, ast.sourceSpan, args, this._converterFactory.createLiteralMapConverter(ast.keys));\n }\n}\nclass _AstToIrVisitor {\n constructor(_localResolver, _implicitReceiver, bindingId, supportsInterpolation, baseSourceSpan, implicitReceiverAccesses) {\n this._localResolver = _localResolver;\n this._implicitReceiver = _implicitReceiver;\n this.bindingId = bindingId;\n this.supportsInterpolation = supportsInterpolation;\n this.baseSourceSpan = baseSourceSpan;\n this.implicitReceiverAccesses = implicitReceiverAccesses;\n this._nodeMap = new Map();\n this._resultMap = new Map();\n this._currentTemporary = 0;\n this.temporaryCount = 0;\n this.usesImplicitReceiver = false;\n }\n visitUnary(ast, mode) {\n let op;\n switch (ast.operator) {\n case '+':\n op = UnaryOperator.Plus;\n break;\n case '-':\n op = UnaryOperator.Minus;\n break;\n default:\n throw new Error(`Unsupported operator ${ast.operator}`);\n }\n return convertToStatementIfNeeded(mode, new UnaryOperatorExpr(op, this._visit(ast.expr, _Mode.Expression), undefined, this.convertSourceSpan(ast.span)));\n }\n visitBinary(ast, mode) {\n let op;\n switch (ast.operation) {\n case '+':\n op = BinaryOperator.Plus;\n break;\n case '-':\n op = BinaryOperator.Minus;\n break;\n case '*':\n op = BinaryOperator.Multiply;\n break;\n case '/':\n op = BinaryOperator.Divide;\n break;\n case '%':\n op = BinaryOperator.Modulo;\n break;\n case '&&':\n op = BinaryOperator.And;\n break;\n case '||':\n op = BinaryOperator.Or;\n break;\n case '==':\n op = BinaryOperator.Equals;\n break;\n case '!=':\n op = BinaryOperator.NotEquals;\n break;\n case '===':\n op = BinaryOperator.Identical;\n break;\n case '!==':\n op = BinaryOperator.NotIdentical;\n break;\n case '<':\n op = BinaryOperator.Lower;\n break;\n case '>':\n op = BinaryOperator.Bigger;\n break;\n case '<=':\n op = BinaryOperator.LowerEquals;\n break;\n case '>=':\n op = BinaryOperator.BiggerEquals;\n break;\n case '??':\n return this.convertNullishCoalesce(ast, mode);\n default:\n throw new Error(`Unsupported operation ${ast.operation}`);\n }\n return convertToStatementIfNeeded(mode, new BinaryOperatorExpr(op, this._visit(ast.left, _Mode.Expression), this._visit(ast.right, _Mode.Expression), undefined, this.convertSourceSpan(ast.span)));\n }\n visitChain(ast, mode) {\n ensureStatementMode(mode, ast);\n return this.visitAll(ast.expressions, mode);\n }\n visitConditional(ast, mode) {\n const value = this._visit(ast.condition, _Mode.Expression);\n return convertToStatementIfNeeded(mode, value.conditional(this._visit(ast.trueExp, _Mode.Expression), this._visit(ast.falseExp, _Mode.Expression), this.convertSourceSpan(ast.span)));\n }\n visitPipe(ast, mode) {\n throw new Error(`Illegal state: Pipes should have been converted into functions. Pipe: ${ast.name}`);\n }\n visitImplicitReceiver(ast, mode) {\n ensureExpressionMode(mode, ast);\n this.usesImplicitReceiver = true;\n return this._implicitReceiver;\n }\n visitThisReceiver(ast, mode) {\n return this.visitImplicitReceiver(ast, mode);\n }\n visitInterpolation(ast, mode) {\n if (!this.supportsInterpolation) {\n throw new Error('Unexpected interpolation');\n }\n ensureExpressionMode(mode, ast);\n let args = [];\n for (let i = 0; i < ast.strings.length - 1; i++) {\n args.push(literal(ast.strings[i]));\n args.push(this._visit(ast.expressions[i], _Mode.Expression));\n }\n args.push(literal(ast.strings[ast.strings.length - 1]));\n // If we're dealing with an interpolation of 1 value with an empty prefix and suffix, reduce the\n // args returned to just the value, because we're going to pass it to a special instruction.\n const strings = ast.strings;\n if (strings.length === 2 && strings[0] === '' && strings[1] === '') {\n // Single argument interpolate instructions.\n args = [args[1]];\n }\n else if (ast.expressions.length >= 9) {\n // 9 or more arguments must be passed to the `interpolateV`-style instructions, which accept\n // an array of arguments\n args = [literalArr(args)];\n }\n return new InterpolationExpression(args);\n }\n visitKeyedRead(ast, mode) {\n const leftMostSafe = this.leftMostSafeNode(ast);\n if (leftMostSafe) {\n return this.convertSafeAccess(ast, leftMostSafe, mode);\n }\n else {\n return convertToStatementIfNeeded(mode, this._visit(ast.receiver, _Mode.Expression).key(this._visit(ast.key, _Mode.Expression)));\n }\n }\n visitKeyedWrite(ast, mode) {\n const obj = this._visit(ast.receiver, _Mode.Expression);\n const key = this._visit(ast.key, _Mode.Expression);\n const value = this._visit(ast.value, _Mode.Expression);\n if (obj === this._implicitReceiver) {\n this._localResolver.maybeRestoreView();\n }\n return convertToStatementIfNeeded(mode, obj.key(key).set(value));\n }\n visitLiteralArray(ast, mode) {\n throw new Error(`Illegal State: literal arrays should have been converted into functions`);\n }\n visitLiteralMap(ast, mode) {\n throw new Error(`Illegal State: literal maps should have been converted into functions`);\n }\n visitLiteralPrimitive(ast, mode) {\n // For literal values of null, undefined, true, or false allow type interference\n // to infer the type.\n const type = ast.value === null || ast.value === undefined || ast.value === true || ast.value === true ?\n INFERRED_TYPE :\n undefined;\n return convertToStatementIfNeeded(mode, literal(ast.value, type, this.convertSourceSpan(ast.span)));\n }\n _getLocal(name, receiver) {\n if (this._localResolver.globals?.has(name) && receiver instanceof ThisReceiver) {\n return null;\n }\n return this._localResolver.getLocal(name);\n }\n visitPrefixNot(ast, mode) {\n return convertToStatementIfNeeded(mode, not(this._visit(ast.expression, _Mode.Expression)));\n }\n visitNonNullAssert(ast, mode) {\n return convertToStatementIfNeeded(mode, this._visit(ast.expression, _Mode.Expression));\n }\n visitPropertyRead(ast, mode) {\n const leftMostSafe = this.leftMostSafeNode(ast);\n if (leftMostSafe) {\n return this.convertSafeAccess(ast, leftMostSafe, mode);\n }\n else {\n let result = null;\n const prevUsesImplicitReceiver = this.usesImplicitReceiver;\n const receiver = this._visit(ast.receiver, _Mode.Expression);\n if (receiver === this._implicitReceiver) {\n result = this._getLocal(ast.name, ast.receiver);\n if (result) {\n // Restore the previous \"usesImplicitReceiver\" state since the implicit\n // receiver has been replaced with a resolved local expression.\n this.usesImplicitReceiver = prevUsesImplicitReceiver;\n this.addImplicitReceiverAccess(ast.name);\n }\n }\n if (result == null) {\n result = receiver.prop(ast.name, this.convertSourceSpan(ast.span));\n }\n return convertToStatementIfNeeded(mode, result);\n }\n }\n visitPropertyWrite(ast, mode) {\n const receiver = this._visit(ast.receiver, _Mode.Expression);\n const prevUsesImplicitReceiver = this.usesImplicitReceiver;\n let varExpr = null;\n if (receiver === this._implicitReceiver) {\n const localExpr = this._getLocal(ast.name, ast.receiver);\n if (localExpr) {\n if (localExpr instanceof ReadPropExpr) {\n // If the local variable is a property read expression, it's a reference\n // to a 'context.property' value and will be used as the target of the\n // write expression.\n varExpr = localExpr;\n // Restore the previous \"usesImplicitReceiver\" state since the implicit\n // receiver has been replaced with a resolved local expression.\n this.usesImplicitReceiver = prevUsesImplicitReceiver;\n this.addImplicitReceiverAccess(ast.name);\n }\n else {\n // Otherwise it's an error.\n const receiver = ast.name;\n const value = (ast.value instanceof PropertyRead) ? ast.value.name : undefined;\n throw new Error(`Cannot assign value \"${value}\" to template variable \"${receiver}\". Template variables are read-only.`);\n }\n }\n }\n // If no local expression could be produced, use the original receiver's\n // property as the target.\n if (varExpr === null) {\n varExpr = receiver.prop(ast.name, this.convertSourceSpan(ast.span));\n }\n return convertToStatementIfNeeded(mode, varExpr.set(this._visit(ast.value, _Mode.Expression)));\n }\n visitSafePropertyRead(ast, mode) {\n return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);\n }\n visitSafeKeyedRead(ast, mode) {\n return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);\n }\n visitAll(asts, mode) {\n return asts.map(ast => this._visit(ast, mode));\n }\n visitQuote(ast, mode) {\n throw new Error(`Quotes are not supported for evaluation!\n Statement: ${ast.uninterpretedExpression} located at ${ast.location}`);\n }\n visitCall(ast, mode) {\n const leftMostSafe = this.leftMostSafeNode(ast);\n if (leftMostSafe) {\n return this.convertSafeAccess(ast, leftMostSafe, mode);\n }\n const convertedArgs = this.visitAll(ast.args, _Mode.Expression);\n if (ast instanceof BuiltinFunctionCall) {\n return convertToStatementIfNeeded(mode, ast.converter(convertedArgs));\n }\n const receiver = ast.receiver;\n if (receiver instanceof PropertyRead &&\n receiver.receiver instanceof ImplicitReceiver &&\n !(receiver.receiver instanceof ThisReceiver) && receiver.name === '$any') {\n if (convertedArgs.length !== 1) {\n throw new Error(`Invalid call to $any, expected 1 argument but received ${convertedArgs.length || 'none'}`);\n }\n return convertToStatementIfNeeded(mode, convertedArgs[0]);\n }\n const call = this._visit(receiver, _Mode.Expression)\n .callFn(convertedArgs, this.convertSourceSpan(ast.span));\n return convertToStatementIfNeeded(mode, call);\n }\n visitSafeCall(ast, mode) {\n return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);\n }\n _visit(ast, mode) {\n const result = this._resultMap.get(ast);\n if (result)\n return result;\n return (this._nodeMap.get(ast) || ast).visit(this, mode);\n }\n convertSafeAccess(ast, leftMostSafe, mode) {\n // If the expression contains a safe access node on the left it needs to be converted to\n // an expression that guards the access to the member by checking the receiver for blank. As\n // execution proceeds from left to right, the left most part of the expression must be guarded\n // first but, because member access is left associative, the right side of the expression is at\n // the top of the AST. The desired result requires lifting a copy of the left part of the\n // expression up to test it for blank before generating the unguarded version.\n // Consider, for example the following expression: a?.b.c?.d.e\n // This results in the ast:\n // .\n // / \\\n // ?. e\n // / \\\n // . d\n // / \\\n // ?. c\n // / \\\n // a b\n // The following tree should be generated:\n //\n // /---- ? ----\\\n // / | \\\n // a /--- ? ---\\ null\n // / | \\\n // . . null\n // / \\ / \\\n // . c . e\n // / \\ / \\\n // a b . d\n // / \\\n // . c\n // / \\\n // a b\n //\n // Notice that the first guard condition is the left hand of the left most safe access node\n // which comes in as leftMostSafe to this routine.\n let guardedExpression = this._visit(leftMostSafe.receiver, _Mode.Expression);\n let temporary = undefined;\n if (this.needsTemporaryInSafeAccess(leftMostSafe.receiver)) {\n // If the expression has method calls or pipes then we need to save the result into a\n // temporary variable to avoid calling stateful or impure code more than once.\n temporary = this.allocateTemporary();\n // Preserve the result in the temporary variable\n guardedExpression = temporary.set(guardedExpression);\n // Ensure all further references to the guarded expression refer to the temporary instead.\n this._resultMap.set(leftMostSafe.receiver, temporary);\n }\n const condition = guardedExpression.isBlank();\n // Convert the ast to an unguarded access to the receiver's member. The map will substitute\n // leftMostNode with its unguarded version in the call to `this.visit()`.\n if (leftMostSafe instanceof SafeCall) {\n this._nodeMap.set(leftMostSafe, new Call(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.receiver, leftMostSafe.args, leftMostSafe.argumentSpan));\n }\n else if (leftMostSafe instanceof SafeKeyedRead) {\n this._nodeMap.set(leftMostSafe, new KeyedRead(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.receiver, leftMostSafe.key));\n }\n else {\n this._nodeMap.set(leftMostSafe, new PropertyRead(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.nameSpan, leftMostSafe.receiver, leftMostSafe.name));\n }\n // Recursively convert the node now without the guarded member access.\n const access = this._visit(ast, _Mode.Expression);\n // Remove the mapping. This is not strictly required as the converter only traverses each node\n // once but is safer if the conversion is changed to traverse the nodes more than once.\n this._nodeMap.delete(leftMostSafe);\n // If we allocated a temporary, release it.\n if (temporary) {\n this.releaseTemporary(temporary);\n }\n // Produce the conditional\n return convertToStatementIfNeeded(mode, condition.conditional(NULL_EXPR, access));\n }\n convertNullishCoalesce(ast, mode) {\n const left = this._visit(ast.left, _Mode.Expression);\n const right = this._visit(ast.right, _Mode.Expression);\n const temporary = this.allocateTemporary();\n this.releaseTemporary(temporary);\n // Generate the following expression. It is identical to how TS\n // transpiles binary expressions with a nullish coalescing operator.\n // let temp;\n // (temp = a) !== null && temp !== undefined ? temp : b;\n return convertToStatementIfNeeded(mode, temporary.set(left)\n .notIdentical(NULL_EXPR)\n .and(temporary.notIdentical(literal(undefined)))\n .conditional(temporary, right));\n }\n // Given an expression of the form a?.b.c?.d.e then the left most safe node is\n // the (a?.b). The . and ?. are left associative thus can be rewritten as:\n // ((((a?.c).b).c)?.d).e. This returns the most deeply nested safe read or\n // safe method call as this needs to be transformed initially to:\n // a == null ? null : a.c.b.c?.d.e\n // then to:\n // a == null ? null : a.b.c == null ? null : a.b.c.d.e\n leftMostSafeNode(ast) {\n const visit = (visitor, ast) => {\n return (this._nodeMap.get(ast) || ast).visit(visitor);\n };\n return ast.visit({\n visitUnary(ast) {\n return null;\n },\n visitBinary(ast) {\n return null;\n },\n visitChain(ast) {\n return null;\n },\n visitConditional(ast) {\n return null;\n },\n visitCall(ast) {\n return visit(this, ast.receiver);\n },\n visitSafeCall(ast) {\n return visit(this, ast.receiver) || ast;\n },\n visitImplicitReceiver(ast) {\n return null;\n },\n visitThisReceiver(ast) {\n return null;\n },\n visitInterpolation(ast) {\n return null;\n },\n visitKeyedRead(ast) {\n return visit(this, ast.receiver);\n },\n visitKeyedWrite(ast) {\n return null;\n },\n visitLiteralArray(ast) {\n return null;\n },\n visitLiteralMap(ast) {\n return null;\n },\n visitLiteralPrimitive(ast) {\n return null;\n },\n visitPipe(ast) {\n return null;\n },\n visitPrefixNot(ast) {\n return null;\n },\n visitNonNullAssert(ast) {\n return null;\n },\n visitPropertyRead(ast) {\n return visit(this, ast.receiver);\n },\n visitPropertyWrite(ast) {\n return null;\n },\n visitQuote(ast) {\n return null;\n },\n visitSafePropertyRead(ast) {\n return visit(this, ast.receiver) || ast;\n },\n visitSafeKeyedRead(ast) {\n return visit(this, ast.receiver) || ast;\n }\n });\n }\n // Returns true of the AST includes a method or a pipe indicating that, if the\n // expression is used as the target of a safe property or method access then\n // the expression should be stored into a temporary variable.\n needsTemporaryInSafeAccess(ast) {\n const visit = (visitor, ast) => {\n return ast && (this._nodeMap.get(ast) || ast).visit(visitor);\n };\n const visitSome = (visitor, ast) => {\n return ast.some(ast => visit(visitor, ast));\n };\n return ast.visit({\n visitUnary(ast) {\n return visit(this, ast.expr);\n },\n visitBinary(ast) {\n return visit(this, ast.left) || visit(this, ast.right);\n },\n visitChain(ast) {\n return false;\n },\n visitConditional(ast) {\n return visit(this, ast.condition) || visit(this, ast.trueExp) || visit(this, ast.falseExp);\n },\n visitCall(ast) {\n return true;\n },\n visitSafeCall(ast) {\n return true;\n },\n visitImplicitReceiver(ast) {\n return false;\n },\n visitThisReceiver(ast) {\n return false;\n },\n visitInterpolation(ast) {\n return visitSome(this, ast.expressions);\n },\n visitKeyedRead(ast) {\n return false;\n },\n visitKeyedWrite(ast) {\n return false;\n },\n visitLiteralArray(ast) {\n return true;\n },\n visitLiteralMap(ast) {\n return true;\n },\n visitLiteralPrimitive(ast) {\n return false;\n },\n visitPipe(ast) {\n return true;\n },\n visitPrefixNot(ast) {\n return visit(this, ast.expression);\n },\n visitNonNullAssert(ast) {\n return visit(this, ast.expression);\n },\n visitPropertyRead(ast) {\n return false;\n },\n visitPropertyWrite(ast) {\n return false;\n },\n visitQuote(ast) {\n return false;\n },\n visitSafePropertyRead(ast) {\n return false;\n },\n visitSafeKeyedRead(ast) {\n return false;\n }\n });\n }\n allocateTemporary() {\n const tempNumber = this._currentTemporary++;\n this.temporaryCount = Math.max(this._currentTemporary, this.temporaryCount);\n return new ReadVarExpr(temporaryName(this.bindingId, tempNumber));\n }\n releaseTemporary(temporary) {\n this._currentTemporary--;\n if (temporary.name != temporaryName(this.bindingId, this._currentTemporary)) {\n throw new Error(`Temporary ${temporary.name} released out of order`);\n }\n }\n /**\n * Creates an absolute `ParseSourceSpan` from the relative `ParseSpan`.\n *\n * `ParseSpan` objects are relative to the start of the expression.\n * This method converts these to full `ParseSourceSpan` objects that\n * show where the span is within the overall source file.\n *\n * @param span the relative span to convert.\n * @returns a `ParseSourceSpan` for the given span or null if no\n * `baseSourceSpan` was provided to this class.\n */\n convertSourceSpan(span) {\n if (this.baseSourceSpan) {\n const start = this.baseSourceSpan.start.moveBy(span.start);\n const end = this.baseSourceSpan.start.moveBy(span.end);\n const fullStart = this.baseSourceSpan.fullStart.moveBy(span.start);\n return new ParseSourceSpan(start, end, fullStart);\n }\n else {\n return null;\n }\n }\n /** Adds the name of an AST to the list of implicit receiver accesses. */\n addImplicitReceiverAccess(name) {\n if (this.implicitReceiverAccesses) {\n this.implicitReceiverAccesses.add(name);\n }\n }\n}\nfunction flattenStatements(arg, output) {\n if (Array.isArray(arg)) {\n arg.forEach((entry) => flattenStatements(entry, output));\n }\n else {\n output.push(arg);\n }\n}\nfunction unsupported() {\n throw new Error('Unsupported operation');\n}\nclass InterpolationExpression extends Expression {\n constructor(args) {\n super(null, null);\n this.args = args;\n this.isConstant = unsupported;\n this.isEquivalent = unsupported;\n this.visitExpression = unsupported;\n }\n}\nclass DefaultLocalResolver {\n constructor(globals) {\n this.globals = globals;\n }\n notifyImplicitReceiverUse() { }\n maybeRestoreView() { }\n getLocal(name) {\n if (name === EventHandlerVars.event.name) {\n return EventHandlerVars.event;\n }\n return null;\n }\n}\nclass BuiltinFunctionCall extends Call {\n constructor(span, sourceSpan, args, converter) {\n super(span, sourceSpan, new EmptyExpr(span, sourceSpan), args, null);\n this.converter = converter;\n }\n}\n\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// =================================================================================================\n// =================================================================================================\n// =========== S T O P - S T O P - S T O P - S T O P - S T O P - S T O P ===========\n// =================================================================================================\n// =================================================================================================\n//\n// DO NOT EDIT THIS LIST OF SECURITY SENSITIVE PROPERTIES WITHOUT A SECURITY REVIEW!\n// Reach out to mprobst for details.\n//\n// =================================================================================================\n/** Map from tagName|propertyName to SecurityContext. Properties applying to all tags use '*'. */\nlet _SECURITY_SCHEMA;\nfunction SECURITY_SCHEMA() {\n if (!_SECURITY_SCHEMA) {\n _SECURITY_SCHEMA = {};\n // Case is insignificant below, all element and attribute names are lower-cased for lookup.\n registerContext(SecurityContext.HTML, [\n 'iframe|srcdoc',\n '*|innerHTML',\n '*|outerHTML',\n ]);\n registerContext(SecurityContext.STYLE, ['*|style']);\n // NB: no SCRIPT contexts here, they are never allowed due to the parser stripping them.\n registerContext(SecurityContext.URL, [\n '*|formAction', 'area|href', 'area|ping', 'audio|src', 'a|href',\n 'a|ping', 'blockquote|cite', 'body|background', 'del|cite', 'form|action',\n 'img|src', 'img|srcset', 'input|src', 'ins|cite', 'q|cite',\n 'source|src', 'source|srcset', 'track|src', 'video|poster', 'video|src',\n ]);\n registerContext(SecurityContext.RESOURCE_URL, [\n 'applet|code',\n 'applet|codebase',\n 'base|href',\n 'embed|src',\n 'frame|src',\n 'head|profile',\n 'html|manifest',\n 'iframe|src',\n 'link|href',\n 'media|src',\n 'object|codebase',\n 'object|data',\n 'script|src',\n ]);\n }\n return _SECURITY_SCHEMA;\n}\nfunction registerContext(ctx, specs) {\n for (const spec of specs)\n _SECURITY_SCHEMA[spec.toLowerCase()] = ctx;\n}\n/**\n * The set of security-sensitive attributes of an `