{"version":3,"sources":["webpack:///../node_modules/@babel/runtime/helpers/interopRequireDefault.js","webpack:///../node_modules/chain-function/index.js","webpack:///../node_modules/cldrjs/dist/cldr.js","webpack:///../node_modules/cldrjs/dist/cldr/event.js","webpack:///../node_modules/cldrjs/dist/cldr/supplemental.js","webpack:///../node_modules/cldrjs/dist/cldr/unresolved.js","webpack:///../node_modules/cldrjs/dist/node_main.js","webpack:///../node_modules/dom-helpers/class/addClass.js","webpack:///../node_modules/dom-helpers/class/hasClass.js","webpack:///../node_modules/dom-helpers/class/removeClass.js","webpack:///../node_modules/dom-helpers/transition/properties.js","webpack:///../node_modules/dom-helpers/util/inDOM.js","webpack:///../node_modules/dom-helpers/util/requestAnimationFrame.js","webpack:///../node_modules/globalize/dist/globalize.js","webpack:///../node_modules/globalize/dist/globalize/number.js","webpack:///../node_modules/griffin-paypal/lib/client/number.js","webpack:///../node_modules/griffin-paypal/lib/client/utils/assertion.js","webpack:///../node_modules/griffin-paypal/lib/client/utils/basic.js","webpack:///../node_modules/griffin-paypal/lib/client/utils/numberHelpers.js","webpack:///../node_modules/griffin-paypal/number.js","webpack:///../node_modules/lodash/_basePropertyOf.js","webpack:///../node_modules/lodash/_unescapeHtmlChar.js","webpack:///../node_modules/lodash/unescape.js","webpack:///../node_modules/react-transition-group/CSSTransitionGroup.js","webpack:///../node_modules/react-transition-group/CSSTransitionGroupChild.js","webpack:///../node_modules/react-transition-group/TransitionGroup.js","webpack:///../node_modules/react-transition-group/index.js","webpack:///../node_modules/react-transition-group/node_modules/warning/browser.js","webpack:///../node_modules/react-transition-group/utils/ChildMapping.js","webpack:///../node_modules/react-transition-group/utils/PropTypes.js"],"names":["module","exports","obj","__esModule","len","arguments","length","args","i","filter","fn","reduce","current","next","apply","this","merge","arrayIsArray","Array","isArray","Object","prototype","toString","call","pathNormalize","path","attributes","join","Error","replace","name","split","arraySome","array","callback","some","coreLikelySubtags","Cldr","cldr","subtags","options","match","language","script","sep","localeSep","territory","variants","slice","concat","get","test","force","coreRemoveLikelySubtags","maxLanguageId","result","push","coreSubtags","locale","aux","arrayForEach","forEach","bundleLookup","minLanguageId","availableBundleMap","_availableBundleMap","availableBundleMapQueue","_availableBundleMapQueue","bundle","existing","maxBundle","minBundle","undefined","splice","createError","code","error","message","JSON","stringify","object","keys","objectKeys","attribute","validate","check","validatePresence","value","validateType","expected","validateTypePath","validateTypePlainObject","resourceGet","data","node","coreSetAvailableBundles","json","main","hasOwnProperty","indexOf","alwaysArray","somethingOrArray","jsonMerge","destination","sources","source","prop","coreLoad","jsons","j","itemGetResolved","normalizedPath","_resolved","init","_alwaysArray","_coreLoad","_createError","_itemGetResolved","_jsonMerge","_pathNormalize","_resourceGet","_validatePresence","_validateType","_validateTypePath","_validateTypePlainObject","load","unicodeLocaleExtensions","variant","unicodeLocaleExtensionsRaw","pop","region","key","type","EventEmitter","proto","indexOfListener","listeners","listener","alias","getListeners","evt","response","events","_getEvents","RegExp","flattenListeners","flatListeners","getListenersAsObject","addListener","listenerIsWrapped","once","on","addOnceListener","defineEvent","defineEvents","evts","removeListener","index","off","addListeners","manipulateListeners","removeListeners","remove","single","multiple","removeEvent","_events","removeAllListeners","emitEvent","_getOnceReturnValue","trigger","emit","setOnceReturnValue","_onceReturnValue","noConflict","originalGlobalValue","superGet","superInit","validateTypeFunction","globalEe","validateTypeEvent","validateThenCall","method","self","event","getOverload","ee","_eventInit","supplementalMain","prepend","supplemental","weekData","firstDay","minDays","parseInt","timeData","allowed","preferred","initSuper","lookup","itemLookup","childLocale","parent","_raw","substr","lastIndexOf","bundleParentLookup","resourceSet","_interopRequireDefault","default","element","className","classList","add","_hasClass","setAttribute","baseVal","contains","replaceClassName","origClass","classToRemove","animationEnd","animationDelay","animationTiming","animationDuration","animationName","transitionEnd","transitionDuration","transitionDelay","transitionTiming","transitionProperty","transform","prefix","_inDOM","_getTransitionPropert","style","document","createElement","vendorMap","O","e","toLowerCase","Moz","Webkit","ms","vendors","vendor","getTransitionProperties","_default","end","property","timing","delay","duration","window","compatRaf","cancel","raf","curr","Date","getTime","Math","max","prev","req","setTimeout","getKey","k","toUpperCase","rafKey","cb","id","formatMessage","variable","objectExtend","partsPush","parts","runtimeStringify","_key","runtimeKey","fnName","argsStr","hash","str","charCodeAt","abs","stringOrArray","validateCldr","skipBoolean","skip","pathRe","validateParameterPresence","validateParameterType","validateParameterTypeLocale","isPlainObject","alwaysCldr","localeOrCldr","validateLikelySubtags","Globalize","_formatMessage","_formatMessageToParts","lastOffset","nameIncludingBrackets","offset","part","_isPlainObject","_objectExtend","_partsJoin","map","_partsPush","_regexpEscape","string","_runtimeBind","runtimeArgs","matches","exec","functionName","generatorString","_stringPad","count","right","String","_validate","_validateCldr","_validateDefaultLocale","_validateParameterPresence","_validateParameterRange","minimum","maximum","_validateParameterTypePlainObject","_validateParameterType","factory","partsJoin","regexpEscape","runtimeBind","stringPad","validateDefaultLocale","validateParameterRange","validateParameterTypePlainObject","createErrorUnsupportedFeature","validateParameterTypeNumber","validateParameterTypeString","numberNumberingSystem","numberNumberingSystemDigitsMap","numberPatternRe","numberPatternProperties","numberSymbol","numberSymbolName","numberSymbolMap","numberTruncate","numberFormatProperties","regexpCfG","regexpDashG","regexpZsG","looseMatching","objectMap","removeLiteralQuotes","numberPattern","numberCompactPatternRe","numberToPrecision","numberFormat","numberToPartsFormatterFn","feature","nu","_type","_digits","pattern","aux1","aux2","fractionPattern","integerFractionOrSignificantPattern","integerPattern","maximumFractionDigits","maximumSignificantDigits","minimumFractionDigits","minimumIntegerDigits","minimumSignificantDigits","padding","primaryGroupingSize","roundIncrement","scientificNotation","secondaryGroupingSize","significantPattern","suffix","_match","minimumSignificantDigitsMatch","maximumSignificantDigitsMatch","symbol","symbolMap","isNaN","NaN","negativePattern","negativePrefix","negativeProperties","negativeSuffix","positivePattern","roundFn","properties","getOptions","propertyIndex","round","incrementOrExp","exp","increment","exponent","toExponential","compact","compactType","maxExponent","newObject","compactKey","numberExponent","pluralForm","numberCompact","useGrouping","min","pair","number","precision","roundOrder","ceil","log","pluralGenerator","compactMap","infinitySymbol","nanSymbol","nuDigitsMap","stringToParts","compactPattern","compactProperties","divisor","numberType","character","literal","digit","etc","isFinite","floor","other","pow","toFixed","numberFormatIntegerFractionDigits","atMinimum","atMaximum","numberFormatSignificantDigits","_garbage","space","currentGroupingSize","ret","switchToSecondary","numberFormatGroupingSeparator","numberFormatter","numberToPartsFormatter","returnFn","numberFormatterFn","fnArgs","raw","validateDigits","numberParser","decimalSymbolRe","digitsRe","groupingSeparatorRe","invertedNuDigitsMap","invertedSymbolMap","numberTokenizer","formatProperties","numberSymbolInvertedMap","localizedDigit","infinity","nan","numberParseProperties","grammar","negative","prefixNSuffix","tokenizer","_value","statement","every","lexeme","Infinity","parse","tokenizeNParse","numberParse","numberParserFn","formatNumber","formatNumberToParts","parseNumber","_createErrorUnsupportedFeature","_numberNumberingSystem","_numberNumberingSystemDigitsMap","_numberPattern","_numberSymbol","_looseMatching","_removeLiteralQuotes","_validateParameterTypeNumber","_validateParameterTypeString","assertion","basic","objectAssign","assert","assertMetadata","assertRange","assertType","getValueOrDefault","numberHelpers","assertCanonicalNumberType","assertLocalizedNumberType","setFractionDigits","NumberHandler","optionsPrototype","outputType","currencyDisplay","defineProperty","enumerable","NUMBER_FORMAT","CURRENCY_PRESETS","CURRENCY_FORMAT","CURRENCY_FORMAT_ISOCURRENCY","CURRENCY_FORMAT_SYMBOLISOCURRENCY","presetName","presetValue","create","CURRENCY_PRESET_VALUES","symbolForCurrency","handler","currencyCode","currencyMeta","metadata","cldrCurrencies","currencyStyles","currency","newCurrencyStyles","didCurrencyLevelOverride","currency_override","currencySymbol","svalueA","svalueB","valueA","valueB","equivalency","position","fuzzyMatch","currencyPatternByStyle","globalize","currencyValue","parameter","parameterValue","currencyDigits","currencyInfo","digits","digitsForCurrency","localeNumberStyles","cldrNumbers","numberStyles","localeCurrencyStyles","formattedCurrency","formatBinder","numberOptions","patternElements","minusSign","C","separator","charAt","createHandler","griffin","griffinNumberMeta","country","cldrLocale","cldrMain","numbers","currencies","assertNumberMeta","listFormat","smarterTypeof","withinRange","condition","errorMessage","errorClass","parameterName","expectedTypes","parameterType","TypeError","expectedTypesMessage","metadataNode","collection","RangeError","objectGet","item","objectSet","objectValues","cloneArray","cloneDate","date","constructor","fixedCharCodeAt","idx","hi","low","objectSlice","jsonDeepMerge","isLatin","trimObject","clonedObject","trim","definePrivateProperty","defineProperties","variables","_","defaultValue","conjunction","invalidCodePointFromString","regex","codePoint","chr","Number","assertCanonicalNumberTypeStrict","unescapeHtmlChar","basePropertyOf","reEscapedHtml","reHasEscapedHtml","_extends","assign","target","_react2","_propTypes2","_TransitionGroup2","_CSSTransitionGroupChild2","_PropTypes","_classCallCheck","instance","Constructor","_possibleConstructorReturn","ReferenceError","nameShape","isRequired","bool","transitionTimeout","CSSTransitionGroup","_React$Component","_temp","_this","_len","_wrapChild","child","props","transitionName","appear","transitionAppear","enter","transitionEnter","leave","transitionLeave","appearTimeout","transitionAppearTimeout","enterTimeout","transitionEnterTimeout","leaveTimeout","transitionLeaveTimeout","subClass","superClass","writable","configurable","setPrototypeOf","__proto__","_inherits","render","childFactory","Component","displayName","propTypes","defaultProps","_addClass2","_removeClass2","_requestAnimationFrame2","_properties","_reactDom","CSSTransitionGroupChild","componentWillAppear","done","transition","componentWillEnter","componentWillLeave","componentWillMount","classNameAndNodeQueue","transitionTimeouts","componentWillUnmount","unmounted","timeout","clearTimeout","animationType","finishCallback","findDOMNode","activeClassName","timer","queueClassAndNode","finish","addEventListener","removeEventListener","addEndListener","_this2","rafHandle","flushClassNameAndNodeQueue","scrollTop","children","cloneElement","Children","only","_chainFunction2","_ChildMapping","any","func","TransitionGroup","context","performAppear","component","currentlyTransitioningKeys","_handleDoneAppearing","bind","componentDidAppear","currentChildMapping","getChildMapping","performLeave","performEnter","_handleDoneEntering","componentDidEnter","_handleDoneLeaving","componentDidLeave","keysToEnter","setState","state","newChildren","childRefs","keysToLeave","componentDidMount","initialChildMapping","componentWillReceiveProps","nextProps","nextChildMapping","prevChildMapping","mergeChildMappings","hasPrev","hasNext","componentDidUpdate","_this3","childrenToRender","_loop","isCallbackRef","ref","factoryChild","r","_CSSTransitionGroup2","_react","getValueForKey","nextKeysPending","pendingKeys","prevKey","childMapping","nextKey","pendingNextKey","transitionType","timeoutPropName","enabledPropName","oneOfType","shape","active","enterActive","leaveActive","appearActive"],"mappings":";;;;;;oFAKAA,EAAOC,QALP,SAAgCC,GAC9B,OAAOA,GAAOA,EAAIC,WAAaD,EAAM,CACnC,QAAWA,IAG0BF,EAAOC,QAAQE,YAAa,EAAMH,EAAOC,QAAiB,QAAID,EAAOC,S;;;;;;oFCJ9GD,EAAOC,QAAU,WAIf,IAHA,IAAIG,EAAMC,UAAUC,OAChBC,EAAO,GAEFC,EAAI,EAAGA,EAAIJ,EAAKI,IACvBD,EAAKC,GAAKH,UAAUG,GAItB,GAAoB,KAFpBD,EAAOA,EAAKE,QAAO,SAASC,GAAK,OAAa,MAANA,MAE/BJ,OACT,OAAoB,IAAhBC,EAAKD,OAAqBC,EAAK,GAE5BA,EAAKI,QAAO,SAASC,EAASC,GACnC,OAAO,WACLD,EAAQE,MAAMC,KAAMV,WACpBQ,EAAKC,MAAMC,KAAMV,iB;;;;;;sFChBvB;;;;QAkBiB,0BAAf,EASO,WAGR,IA6bIW,EA7bAC,EAAeC,MAAMC,SAAW,SAAUjB,GAC7C,MAAiD,mBAA1CkB,OAAOC,UAAUC,SAASC,KAAMrB,IAMpCsB,EAAgB,SAAUC,EAAMC,GAInC,GAHKT,EAAcQ,KAClBA,EAAOA,EAAKE,KAAM,MAEE,iBAATF,EACX,MAAM,IAAIG,MAAO,iBAAoBH,EAAO,KAc7C,OALAA,GALAA,EAAOA,EACLI,QAAS,MAAQ,IACjBA,QAAS,UAAY,KAGXA,QAAS,gBAAgB,SAAUC,GAE9C,OADAA,EAAOA,EAAKD,QAAS,cAAe,MAC7BH,EAAYI,OAGRC,MAAO,MAMhBC,EAAY,SAAUC,EAAOC,GAChC,IAAI1B,EAAGF,EACP,GAAK2B,EAAME,KACV,OAAOF,EAAME,KAAMD,GAEpB,IAAM1B,EAAI,EAAGF,EAAS2B,EAAM3B,OAAQE,EAAIF,EAAQE,IAC/C,GAAK0B,EAAUD,EAAOzB,GAAKA,EAAGyB,GAC7B,OAAO,EAGT,OAAO,GAgDJG,EAAoB,SAAUC,EAAMC,EAAMC,EAASC,GACtD,IAAIC,EACHC,EAAWH,EAAS,GACpBI,EAASJ,EAAS,GAClBK,EAAMP,EAAKQ,UACXC,EAAYP,EAAS,GACrBQ,EAAWR,EAAQS,MAAO,EAAG,GAI9B,OAHAR,EAAUA,GAAW,GAGH,QAAbE,GAAiC,SAAXC,GAAmC,OAAdG,EACxC,CAAEJ,EAAUC,EAAQG,GAAYG,OAAQF,QAIS,IAA7CT,EAAKY,IAAK,8BAKTlB,EAAU,CACtB,CAAEU,EAAUC,EAAQG,GACpB,CAAEJ,EAAUI,GACZ,CAAEJ,EAAUC,GACZ,CAAED,GACF,CAAE,MAAOC,KACP,SAAUQ,GACZ,OAAOV,GAAS,gBAAkBU,KAAMA,EAAKxB,KAAMiB,KAAuBN,EAAKY,IAAK,CAAE,6BAA8BC,EAAKxB,KAAMiB,SAM/HH,EAAQA,EAAMV,MAAOa,GACd,CACO,QAAbF,EAAqBA,EAAWD,EAAO,GAC5B,SAAXE,EAAoBA,EAASF,EAAO,GACtB,OAAdK,EAAqBA,EAAYL,EAAO,IACvCQ,OAAQF,IACCP,EAAQY,MAEZd,EAAKY,IAAK,kCAAmCnB,MAAOa,QAG3D,OA7BD,GA+CGS,EAA0B,SAAUhB,EAAMC,EAAMgB,GACnD,IAAIb,EACHC,EAAWY,EAAe,GAC1BX,EAASW,EAAe,GACxBR,EAAYQ,EAAe,GAC3BP,EAAWO,EAAe,GAe3B,OAZatB,EAAU,CACtB,CAAE,CAAEU,EAAU,OAAQ,MAAQ,CAAEA,IAChC,CAAE,CAAEA,EAAU,OAAQI,GAAa,CAAEJ,EAAUI,IAC/C,CAAE,CAAEJ,EAAUC,EAAQ,MAAQ,CAAED,EAAUC,MACxC,SAAUQ,GACZ,IAAII,EAASnB,EAAmBC,EAAMC,EAAMa,EAAM,IAElD,OADAV,EAAQU,EAAM,GACPI,GAAUA,EAAQ,KAAQD,EAAe,IAC/CC,EAAQ,KAAQD,EAAe,IAC/BC,EAAQ,KAAQD,EAAe,OAI3BP,GACJN,EAAMe,KAAMT,GAENN,GAIDa,GAWJG,EAAc,SAAUC,GAC3B,IAAIC,EACHpB,EAAU,GAwBX,OAnBAoB,GAHAD,EAASA,EAAO7B,QAAS,IAAK,MAGjBE,MAAO,QACV,KACT4B,EAAK,GAAMA,EAAK,GAAI5B,MAAO,OAC3B2B,EAASC,EAAK,IAAQA,EAAK,GAAK,GAAM,MAAQA,EAAK,GAAK,GAAM,IAC9DpB,EAAS,GAAoCoB,EAAK,GAAK,IAe3C,QADbA,EAToBD,EAAO3B,MAAO,OAAS,GASnBU,MAAO,oHAEvB,CAAE,MAAO,OAAQ,OAEzBF,EAAS,GAAqBoB,EAAK,KAAmBA,EAAK,IAAO,MAClEpB,EAAS,GAAmBoB,EAAK,IAAO,OACxCpB,EAAS,GAAsBoB,EAAK,IAAO,KACtCA,EAAK,IAAOA,EAAK,GAAIrD,SACzBiC,EAAS,GAAoBoB,EAAK,GAAIX,MAAO,IAQvCT,IAMJqB,EAAe,SAAU3B,EAAOC,GACnC,IAAI1B,EAAGF,EACP,GAAK2B,EAAM4B,QACV,OAAO5B,EAAM4B,QAAS3B,GAEvB,IAAM1B,EAAI,EAAGF,EAAS2B,EAAM3B,OAAQE,EAAIF,EAAQE,IAC/C0B,EAAUD,EAAOzB,GAAKA,EAAGyB,IAgBvB6B,EAAe,SAAUzB,EAAMC,EAAMyB,GACxC,IAAIC,EAAqB3B,EAAK4B,oBAC7BC,EAA0B7B,EAAK8B,yBAsBhC,OApBKD,EAAwB5D,SAC5BsD,EAAcM,GAAyB,SAAUE,EAAQ5D,GACxD,IAAI6D,EAAUC,EAAWC,EAAWhC,EAGpC,GAFAA,EAAUkB,EAAaW,QAEJI,KADnBF,EAAYlC,EAAmBC,EAAMC,EAAMC,IAG1C,MADA2B,EAAwBO,OAAQjE,EAAG,GAC7B,IAAIoB,MAAO,oCAAsCwC,GAGxDG,GADAA,EAAYlB,EAAyBhB,EAAMC,EAAMgC,IAC3B3C,KAAMU,EAAKQ,YACjCwB,EAAWL,EAAoBO,KACdF,EAAS/D,OAAS8D,EAAO9D,SAG1C0D,EAAoBO,GAAcH,MAEnC/B,EAAK8B,yBAA2B,IAG1BH,EAAoBD,IAAmB,MAwB3CW,EAAc,SAAUC,EAAMjD,GACjC,IAAIkD,EAAOC,EAWX,OATAA,EAAUF,GAASjD,GAAcoD,KAAO,KAAOA,KAAKC,UAAWrD,GAAe,KAC9EkD,EAAQ,IAAIhD,MAAOiD,IACbF,KAAOA,EAGbf,EA1BgB,SAAUoB,GAC1B,IAAIxE,EACH+C,EAAS,GAEV,GAAKnC,OAAO6D,KACX,OAAO7D,OAAO6D,KAAMD,GAGrB,IAAMxE,KAAKwE,EACVzB,EAAOC,KAAMhD,GAGd,OAAO+C,EAcO2B,CAAYxD,IAAc,SAAUyD,GACjDP,EAAOO,GAAczD,EAAYyD,MAG3BP,GAMJQ,EAAW,SAAUT,EAAMU,EAAO3D,GACrC,IAAM2D,EACL,MAAMX,EAAaC,EAAMjD,IAOvB4D,EAAmB,SAAUC,EAAOzD,GACvCsD,EAAU,2BAAwC,IAAVG,EAAuB,CAC9DzD,KAAMA,KAOJ0D,EAAe,SAAUD,EAAOzD,EAAMuD,EAAOI,GAChDL,EAAU,qBAAsBC,EAAO,CACtCI,SAAUA,EACV3D,KAAMA,EACNyD,MAAOA,KAOLG,EAAmB,SAAUH,EAAOzD,GACvC0D,EAAcD,EAAOzD,EAAuB,iBAAVyD,GAAsBtE,EAAcsE,GAAS,oBAgB5EI,EAA0B,SAAUJ,EAAOzD,GAP3B,IAAU5B,EAQ7BsF,EAAcD,EAAOzD,OAAuB,IAAVyD,GAPnB,QADcrF,EAQ6CqF,IAPnD,GAAKrF,GAAQ,kBAO+C,iBAchF0F,EAAc,SAAUC,EAAMpE,GACjC,IAAIjB,EACHsF,EAAOD,EACPvF,EAASmB,EAAKnB,OAEf,IAAME,EAAI,EAAGA,EAAIF,EAAS,EAAGE,IAE5B,KADAsF,EAAOA,EAAMrE,EAAMjB,KAElB,OAGF,OAAOsF,EAAMrE,EAAMjB,KAehBuF,EAA0B,SAAU1D,EAAM2D,GAC7C,IAAI5B,EACHF,EAA0B7B,EAAK8B,yBAC/B8B,EAAOL,EAAaI,EAAM,CAAE,SAE7B,GAAKC,EACJ,IAAM7B,KAAU6B,EACVA,EAAKC,eAAgB9B,IAAuB,SAAXA,IACY,IAA/CF,EAAwBiC,QAAS/B,IACnCF,EAAwBV,KAAMY,IAQ9BgC,EAAc,SAAUC,GAC3B,OAAOpF,EAAcoF,GAAsBA,EAAmB,CAAEA,IAI7DC,EAUAtF,EAAQ,WACX,IAAIuF,EAAc,GACjBC,EAAU,GAAGxD,MAAMzB,KAAMlB,UAAW,GAiBrC,OAhBAuD,EAAc4C,GAAS,SAAUC,GAChC,IAAIC,EACJ,IAAMA,KAAQD,EACRC,KAAQH,GAA8C,iBAAxBA,EAAaG,KAAwBzF,EAAcsF,EAAaG,IAGlGH,EAAaG,GAAS1F,EAAOuF,EAAaG,GAAQD,EAAQC,IAK1DH,EAAaG,GAASD,EAAQC,MAK1BH,GAiBJI,EAAW,SAAUtE,EAAMoE,EAAQG,GACtC,IAAIpG,EAAGqG,EAAGb,EAKV,IAHAV,EAAkBsB,EAAO,GAAK,QAGxBpG,EAAI,EAAGA,EAAIoG,EAAMtG,OAAQE,IAK9B,IAFAwF,EAAOI,EAAaQ,EAAOpG,IAErBqG,EAAI,EAAGA,EAAIb,EAAK1F,OAAQuG,IAC7BlB,EAAyBK,EAAMa,GAAK,QACpCJ,EAASH,EAAWG,EAAQT,EAAMa,IAClCd,EAAyB1D,EAAM2D,EAAMa,IAIvC,OAAOJ,GAKJK,EAAkB,SAAUzE,EAAMZ,EAAMC,GAE3C,IAAIqF,EAAiBvF,EAAeC,EAAMC,GAE1C,OAAOkE,EAAavD,EAAK2E,UAAWD,IASjC1E,EAAO,SAAUqB,GACpB3C,KAAKkG,KAAMvD,IAoIZ,OAhIArB,EAAK6E,aAAed,EACpB/D,EAAK8E,UAAYR,EACjBtE,EAAK+E,aAAe1C,EACpBrC,EAAKgF,iBAAmBP,EACxBzE,EAAKiF,WAAahB,EAClBjE,EAAKkF,eAAiB/F,EACtBa,EAAKmF,aAAe5B,EACpBvD,EAAKoF,kBAAoBnC,EACzBjD,EAAKqF,cAAgBlC,EACrBnD,EAAKsF,kBAAoBjC,EACzBrD,EAAKuF,yBAA2BjC,EAEhCtD,EAAK4B,oBAAsB,GAC3B5B,EAAK8B,yBAA2B,GAChC9B,EAAK2E,UAAY,GAGjB3E,EAAKQ,UAAY,IASjBR,EAAKwF,KAAO,WACXxF,EAAK2E,UAAYL,EAAUtE,EAAMA,EAAK2E,UAAW3G,YAMlDgC,EAAKhB,UAAU4F,KAAO,SAAUvD,GAC/B,IAAIhC,EAAYgB,EAAUY,EAAeS,EAAepB,EAAQJ,EAASO,EAAWgF,EAAyBC,EAjL3ExC,EAkLjC3C,EAAMP,EAAKQ,UACXmF,EAA6B,GAE9B1C,EAAkB5B,EAAQ,UApL1B8B,EADkCD,EAsLd7B,EAAQ,SArLgB,iBAAV6B,EAAoB,YAyL9B,KAFxBhD,EAAUkB,EAAaC,IAEVpD,SAEZ0H,EAA6BpF,EAAM,IAAMA,GADzCkF,EAA0BvF,EAAQ0F,OAG5B1F,EAAS,IACdA,EAAQ0F,OAGVF,EAAUxF,EAAS,GAYnBG,GADAY,EAAgBlB,EAAmBC,EAAMtB,KAAMwB,EAAS,CAAEa,OAAO,KAAYb,GACnD,GAC1BI,EAASW,EAAe,GACxBR,EAAYQ,EAAe,GAE3BS,EAAgBV,EAAyBhB,EAAMtB,KAAMuC,GAAgB3B,KAAMiB,GAG3E7B,KAAKW,WAAaA,EAAa,CAC9B0C,OAAQN,EAAczB,EAAMtB,KAAMgD,GAGlCA,cAAeA,EAAgBiE,EAC/B1E,cAAeA,EAAc3B,KAAMiB,GAAQoF,EAG3CtF,SAAUA,EACVC,OAAQA,EACRG,UAAWA,EACXoF,OAAQpF,EACRiF,QAASA,GAIVD,IAA6B,IAAMA,GAA0BjG,QAAS,yCAAyC,SAAUsD,EAAWgD,EAAKC,GAEnID,EAGJzG,EAAY,IAAMyG,GAAQC,EAI1B1G,EAAY,IAAMyD,IAAc,KAIlCpE,KAAK2C,OAASA,GAMfrB,EAAKhB,UAAU6B,IAAM,SAAUzB,GAK9B,OAHA6D,EAAkB7D,EAAM,QACxBiE,EAAkBjE,EAAM,QAEjBqF,EAAiBzE,EAAMZ,EAAMV,KAAKW,aAM1CW,EAAKhB,UAAU4E,KAAO,SAAUxE,GAS/B,OARA6D,EAAkB7D,EAAM,QACxBiE,EAAkBjE,EAAM,QAExB2D,EAAU,mBAA+C,OAA3BrE,KAAKW,WAAW0C,OAAiB,CAC9DV,OAAQ3C,KAAK2C,SAGdjC,EAAO2E,EAAa3E,GACbV,KAAKmC,IAAK,CAAE,iBAAkBD,OAAQxB,KAGvCY,IAtpBS,mC;;;;;;sFClBjB;;;;GAkBE,EAAQ,CAAE,6DAAoB,0BAAP,EASvB,SAAUA,GAGX,IAWGgG,EAXC7G,EAAgBa,EAAKkF,eACxBjC,EAAmBjD,EAAKoF,kBACxBjC,EAAenD,EAAKqF;;;;;;GAWtBW,EAAgB,WASf,SAASA,KAGT,IAAIC,EAAQD,EAAahH,UACrBpB,EAAU,GAWd,SAASsI,EAAgBC,EAAWC,GAEnC,IADA,IAAIjI,EAAIgI,EAAUlI,OACXE,KACN,GAAIgI,EAAUhI,GAAGiI,WAAaA,EAC7B,OAAOjI,EAIT,OAAQ,EAUT,SAASkI,EAAM5G,GACd,OAAO,WACN,OAAOf,KAAKe,GAAMhB,MAAMC,KAAMV,YAwZhC,OA3YAiI,EAAMK,aAAe,SAAsBC,GAC1C,IACIC,EACAV,EAFAW,EAAS/H,KAAKgI,aAMlB,GAAIH,aAAeI,OAElB,IAAKb,KADLU,EAAW,GACCC,EACPA,EAAO5C,eAAeiC,IAAQS,EAAIzF,KAAKgF,KAC1CU,EAASV,GAAOW,EAAOX,SAKzBU,EAAWC,EAAOF,KAASE,EAAOF,GAAO,IAG1C,OAAOC,GASRP,EAAMW,iBAAmB,SAA0BT,GAClD,IACIhI,EADA0I,EAAgB,GAGpB,IAAK1I,EAAI,EAAGA,EAAIgI,EAAUlI,OAAQE,GAAK,EACtC0I,EAAc1F,KAAKgF,EAAUhI,GAAGiI,UAGjC,OAAOS,GASRZ,EAAMa,qBAAuB,SAA8BP,GAC1D,IACIC,EADAL,EAAYzH,KAAK4H,aAAaC,GAQlC,OALIJ,aAAqBtH,SACxB2H,EAAW,IACFD,GAAOJ,GAGVK,GAAYL,GAapBF,EAAMc,YAAc,SAAqBR,EAAKH,GAC7C,IAEIN,EAFAK,EAAYzH,KAAKoI,qBAAqBP,GACtCS,EAAwC,iBAAbZ,EAG/B,IAAKN,KAAOK,EACPA,EAAUtC,eAAeiC,KAAuD,IAA/CI,EAAgBC,EAAUL,GAAMM,IACpED,EAAUL,GAAK3E,KAAK6F,EAAoBZ,EAAW,CAClDA,SAAUA,EACVa,MAAM,IAKT,OAAOvI,MAMRuH,EAAMiB,GAAKb,EAAM,eAUjBJ,EAAMkB,gBAAkB,SAAyBZ,EAAKH,GACrD,OAAO1H,KAAKqI,YAAYR,EAAK,CAC5BH,SAAUA,EACVa,MAAM,KAORhB,EAAMgB,KAAOZ,EAAM,mBASnBJ,EAAMmB,YAAc,SAAqBb,GAExC,OADA7H,KAAK4H,aAAaC,GACX7H,MASRuH,EAAMoB,aAAe,SAAsBC,GAC1C,IAAK,IAAInJ,EAAI,EAAGA,EAAImJ,EAAKrJ,OAAQE,GAAK,EACrCO,KAAK0I,YAAYE,EAAKnJ,IAEvB,OAAOO,MAWRuH,EAAMsB,eAAiB,SAAwBhB,EAAKH,GACnD,IACIoB,EACA1B,EAFAK,EAAYzH,KAAKoI,qBAAqBP,GAI1C,IAAKT,KAAOK,EACPA,EAAUtC,eAAeiC,KAGb,KAFf0B,EAAQtB,EAAgBC,EAAUL,GAAMM,KAGvCD,EAAUL,GAAK1D,OAAOoF,EAAO,GAKhC,OAAO9I,MAMRuH,EAAMwB,IAAMpB,EAAM,kBAYlBJ,EAAMyB,aAAe,SAAsBnB,EAAKJ,GAE/C,OAAOzH,KAAKiJ,qBAAoB,EAAOpB,EAAKJ,IAa7CF,EAAM2B,gBAAkB,SAAyBrB,EAAKJ,GAErD,OAAOzH,KAAKiJ,qBAAoB,EAAMpB,EAAKJ,IAe5CF,EAAM0B,oBAAsB,SAA6BE,EAAQtB,EAAKJ,GACrE,IAAIhI,EACA+E,EACA4E,EAASD,EAASnJ,KAAK6I,eAAiB7I,KAAKqI,YAC7CgB,EAAWF,EAASnJ,KAAKkJ,gBAAkBlJ,KAAKgJ,aAGpD,GAAmB,iBAARnB,GAAsBA,aAAeI,OAmB/C,IADAxI,EAAIgI,EAAUlI,OACPE,KACN2J,EAAO5I,KAAKR,KAAM6H,EAAKJ,EAAUhI,SAnBlC,IAAKA,KAAKoI,EACLA,EAAI1C,eAAe1F,KAAO+E,EAAQqD,EAAIpI,MAEpB,mBAAV+E,EACV4E,EAAO5I,KAAKR,KAAMP,EAAG+E,GAIrB6E,EAAS7I,KAAKR,KAAMP,EAAG+E,IAe3B,OAAOxE,MAYRuH,EAAM+B,YAAc,SAAqBzB,GACxC,IAEIT,EAFAC,SAAcQ,EACdE,EAAS/H,KAAKgI,aAIlB,GAAa,WAATX,SAEIU,EAAOF,QAEV,GAAIA,aAAeI,OAEvB,IAAKb,KAAOW,EACPA,EAAO5C,eAAeiC,IAAQS,EAAIzF,KAAKgF,WACnCW,EAAOX,eAMTpH,KAAKuJ,QAGb,OAAOvJ,MAQRuH,EAAMiC,mBAAqB7B,EAAM,eAcjCJ,EAAMkC,UAAY,SAAmB5B,EAAKrI,GACzC,IACIkI,EACAjI,EACA2H,EAHAK,EAAYzH,KAAKoI,qBAAqBP,GAM1C,IAAKT,KAAOK,EACX,GAAIA,EAAUtC,eAAeiC,GAG5B,IAFA3H,EAAIgI,EAAUL,GAAK7H,OAEZE,MAKgB,KAFtBiI,EAAWD,EAAUL,GAAK3H,IAEb8I,MACZvI,KAAK6I,eAAehB,EAAKH,EAASA,UAGxBA,EAASA,SAAS3H,MAAMC,KAAMR,GAAQ,MAEhCQ,KAAK0J,uBACrB1J,KAAK6I,eAAehB,EAAKH,EAASA,UAMtC,OAAO1H,MAMRuH,EAAMoC,QAAUhC,EAAM,aAUtBJ,EAAMqC,KAAO,SAAc/B,GAC1B,IAAIrI,EAAOW,MAAMG,UAAU2B,MAAMzB,KAAKlB,UAAW,GACjD,OAAOU,KAAKyJ,UAAU5B,EAAKrI,IAW5B+H,EAAMsC,mBAAqB,SAA4BrF,GAEtD,OADAxE,KAAK8J,iBAAmBtF,EACjBxE,MAWRuH,EAAMmC,oBAAsB,WAC3B,OAAI1J,KAAKmF,eAAe,qBAChBnF,KAAK8J,kBAadvC,EAAMS,WAAa,WAClB,OAAOhI,KAAKuJ,UAAYvJ,KAAKuJ,QAAU,KAQxCjC,EAAayC,WAAa,WAEzB,OADA7K,EAAQoI,aAAe0C,oBAChB1C,GAGDA,EApcO,GA0cd,IAOI2C,EAAUC,EAPVC,EAAuB,SAAU3F,EAAOzD,GAC3C0D,EAAcD,EAAOzD,OAAuB,IAAVyD,GAA0C,mBAAVA,EAAsB,aAOxF4F,EAAW,IAAI9C,EAEhB,SAAS+C,EAAmB7F,EAAOzD,GAClC0D,EAAcD,EAAOzD,EAAuB,iBAAVyD,GAAsBA,aAAiByD,OAAQ,oBAGlF,SAASqC,EAAkBC,EAAQC,GAClC,OAAO,SAAUC,EAAO/C,GAOvB,OANAnD,EAAkBkG,EAAO,SACzBJ,EAAmBI,EAAO,SAE1BlG,EAAkBmD,EAAU,YAC5ByC,EAAsBzC,EAAU,YAEzB8C,EAAMD,GAASxK,MAAOyK,EAAMlL,YAIrC,SAASyJ,EAAKyB,GACb,OAAOF,EAAkB,MAAOE,GAGjC,SAAShC,EAAIgC,GACZ,OAAOF,EAAkB,KAAME,GAGhC,SAASjC,EAAMiC,GACd,OAAOF,EAAkB,OAAQE,GAyBlC,SAASE,IAKRT,EAAW3I,EAAKhB,UAAU6B,IAC1Bb,EAAKhB,UAAU6B,IAAM,SAAUzB,GAC9B,IAAI8D,EAAQyF,EAASlK,MAAOC,KAAMV,WAIlC,OAHAoB,EAAOD,EAAeC,EAAMV,KAAKW,YAAaC,KAAM,KACpDwJ,EAAST,QAAS,MAAO,CAAEjJ,EAAM8D,IACjCxE,KAAK2K,GAAGhB,QAAS,MAAO,CAAEjJ,EAAM8D,IACzBA,GAOT,OAxCAlD,EAAKyH,IAAMA,EAAKqB,GAChB9I,EAAKkH,GAAKA,EAAI4B,GACd9I,EAAKiH,KAAOA,EAAM6B,GAKlBF,EAAY5I,EAAKhB,UAAU4F,KAC3B5E,EAAKhB,UAAU4F,KAAO,WACrB,IAAIyE,EACJ3K,KAAK2K,GAAKA,EAAK,IAAIrD,EACnBtH,KAAK+I,IAAMA,EAAK4B,GAChB3K,KAAKwI,GAAKA,EAAImC,GACd3K,KAAKuI,KAAOA,EAAMoC,GAClBT,EAAUnK,MAAOC,KAAMV,YAuBxBgC,EAAKsJ,WAAaF,EAClBA,IAEOpJ,IAjjBwB,gC;;;;;;sFClBhC;;;;GAkBE,EAAQ,CAAE,6DAAoB,0BAAP,EASvB,SAAUA,GAGX,IAAI+D,EAAc/D,EAAK6E,aAInB0E,EAAmB,SAAUtJ,GAEhC,IAAIuJ,EAASC,EAwCb,OA/BAA,GAPAD,EAAU,SAAUA,GACnB,OAAO,SAAUpK,GAEhB,OADAA,EAAO2E,EAAa3E,GACba,EAAKY,IAAK,CAAE2I,GAAU5I,OAAQxB,OAIf,iBAIXsK,SAAWF,EAAS,yBAEjCC,EAAaC,SAASC,SAAW,WAChC,OAAO1J,EAAKY,IAAK,+CAChBZ,EAAKY,IAAK,uCAGZ4I,EAAaC,SAASE,QAAU,WAC/B,IAAIA,EAAU3J,EAAKY,IAAK,8CACvBZ,EAAKY,IAAK,qCACX,OAAOgJ,SAAUD,EAAS,KAK3BH,EAAaK,SAAWN,EAAS,yBAEjCC,EAAaK,SAASC,QAAU,WAC/B,OAAO9J,EAAKY,IAAK,+CAChBZ,EAAKY,IAAK,uCAGZ4I,EAAaK,SAASE,UAAY,WACjC,OAAO/J,EAAKY,IAAK,iDAChBZ,EAAKY,IAAK,yCAGL4I,GAOJQ,EAAYjK,EAAKhB,UAAU4F,KAY/B,OALA5E,EAAKhB,UAAU4F,KAAO,WACrBqF,EAAUxL,MAAOC,KAAMV,WACvBU,KAAK+K,aAAeF,EAAkB7K,OAGhCsB,IA7EwB,gC;;;;;;sFClBhC;;;;GAkBE,EAAQ,CAAE,6DAAoB,0BAAP,EASvB,SAAUA,GAGX,IAqDIkK,EArDA5F,EAAWtE,EAAK8E,UAChBb,EAAYjE,EAAKiF,WACjB9F,EAAgBa,EAAKkF,eACrB3B,EAAcvD,EAAKmF,aACnBlC,EAAmBjD,EAAKoF,kBACxB/B,EAAmBrD,EAAKsF,kBA8CxB6E,EAIJD,EAAS,SAAUlK,EAAMqB,EAAQjC,EAAMC,EAAY+K,GAClD,IAAI1F,EAAgB2F,EAAQnH,EAI5B,QAAuB,IAAX7B,GAAkCA,IAAW+I,EAWzD,OANA1F,EAAiBvF,EAAeC,EAAMC,QAMvB8C,KADfe,EAAQK,EAAavD,EAAK2E,UAAWD,KACQ,iBAAVxB,SAOpBf,KAFfe,EAAQK,EAAavD,EAAKsK,KAAM5F,MAI/B2F,EAvEuB,SAAUrK,EAAMqB,GACxC,IAAIqD,EAAgB2F,EAEpB,GAAgB,SAAXhJ,EAOL,OAFAqD,EAAiBvF,EAAe,CAAE,0CAA2CkC,KAC7EgJ,EAAS9G,EAAavD,EAAK2E,UAAWD,IAAoBnB,EAAavD,EAAKsK,KAAM5F,IAE1E2F,GAIRA,EAAShJ,EAAOkJ,OAAQ,EAAGlJ,EAAOmJ,YAAaxK,EAAKQ,cAE5C,OAsDEiK,CAAoBzK,EAAMqB,GACnC6B,EAAQgH,EAAQlK,EAAMqK,EAAQjL,EAAM6E,EAAW5E,EAAY,CAAE0C,OAAQsI,IAAWhJ,SAGlEc,IAAVe,GAhDY,SAAUM,EAAMpE,EAAM8D,GACvC,IAAI/E,EACHsF,EAAOD,EACPvF,EAASmB,EAAKnB,OAEf,IAAME,EAAI,EAAGA,EAAIF,EAAS,EAAGE,IACtBsF,EAAMrE,EAAMjB,MACjBsF,EAAMrE,EAAMjB,IAAQ,IAErBsF,EAAOA,EAAMrE,EAAMjB,IAEpBsF,EAAMrE,EAAMjB,IAAQ+E,EAuCnBwH,CAAa1K,EAAK2E,UAAWD,EAAgBxB,IAdtCA,GAwDT,OA/BAlD,EAAKsK,KAAO,GAUZtK,EAAKwF,KAAO,WACXxF,EAAKsK,KAAOhG,EAAUtE,EAAMA,EAAKsK,KAAMtM,YAMxCgC,EAAKhB,UAAU6B,IAAM,SAAUzB,GAM9B,OALA6D,EAAkB7D,EAAM,QACxBiE,EAAkBjE,EAAM,QAIjB+K,EAAYnK,EAAMtB,KAAKW,YAAcX,KAAKW,WAAW0C,QAAkB,GAAY3C,EAAMV,KAAKW,aAIjGW,EAAKsJ,YACTtJ,EAAKsJ,aAGCtJ,IA5IwB,gC;;;;;;;;;;;ACFhCrC,EAAOC,QAAU,eAAS,uCAG1B,qBAAS,6CACT,4BAAS,oDACT,0BAAS,mD;;;;;;mGCnBT,IAAI+M,EAAyB,qDAAQ,mEAErC/M,EAAQE,YAAa,EACrBF,EAAQgN,QAIR,SAAkBC,EAASC,GACrBD,EAAQE,UAAWF,EAAQE,UAAUC,IAAIF,IAAqB,EAAIG,EAAUL,SAASC,EAASC,KAA6C,iBAAtBD,EAAQC,UAAwBD,EAAQC,UAAYD,EAAQC,UAAY,IAAMA,EAAeD,EAAQK,aAAa,SAAUL,EAAQC,WAAaD,EAAQC,UAAUK,SAAW,IAAM,IAAML,KAHrT,IAAIG,EAAYN,EAAuB,mBAAQ,kDAM/ChN,EAAOC,QAAUA,EAAiB,S;;;;;;mGCXlCA,EAAQE,YAAa,EACrBF,EAAQgN,QAER,SAAkBC,EAASC,GACzB,OAAID,EAAQE,YAAoBD,GAAaD,EAAQE,UAAUK,SAASN,IAA0H,KAAlG,KAAOD,EAAQC,UAAUK,SAAWN,EAAQC,WAAa,KAAKhH,QAAQ,IAAMgH,EAAY,MAG1LnN,EAAOC,QAAUA,EAAiB,S;;;;;;mGCPlC,SAASyN,EAAiBC,EAAWC,GACnC,OAAOD,EAAU9L,QAAQ,IAAImH,OAAO,UAAY4E,EAAgB,YAAa,KAAM,MAAM/L,QAAQ,OAAQ,KAAKA,QAAQ,aAAc,IAGtI7B,EAAOC,QAAU,SAAqBiN,EAASC,GACzCD,EAAQE,UAAWF,EAAQE,UAAUlD,OAAOiD,GAAiD,iBAAtBD,EAAQC,UAAwBD,EAAQC,UAAYO,EAAiBR,EAAQC,UAAWA,GAAgBD,EAAQK,aAAa,QAASG,EAAiBR,EAAQC,WAAaD,EAAQC,UAAUK,SAAW,GAAIL,M;;;;;;mGCL1R,IAAIH,EAAyB,qDAAQ,mEAErC/M,EAAQE,YAAa,EACrBF,EAAQgN,QAAUhN,EAAQ4N,aAAe5N,EAAQ6N,eAAiB7N,EAAQ8N,gBAAkB9N,EAAQ+N,kBAAoB/N,EAAQgO,cAAgBhO,EAAQiO,cAAgBjO,EAAQkO,mBAAqBlO,EAAQmO,gBAAkBnO,EAAQoO,iBAAmBpO,EAAQqO,mBAAqBrO,EAAQsO,eAAY,EAE3S,IAIIC,EAAQN,EAAeL,EAGvBS,EAAoBH,EAAoBE,EAAkBD,EAK1DH,EAAeD,EAAmBD,EAAiBD,EAZnDW,EAASzB,EAAuB,sBAAQ,8CAExCuB,EAAY,YAgBhB,GAfAtO,EAAQsO,UAAYA,EAEpBtO,EAAQ4N,aAAeA,EACvB5N,EAAQiO,cAAgBA,EAExBjO,EAAQmO,gBAAkBA,EAC1BnO,EAAQoO,iBAAmBA,EAC3BpO,EAAQkO,mBAAqBA,EAC7BlO,EAAQqO,mBAAqBA,EAE7BrO,EAAQ6N,eAAiBA,EACzB7N,EAAQ8N,gBAAkBA,EAC1B9N,EAAQ+N,kBAAoBA,EAC5B/N,EAAQgO,cAAgBA,EAEpBQ,EAAOxB,QAAS,CAClB,IAAIyB,EA0BN,WAoBE,IAnBA,IAgBIR,EAAeL,EAhBfc,EAAQC,SAASC,cAAc,OAAOF,MACtCG,EAAY,CACdC,EAAG,SAAWC,GACZ,MAAO,IAAMA,EAAEC,eAEjBC,IAAK,SAAaF,GAChB,OAAOA,EAAEC,eAEXE,OAAQ,SAAgBH,GACtB,MAAO,SAAWA,GAEpBI,GAAI,SAAYJ,GACd,MAAO,KAAOA,IAGdK,EAAUjO,OAAO6D,KAAK6J,GAEtBN,EAAS,GAEJhO,EAAI,EAAGA,EAAI6O,EAAQ/O,OAAQE,IAAK,CACvC,IAAI8O,EAASD,EAAQ7O,GAErB,GAAI8O,EAAS,uBAAwBX,EAAO,CAC1CH,EAAS,IAAMc,EAAOL,cACtBf,EAAgBY,EAAUQ,GAAQ,iBAClCzB,EAAeiB,EAAUQ,GAAQ,gBACjC,QAICpB,GAAiB,uBAAwBS,IAAOT,EAAgB,kBAChEL,GAAgB,kBAAmBc,IAAOd,EAAe,gBAE9D,OADAc,EAAQ,KACD,CACLd,aAAcA,EACdK,cAAeA,EACfM,OAAQA,GA/DkBe,GAE5Bf,EAASE,EAAsBF,OAC/BvO,EAAQiO,cAAgBA,EAAgBQ,EAAsBR,cAC9DjO,EAAQ4N,aAAeA,EAAea,EAAsBb,aAC5D5N,EAAQsO,UAAYA,EAAYC,EAAS,IAAMD,EAC/CtO,EAAQqO,mBAAqBA,EAAqBE,EAAS,uBAC3DvO,EAAQkO,mBAAqBA,EAAqBK,EAAS,uBAC3DvO,EAAQmO,gBAAkBA,EAAkBI,EAAS,oBACrDvO,EAAQoO,iBAAmBA,EAAmBG,EAAS,8BACvDvO,EAAQgO,cAAgBA,EAAgBO,EAAS,kBACjDvO,EAAQ+N,kBAAoBA,EAAoBQ,EAAS,sBACzDvO,EAAQ8N,gBAAkBA,EAAkBS,EAAS,mBACrDvO,EAAQ6N,eAAiBA,EAAiBU,EAAS,6BAGrD,IAAIgB,EAAW,CACbjB,UAAWA,EACXkB,IAAKvB,EACLwB,SAAUpB,EACVqB,OAAQtB,EACRuB,MAAOxB,EACPyB,SAAU1B,GAEZlO,EAAQgN,QAAUuC,G;;;;;;mGChDlBvP,EAAQE,YAAa,EACrBF,EAAQgN,aAAU,EAElB,IAAIuC,IAAgC,oBAAXM,SAA0BA,OAAOlB,WAAYkB,OAAOlB,SAASC,eAEtF5O,EAAQgN,QAAUuC,EAClBxP,EAAOC,QAAUA,EAAiB,S;;;;;;mGCNlC,IAAI+M,EAAyB,qDAAQ,mEAErC/M,EAAQE,YAAa,EACrBF,EAAQgN,aAAU,EAElB,IAKI8C,EALAtB,EAASzB,EAAuB,gBAAQ,8CAGxCgD,EAAS,eACTC,EAwBJ,SAAkBvP,GAChB,IAAIwP,GAAO,IAAIC,MAAOC,UAClBhB,EAAKiB,KAAKC,IAAI,EAAG,IAAMJ,EAAOK,IAC9BC,EAAMC,WAAW/P,EAAI0O,GAEzB,OADAmB,EAAOL,EACAM,GA1BLE,EAAS,SAAgBpB,EAAQqB,GACnC,OAAOrB,GAAWA,EAAaqB,EAAE,GAAGC,cAAgBD,EAAE/D,OAAO,GAAlC+D,GAAwC,kBAGjElC,EAAOxB,SATG,CAAC,GAAI,SAAU,MAAO,IAAK,MAU/B9K,MAAK,SAAUmN,GACrB,IAAIuB,EAASH,EAAOpB,EAAQ,WAE5B,GAAIuB,KAAUf,OAEZ,OADAE,EAASU,EAAOpB,EAAQ,UACjBW,EAAM,SAAaa,GACxB,OAAOhB,OAAOe,GAAQC,OAQ9B,IAAIP,GAAO,IAAIJ,MAAOC,WAUtBL,EAAY,SAAmBe,GAC7B,OAAOb,EAAIa,KAGHd,OAAS,SAAUe,GAC3BjB,OAAOE,IAAqC,mBAAnBF,OAAOE,IAA0BF,OAAOE,GAAQe,IAG3E,IAAIvB,EAAWO,EACf9P,EAAQgN,QAAUuC,EAClBxP,EAAOC,QAAUA,EAAiB,S;;;;;;;;;;;ACzBhCD,EAAOC,QAMA,SAAUoC,GASnB,IA0BI2O,EAAgB,SAAUnM,EAASgB,GAQtC,OALAhB,EAAUA,EAAQhD,QAAS,uBAAuB,SAAUC,GAE3D,OADAA,EAAOA,EAAKD,QAAS,cAAe,MA7BV,iBADHoP,EA+BNpL,EAAM/D,IA9BcmP,EAAiC,iBAAbA,EAAwB,GACjFA,EAAWnM,KAAKC,UAAWkM,GAFd,IAAUA,MAwCrBC,EAAe,WAClB,IAAI3K,EAAclG,UAAW,GAC5BmG,EAAU,GAAGxD,MAAMzB,KAAMlB,UAAW,GASrC,OAPAmG,EAAQ3C,SAAQ,SAAU4C,GACzB,IAAIC,EACJ,IAAMA,KAAQD,EACbF,EAAaG,GAASD,EAAQC,MAIzBH,GAMJ7B,EAAc,SAAUC,EAAME,EAASnD,GAC1C,IAAIkD,EAQJ,OANAC,EAAUF,GAASE,EAAU,KAAOmM,EAAenM,EAASnD,GAAe,KAC3EkD,EAAQ,IAAIhD,MAAOiD,IACbF,KAAOA,EAEbuM,EAActM,EAAOlD,GAEdkD,GASJuM,EAAY,SAAUC,EAAOhJ,EAAM7C,GAGhC6L,EAAM9Q,QAAU8Q,EAAOA,EAAM9Q,OAAS,GAAI8H,OAASA,EACvDgJ,EAAOA,EAAM9Q,OAAS,GAAIiF,OAASA,EAIpC6L,EAAM5N,KAAM,CAAE4E,KAAMA,EAAM7C,MAAOA,KA4D/B8L,EAAmB,SAAU9Q,GAChC,OAAOuE,KAAKC,UAAWxE,GAAM,SAAU+Q,EAAM/L,GAC5C,OAAKA,GAASA,EAAMgM,WACZhM,EAAMgM,WAEPhM,MAmBLgM,EAAa,SAAUC,EAAQ9N,EAAQnD,EAAMkR,GAChD,IAAIC,EAZsBC,EAe1B,OAFAF,EAAUA,GAAWJ,EAAkB9Q,GAbboR,EAcPH,EAAS9N,EAAS+N,GAArCC,EAbO,GAAG/Q,OAAOY,KAAMoQ,GAAK,SAAUD,EAAMlR,GAG3C,OAAc,GADdkR,GAAWA,GAAQ,GAAMA,EADflR,EAAEoR,WAAY,MAGtB,IAUW,EAAI,IAAMF,EAAO,IAAMrB,KAAKwB,IAAKH,IAgD5CtM,EAAW,SAAUT,EAAME,EAASQ,EAAO3D,GAC9C,IAAM2D,EACL,MAAMX,EAAaC,EAAME,EAASnD,IAOhC0E,EAAc,SAAU0L,GAC3B,OAAO5Q,MAAMC,QAAS2Q,GAAkBA,EAAgBA,EAAgB,CAAEA,GAAkB,IAMzFC,EAAe,SAAUtQ,EAAM8D,EAAO/C,GACzC,IAAIwP,EAGJA,EAAc5L,GAFd5D,EAAUA,GAAW,IAEcyP,MAAO9P,MAAK,SAAU+P,GACxD,OAAOA,EAAO/O,KAAM1B,MAGrB2D,EAAU,iBAAkB,0CAA2CG,GAASyM,EAAa,CAC5FvQ,KAAMA,KAeJ0Q,EAA4B,SAAU5M,EAAOzD,GAChDsD,EAAU,sBAAuB,4CACtBZ,IAAVe,EAAqB,CAAEzD,KAAMA,KAkC3BsQ,EAAwB,SAAU7M,EAAOzD,EAAMuD,EAAOI,GACzDL,EACC,qBACA,6DACAC,EACA,CACCI,SAAUA,EACV3D,KAAMA,EACNyD,MAAOA,KAQN8M,EAA8B,SAAU9M,EAAOzD,GAClDsQ,EACC7M,EACAzD,OACU0C,IAAVe,GAAwC,iBAAVA,GAAsBA,aAAiBlD,EACrE,4BAUEiQ,EAAgB,SAAUpS,GAC7B,OAAe,OAARA,GAAgB,GAAKA,GAAQ,mBAkBjCqS,EAAa,SAAUC,GAC1B,OAAOA,aAAwBnQ,EAAOmQ,EAAe,IAAInQ,EAAMmQ,IA4BhE,SAASC,EAAuBnQ,GAC/BA,EAAKgH,KAAM,MAAOyI,GAClBzP,EAAKY,IAAK,8BAYX,SAASwP,EAAWhP,GACnB,KAAQ3C,gBAAgB2R,GACvB,OAAO,IAAIA,EAAWhP,GAGvByO,EAA2BzO,EAAQ,UACnC2O,EAA6B3O,EAAQ,UAErC3C,KAAKuB,KAAOiQ,EAAY7O,GAExB+O,EAAuB1R,KAAKuB,MA4D7B,OAjDAoQ,EAAU7K,KAAO,WAGhBxF,EAAKwF,KAAK/G,MAAOuB,EAAMhC,YAcxBqS,EAAUhP,OAAS,SAAUA,GAO5B,OANA2O,EAA6B3O,EAAQ,UAEhCrD,UAAUC,SACdS,KAAKuB,KAAOiQ,EAAY7O,GACxB+O,EAAuB1R,KAAKuB,OAEtBvB,KAAKuB,MAMboQ,EAAUxL,aAAed,EACzBsM,EAAUtL,aAAe1C,EACzBgO,EAAUC,eAAiB3B,EAC3B0B,EAAUE,sBA9UiB,SAAU/N,EAASgB,GAE7C,IAAIgN,EAAa,EAChBzB,EAAQ,GAYT,OATAvM,EAAQhD,QAAS,uBAAuB,SAAUiR,EAAuBC,GACxE,IAAIjR,EAAOgR,EAAsB9P,MAAO,GAAI,GAC5CmO,EAAWC,EAAO,UAAWvM,EAAQ7B,MAAO6P,EAAYE,IACxD5B,EAAWC,EAAO,WAAYvL,EAAM/D,IACpCsP,EAAOA,EAAM9Q,OAAS,GAAIwB,KAAOA,EACjC+Q,GAAcE,EAASD,EAAsBxS,UAIvC8Q,EAAM3Q,QAAO,SAAUuS,GAC7B,MAAsB,KAAfA,EAAKzN,UA+TdmN,EAAUO,eAAiBX,EAC3BI,EAAUQ,cAAgBhC,EAC1BwB,EAAUS,WAvTM,SAAU/B,GACzB,OAAOA,EAAMgC,KAAK,SAAUJ,GAC3B,OAAOA,EAAKzN,SACV5D,KAAM,KAqTV+Q,EAAUW,WAAalC,EACvBuB,EAAUY,cA9FS,SAAUC,GAC5B,OAAOA,EAAO1R,QAAS,8BAA+B,SA8FvD6Q,EAAUc,aA/PQ,SAAUjT,EAAM+B,EAAM5B,EAAI+S,GAE3C,IAAIhC,EAAUJ,EAAkB9Q,GAC/BiR,EAnBiB,SAAU9Q,GAC5B,QAAiB8D,IAAZ9D,EAAGoB,KACP,OAAOpB,EAAGoB,KAIX,IAAI4R,EAAU,6BAA6BC,KAAMjT,EAAGY,YAEpD,OAAKoS,GAAWA,EAAQpT,OAAS,EACzBoT,EAAS,QADjB,EAWUE,CAAclT,GACvBgD,EAASpB,EAAKoB,OAIf,OAAM8N,GAIN9Q,EAAG6Q,WAAaA,EAAYC,EAAQ9N,EAAQ,KAAM+N,GAElD/Q,EAAGmT,gBAAkB,WACpB,MAAO,cAAiBnQ,EAAS,MAAS8N,EAAS,IAAMC,EAAQzO,MAAO,GAAI,GAAM,KAGnFtC,EAAG+S,YAAcA,EAEV/S,GAXCA,GAuPTgS,EAAUoB,WAzFM,SAAUnC,EAAKoC,EAAOC,GACrC,IAAI1T,EAIJ,IAHoB,iBAARqR,IACXA,EAAMsC,OAAQtC,IAETrR,EAASqR,EAAIrR,OAAQA,EAASyT,EAAOzT,GAAU,EACpDqR,EAAQqC,EAAUrC,EAAM,IAAU,IAAMA,EAEzC,OAAOA,GAkFRe,EAAUwB,UAAY9O,EACtBsN,EAAUyB,cAAgBpC,EAC1BW,EAAU0B,uBAzMkB,SAAU7O,GACrCH,EAAU,+BAAgC,4CAC/BZ,IAAVe,EAAqB,KAwMvBmN,EAAU2B,2BAA6BlC,EACvCO,EAAU4B,wBAhLmB,SAAU/O,EAAOzD,EAAMyS,EAASC,GAC5DpP,EACC,qBACA,mFACUZ,IAAVe,GAAuBA,GAASgP,GAAWhP,GAASiP,EACpD,CACCA,QAASA,EACTD,QAASA,EACTzS,KAAMA,EACNyD,MAAOA,KAwKVmN,EAAU+B,kCA1H6B,SAAUlP,EAAOzD,GACvDsQ,EACC7M,EACAzD,OACU0C,IAAVe,GAAuB+M,EAAe/M,GACtC,iBAsHFmN,EAAUgC,uBAAyBtC,EAE5BM,EAzdYiC,CAAS,eAAS,8C;;;;;;;;;;GCbpC,IAqBuBjC,EAEpBhO,EACHkQ,EACAzD,EACA0D,EACAC,EACAC,EACAhD,EACAiD,EACA7C,EACA8C,EACA7C,EACA8C,EAGGC,EASAC,EAYAC,EA4BAC,EAmEAC,EAiEAC,EAeAC,EAoIAC,EAUAC,EAyBAC,EAcAC,EAiHAC,EA0GAC,EAiBAC,EAeAC,EAYAC,EA0LAC,EAqBAC,EAsKAC,EA+BAC,EAgIAC,EA2EAC,EAwMAC,EA77CFzW,EAAOC,SAAmB,eAAS,4CAMbyS,EANyB,qBAAS,+CAQtDhO,EAAcgO,EAAUtL,aAC3BwN,EAAYlC,EAAUS,WACtBhC,EAAYuB,EAAUW,WACtBwB,EAAenC,EAAUY,cACzBwB,EAAcpC,EAAUc,aACxBuB,EAAYrC,EAAUoB,WACtB/B,EAAeW,EAAUyB,cACzBa,EAAwBtC,EAAU0B,uBAClCjC,EAA4BO,EAAU2B,2BACtCY,EAAyBvC,EAAU4B,wBACnClC,EAAwBM,EAAUgC,uBAClCQ,EAAmCxC,EAAU+B,kCAG1CU,EAAgC,SAAUuB,GAC7C,OAAOhS,EAAa,gBAAiB,yBAA0B,CAC9DgS,QAASA,KAOPtB,EAA8B,SAAU7P,EAAOzD,GAClDsQ,EACC7M,EACAzD,OACU0C,IAAVe,GAAwC,iBAAVA,EAC9B,WAOE8P,EAA8B,SAAU9P,EAAOzD,GAClDsQ,EACC7M,EACAzD,OACU0C,IAAVe,GAAwC,iBAAVA,EAC9B,aAuBE+P,EAAwB,SAAUhT,GACrC,IAAIqU,EAAKrU,EAAKZ,WAAY,QAE1B,OAAKiV,GACQ,aAAPA,IACJA,EAAK,gBAEyD,IAA1D,CAAE,SAAU,cAAe,WAAYxQ,QAASwQ,GAI7CrU,EAAK2D,KAAK,CAAE,gCAAiC0Q,IAI9CA,GAIDrU,EAAK2D,KAAM,mCAgDfsP,EAAiC,SAAUjT,GAC9C,IAAIqB,EACHgT,EAAKrB,EAAuBhT,GAE7B,GAAY,SAAPqU,EAAL,CAMA,GAAmB,aAFnBhT,EAAMrB,EAAKwJ,aAAa,CAAE,mBAAoB6K,KAErCC,MACR,MAAMzB,EAA+B,IAAMxR,EAAIiT,MAAQ,sBAGxD,OAAOjT,EAAIkT,UAmDRrB,EAAkB,uHAelBC,EAA0B,SAAUqB,GACvC,IAAIC,EAAMC,EAAMC,EAAiBC,EAAqCC,EACrEC,EAAuBC,EAA0BC,EACjDC,EAAsBC,EAA0BC,EAASjJ,EAAQkJ,EACjEC,EAAgBC,EAAoBC,EAAuBC,EAAoBC,EAGhF,KADAjB,EAAUA,EAAQrU,MAAO+S,IAExB,MAAM,IAAI5T,MAAO,oBAAsBkV,GAmDxC,GAhDAtI,EAASsI,EAAS,GAClBW,EAAUX,EAAS,GACnBI,EAAsCJ,EAAS,GAC/CgB,EAAqBhB,EAAS,GAC9Bc,EAAqBd,EAAS,IAC9BiB,EAASjB,EAAS,IAGbgB,EACJA,EAAmBjW,QAAS,YAAY,SAAUmW,EAAQC,EAA+BC,GACxFV,EAA2BS,EAA8B3X,OACzD+W,EAA2BG,EAC1BU,EAA8B5X,WAKhC2W,EAAkBH,EAAS,GAC3BK,EAAiBL,EAAS,GAErBG,GAGJA,EAAgBpV,QAAS,UAAU,SAAUY,GAC5C6U,EAAwB7U,KAEpB6U,GACJK,IAAoB,KAAOL,GAC3BA,EAAwBA,EAAsBhX,QAE9CgX,EAAwB,EAKzBF,EAAwBH,EAAgB3W,OAAS,IAEjDgX,EAAwB,EACxBF,EAAwB,GAIzBD,EAAetV,QAAS,OAAO,SAAUY,GACxC8U,EAAuB9U,EAAMnC,WAK1BsX,EACJ,MAAMzC,EAA8B,CACnCuB,QAAS,0CAKX,GAAKe,EACJ,MAAMtC,EAA8B,CACnCuB,QAAS,8BAqCX,OAhC4E,KAArEK,EAAOG,EAAoCrK,YAAa,QAK9D6K,GADAV,EAAOE,EAAoCnV,MAAO,KAAO,IAC9BzB,OAASyW,EAAO,GAG2C,KAA/EC,EAAOE,EAAoCrK,YAAa,IAAKkK,EAAO,MAC1Ec,EAAwBd,EAAO,EAAIC,IAuB9B,CACNxI,EACAiJ,EACAF,EACAD,EACAF,EACAI,EACAH,EACAM,EACAD,EACAG,EACAE,IAgBErC,EAAe,SAAU5T,EAAMQ,GAClC,OAAOA,EAAK2D,KAAK,CAChB,gCAAkCqP,EAAuBhT,GACzDR,KAOE6T,EAAmB,CACtB,IAAK,UACL,IAAK,QACL,IAAK,cACL,IAAK,WACL,IAAK,YACL,EAAK,cACL,IAAU,YAkBPC,EAAkB,SAAUtT,GAC/B,IAAI6V,EACHC,EAAY,GAEb,IAAMD,KAAUxC,EACfyC,EAAWD,GAAWzC,EAAcC,EAAkBwC,GAAU7V,GAGjE,OAAO8V,GAMJvC,EAAiB,SAAUtQ,GAC9B,OAAK8S,MAAO9S,GACJ+S,IAEDjI,KAAM9K,EAAQ,EAAI,OAAS,SAAWA,IA6G1CuQ,EAAyB,SAAUgB,EAASxU,EAAME,GACrD,IAAI+V,EAAiBC,EAAgBC,EAAoBC,EAAgBC,EACxEC,EAASC,EAlFiBvN,EAoF3B,SAASwN,EAAY3T,EAAW4T,GAC1B5T,KAAa3C,IACjBqW,EAAYE,GAAkBvW,EAAS2C,IAoFzC,OAhFA3C,EAAUA,GAAW,GAGrBmW,GAFA7B,EAAUA,EAAQ/U,MAAO,MAEE,GAE3BwW,EAAkBzB,EAAS,IAAO,IAAM6B,EAExCH,GADAC,EAAqBhD,EAAyB8C,IACT,GACrCG,EAAiBD,EAAoB,IAhGrCnN,EAAoB,cADpBA,GAD2BA,EAqGJ9I,EAAQwW,QApGZ,SACcnD,EAAiBxF,KAAM/E,IAmGxDsN,EAjGO,SAAUrT,EAAO0T,GACvB,IAAIC,EAAKC,EAKT,GAHA5T,GAASA,EAGJ8S,MAAO9S,GACX,OAAO+S,IAIR,GAA+B,iBAAnBW,GAA+BA,EAAeG,SAAW,CAIpE,GAFAD,EAAY,EAEC,IAHbD,GAAOD,EAAeG,UAIrB,OAAO9N,EAAQ/F,GAIhB,GAAuB,iBAAR2T,GAAoBA,EAAM,GAAM,EAC9C,OAAOZ,QAIF,CAGN,GAAmB,KAFnBa,GAAaF,GAAkB,GAG9B,OAAO3N,EAAQ/F,GAIhB,GAAK8S,MAAOc,GACX,OAAOb,IAIRY,IADAC,EAAYA,EAAUE,gBAAgBtX,MAAO,MAC3B,GAClBoX,GAAaA,EAAW,GAazB,OATA5T,EAAQA,EAAMjE,WAAWS,MAAO,MACzB,IAAOwD,EAAO,GAAM4T,EAC3B5T,EAAO,GAAMA,EAAO,IAASA,EAAO,GAAM2T,GAASA,GAInD3T,GAHAA,EAAQ+F,IAAW/F,EAAO,GAAM,IAAMA,EAAO,MAG/BjE,WAAWS,MAAO,MACzB,IAAOwD,EAAO,GAAM4T,EAC3B5T,EAAO,GAAMA,EAAO,IAASA,EAAO,GAAM2T,EAAQA,IACxC3T,EAAO,GAAM,IAAMA,EAAO,MA8C7BsO,gBAAkB,WACzB,MAAO,gBAAmBrR,EAAQwW,MAAQ,IAAOxW,EAAQwW,MAAQ,IAAO,IAAO,KAGhFH,EAAapD,EAAyBkD,GAAkB1V,OAAO,CAC9D0V,EACAH,EAAiBG,EAAkBD,EACnCF,EACAE,EACAE,EACAlD,EAAc,WAAYpT,GAC1BoT,EAAc,MAAOpT,GACrBsT,EAAiBtT,GACjBiT,EAAgCjT,KAG5BE,EAAQ8W,UAOZT,EAAY,GAAM,EAClBA,EAAY,GAAM,EAClBA,EAAY,GAAM,EAClBA,EAAY,GACXA,EAAY,QAAMrU,EAEnBqU,EAAY,IA1cM,SAAUU,EAAajX,GAC1C,IAAIkX,EAAc,EAEdxU,EAAS1C,EAAK2D,KAAK,CACtB,uCAAyCqP,EAAuBhT,GAChEiX,EACA,kBAcD,OAXAvU,EAAS5D,OAAO6D,KAAMD,GAASrE,QAAO,SAAU8Y,EAAWC,GAC1D,IAAIC,EAAiBD,EAAW3X,MAAO,KAAMzB,OAAS,EAClDsZ,EAAaF,EAAW3X,MAAO,KAAO,GAI1C,OAHA0X,EAAWE,GAAmBF,EAAWE,IAAoB,GAC7DF,EAAWE,GAAkBC,GAAe5U,EAAQ0U,GACpDF,EAAcnJ,KAAKC,IAAKqJ,EAAgBH,GACjCC,IACL,KAEID,YAAcA,EAEdxU,EAsba6U,CAAerX,EAAQ8W,QAAShX,IAGpDwW,EAAY,uBAAwB,GACpCA,EAAY,wBAAyB,GACrCA,EAAY,wBAAyB,GACrCA,EAAY,2BAA4B,GACxCA,EAAY,2BAA4B,IAGX,IAAxBtW,EAAQsX,cACZjB,EAAY,GAAM,MAKd,0BAA2BrW,KAAc,0BAA2BA,GAGxEqW,EAAY,GAAMxI,KAAKC,IAAKuI,EAAY,GAAKA,EAAY,MAC3C,0BAA2BrW,IACxC,0BAA2BA,IAG5BqW,EAAY,GAAMxI,KAAK0J,IAAKlB,EAAY,GAAKA,EAAY,KAenDA,GAgBJ9C,EAAY,+OAiBZC,EAAc,gJAedC,EAAY,gDAYZC,EAAgB,SAAU3Q,GAC7B,OAAOA,EACL1D,QAASkU,EAAW,IACpBlU,QAASmU,EAAa,KACtBnU,QAASoU,EAAW,MAsLnBE,EAAY,SAAUnR,EAAQtE,GACjC,OAAOU,OAAO6D,KAAMD,GAASoO,KAAI,SAAUjL,GAC1C,OAAOzH,EAAG,CAAEyH,EAAKnD,EAAQmD,QACvBxH,QAAO,SAAUqE,EAAQgV,GAE3B,OADAhV,EAAQgV,EAAM,IAAQA,EAAM,GACrBhV,IACL,KAeAoR,EAAsB,SAAU7C,GACnC,OAAKA,EAAQ,GAAMA,EAAQA,EAAOjT,OAAS,KAAQ,KAC3CiT,EAEQ,OAAXA,EACG,IAEDA,EAAO1R,QAAS,MAAO,KAAMmB,MAAO,GAAI,IA+J5CqT,EAAgB,SAAU1H,EAAOrM,GACpC,GAAe,YAAVqM,GAAiC,YAAVA,EAC3B,MAAM,IAAI/M,MAAO,iBAGlB,OAAOU,EAAK2D,KAAK,CAChB,UACA0I,EAAQ,wBAA0B2G,EAAuBhT,GACzD,cAuBEgU,EAAyB,uBAgIzBC,EAAoB,SAAU0D,EAAQC,EAAWlB,GACpD,IAAImB,EAEJ,OAAgB,IAAXF,EACGA,GAGRE,EAAa9J,KAAK+J,KAAM/J,KAAKgK,IAAKhK,KAAKwB,IAAKoI,IAAa5J,KAAKgK,IAAK,KAG5DrB,EAAOiB,EAAQ,CAAEb,SAFxBe,GAAcD,MAmEX1D,EAAe,SAAUyD,EAAQpB,EAAYyB,GAChD,IAAI3W,EAAK4W,EAAYC,EAAgBpD,EAAuBC,EAC3DC,EAAuBC,EAAsBC,EAA0BiD,EACvEC,EAAalM,EAAQkJ,EAAqBZ,EAASkC,EAAOrB,EAC1DE,EAAuB8C,EAAe5C,EAAQK,EAyG3CwC,EAA+BC,EAAmBC,EAASnB,EAAgBC,EAvF/E,OAhBArC,EAAuBsB,EAAY,GACnCvB,EAAwBuB,EAAY,GACpCzB,EAAwByB,EAAY,GACpCrB,EAA2BqB,EAAY,GACvCxB,EAA2BwB,EAAY,GACvClB,EAAiBkB,EAAY,GAC7BnB,EAAsBmB,EAAY,GAClChB,EAAwBgB,EAAY,GACpCG,EAAQH,EAAY,IACpB2B,EAAiB3B,EAAY,IAC7B4B,EAAY5B,EAAY,IACxBT,EAAYS,EAAY,IACxB6B,EAAc7B,EAAY,IAC1B0B,EAAa1B,EAAY,IAGpBR,MAAO4B,GACJ,CAAE,CAAE7R,KAAM,MAAO7C,MAAOkV,KAG3BR,EAAS,GACbnD,EAAU+B,EAAY,IACtBrK,EAASqK,EAAY,IACrBd,EAASc,EAAY,MAErB/B,EAAU+B,EAAY,IACtBrK,EAASqK,EAAY,GACrBd,EAASc,EAAY,KAwDtBrK,GApDAmM,EAAgB,SAAUpH,GACzB,IAAIwH,EAAa,UAChB3J,EAAQ,GA+CT,OA3CAmC,EAAO1R,QAAS,wBAAwB,SAAUmZ,EAAWC,GAGvDA,EACJ9J,EAAWC,EAAO,UAAWgF,EAAqB6E,IAKhC,MAAdD,GAiBLA,GAXAA,EAAYA,EAAUnZ,QAAS,mBAAmB,SAAUsW,GAO3D,MANgB,MAAXA,IACJ4C,EAAa,YAEd5J,EAAWC,EAAOuE,EAAkBwC,GAAUC,EAAWD,IAGlD,OAIctW,QAAS,SAAS,SAAUqZ,GASjD,OANKR,IACJQ,EAAQR,GAAcQ,IAEvB/J,EAAWC,EAAO2J,EAAYG,GAGvB,OAIErZ,QAAS,KAAK,SAAUsZ,GACjChK,EAAWC,EAAO,UAAW+J,MA9B7BhK,EAAWC,EAAO,WAAY4J,MAiCzB5J,IAGgB5C,GACxBuJ,EAAS4C,EAAe5C,GAGlBqD,SAAUnB,KAQiB,IAA5BnD,EAAQ3Q,QAAS,KACrB8T,GAAU,KAGkC,IAAjCnD,EAAQ3Q,QAAS,OAC5B8T,GAAU,KAMNM,IACJZ,EAAiBtJ,KAAKwB,IAAKxB,KAAKgL,MAAOpB,IAAW3Y,WAAWhB,OAAS,GACtEqZ,EAAiBtJ,KAAK0J,IAAKJ,EAAgBY,EAAWf,eAG/B,IACtBoB,EAAiBL,EAAYZ,IAAoBY,EAAYZ,GAAiB2B,OAGvD,MAAnBV,EACJA,EAAiB,KACNA,IAEXE,EAAUnB,GADMiB,EAAe7Y,MAAO,KAAMzB,OAAS,EACR,GAC7C2Z,GAAkB5J,KAAKkL,IAAK,GAAIT,KAWjCb,EANK5B,MAAOb,EAA2BH,GAjRD,SAAU4C,EAAQ1C,EAAsBD,EAAuBF,EAAuB4B,EAC7HrB,GAiDA,OA1CEsC,EAJG7C,EAIM4B,EAAOiB,EADZtC,GAKoB,CAAEyB,UAAWhC,IAI7B4B,EAAOiB,GAGjBA,EAAShG,OAAQgG,GAGZ7C,GAAyB,KAAKjU,KAAM8W,KASxCA,IAAYA,GAASuB,QAASpE,GAC5BvV,QAAS,MAAO,IAChBA,QAAS,MAAO,KAIdyV,KACJ2C,EAASA,EAAOlY,MAAO,MACf,GAAMgT,EAAWkF,EAAQ,IAAO,GAAI3C,GAAuB,GACnE2C,EAASA,EAAOtY,KAAM,MAIlB4V,KACJ0C,EAASA,EAAOlY,MAAO,MACf,GAAMgT,EAAWkF,EAAQ,GAAK1C,GACtC0C,EAASA,EAAOtY,KAAM,MAGhBsY,EAqOGwB,CAAmCxB,EAAQ1C,EACnDD,EAAuBF,EAAuB4B,EAAOrB,GAxLpB,SAAUsC,EAAQzC,EAA0BH,EAA0B2B,GACzG,IAAI0C,EAAWC,EAgBf,GAbKnE,EAA2BH,IAC/BA,EAA2BG,GAU5ByC,KAHAA,IAJAyB,EAAYnF,EAAmB0D,EAAQzC,EAA0BwB,OACjE2C,EAAYpF,EAAmB0D,EAAQ5C,EAA0B2B,IAG5B0C,EAAYC,IAG5Bra,SAAU,IAE1B,IAAQ6B,KAAM8W,GAClB,MAAM9E,EAA8B,CACnCuB,QAAS,iCAWX,OANKc,EAA2ByC,EAAOpY,QAAS,UAAW,IAAKvB,OAAS,KACxE2Z,EAASA,EAAOlY,MAAO,MACf,GAAMgT,EAAWkF,EAAQ,IAAO,GAAIzC,EAA2ByC,EAAQ,GAAIpY,QAAS,MAAO,IAAKvB,QAAQ,GAChH2Z,EAASA,EAAOtY,KAAM,MAGhBsY,EAoJG2B,CAA+B3B,EAAQzC,EAC/CH,EAA0B2B,GASvBuB,GAAcK,IAGlBhB,EAAaU,EAAkBA,GAAkBL,GAAW,QAG5DY,GADAD,EAAiBL,EAAYZ,GAAkBC,IAAgBgB,GAC5BnY,MAAO6T,GAI1C3S,EAAM,SAAU4P,GACf,IAAInC,EAAQ,GAeZ,OAdAmC,EAAO1R,QAAS,oBAAoB,SAAUga,EAAUC,EAAOxC,GAGzDwC,EACJ3K,EAAWC,EAAO,UAAW0K,GAKzBxC,GACJnI,EAAWC,EAAO,UAAWkI,MAIxBlI,GAIR5C,EAASA,EAAOvL,OAAQU,EAAKkX,EAAmB,KAChD9C,EAASpU,EAAKkX,EAAmB,IAAM5X,OAAQ8U,IAIhDkC,EAASA,EAAOpY,QAAS,KAAM,IAG1B6V,IACJuC,EAhXkC,SAAUA,EAAQvC,EAAqBG,GAC1E,IAAIhO,EACHkS,EAAsBrE,EACtBsE,EAAM,GAENC,IAAoBpE,EAKrB,IAFAhO,GADAoQ,EAAShG,OAAQgG,GAASlY,MAAO,MACjB,GAAIzB,OAEZuJ,EAAQkS,GACfC,EAAM/B,EAAQ,GAAIjX,MAAO6G,EAAQkS,EAAqBlS,IACnDmS,EAAI1b,OARD,IAQgB,IAAO0b,EAC7BnS,GAASkS,EACJE,IACJF,EAAsBlE,EACtBoE,GAAoB,GAKtB,OADAhC,EAAQ,GAAMA,EAAQ,GAAIjX,MAAO,EAAG6G,IAAYmS,EAAI1b,OAhB7C,IAgB4D,IAAO0b,EACnE/B,EAAOtY,KAAM,KA2VVua,CAA+BjC,EAAQvC,EAC/CG,IASKrJ,EAAOvL,OACb0X,EAAeV,GACflC,IAnGOvJ,EAAOvL,OACb,CAAEmF,KAAM,WAAY7C,MAAOiV,GAC3BzC,KAwGCtB,EAA2B,SAAUoC,EAAYyB,GACpD,OAAO,SAAiC/U,GAIvC,OAHA4M,EAA2B5M,EAAO,SAClC6P,EAA6B7P,EAAO,SAE7BiR,EAAcjR,EAAOsT,EAAYyB,KA2C1C5H,EAAUyJ,gBACVzJ,EAAUrR,UAAU8a,gBAAkB,SAAU3Z,GAC/C,IAAIjC,EAAM6b,EAAwBC,EAWlC,OATAnH,EAAkC1S,EAAS,WAG3CjC,EAAO,CADPiC,EAAUA,GAAW,IAIrB6Z,EAh8CuB,SAAUD,GACjC,OAAO,SAA0B7W,GAChC,OAAOqP,EAAWwH,EAAwB7W,KA87ChC+W,CADXF,EAAyBrb,KAAKqb,uBAAwB5Z,IAEtDsS,EAAavU,EAAMQ,KAAKuB,KAAM+Z,EAAU,CAAED,IAEnCC,GAaR3J,EAAU0J,uBACV1J,EAAUrR,UAAU+a,uBAAyB,SAAU5Z,GACtD,IAAIjC,EAAM+B,EAAMia,EAAQzF,EAAS+B,EAAYwD,EAE7CnH,EAAkC1S,EAAS,WAE3CA,EAAUA,GAAW,GACrBF,EAAOvB,KAAKuB,KAEZ/B,EAAO,CAAEiC,GAETwS,EAAuB1S,GAEvBA,EAAKiH,GAAI,MAAOwI,GAChB,IAEE+E,EADItU,EAAQga,IACFha,EAAQga,IAERnG,EAAe7T,EAAQmM,OAAS,UAAWrM,GAItDia,EAAS,CADT1D,EAAa/C,EAAwBgB,EAASxU,EAAME,IAEnD,QACDF,EAAKwH,IAAK,MAAOiI,GAWlB,OAjGD,SAAyB8G,GACxB,IAAItB,EAAuBsB,EAAY,GACtCvB,EAAwBuB,EAAY,GACpCzB,EAAwByB,EAAY,GACpCrB,EAA2BqB,EAAY,GACvCxB,EAA2BwB,EAAY,GAGxC,GAAMR,MAAOb,EAA2BH,GAKjC,KAAMgB,MAAOb,KAA+Ba,MAAOhB,GACzD,MAAM,IAAIzV,MAAO,8EAKjBqT,EAAwBsC,EAAsB,uBAAwB,EAAG,IACzEtC,EAAwBqC,EAAuB,wBAAyB,EAAG,IAC3ErC,EAAwBmC,EAAuB,wBAC9CE,EAAuB,SAbxBrC,EAAwBuC,EAA0B,2BAA4B,EAAG,IACjFvC,EAAwBoC,EAA0B,2BACjDG,EAA0B,IA8E5BiF,CAAgB5D,GAEXrW,EAAQ8W,SACZiD,EAAO/Y,KAAMzC,KAAKuZ,mBAEnB+B,EAAW5F,EAAyB3V,MAAO,KAAMyb,GACjDzH,EAAavU,EAAM+B,EAAM+Z,EAAUE,GAE5BF,GAWR3J,EAAUgK,aACVhK,EAAUrR,UAAUqb,aAAe,SAAUla,GAC5C,IAAIjC,EAAM+B,EAAeuW,EAAYwD,EAUrC,GARAnH,EAAkC1S,EAAS,WAE3CA,EAAUA,GAAW,GACrBF,EAAOvB,KAAKuB,KAEZ/B,EAAO,CAAEiC,GAETwS,EAAuB1S,GAClBE,EAAQ8W,QACZ,MAAMnE,EAA8B,CACnCuB,QAAS,6CAoBX,OAhBApU,EAAKiH,GAAI,MAAOwI,GAQhB8G,EAhtB2B,SAAU/B,EAASxU,EAAME,GACpD,IAAImB,EAAKgZ,EAAiBC,EAAUC,EAAqBrC,EAAgBsC,EACxEC,EAAmB3F,EAAuBC,EAC1CG,EAA0BiD,EAAWjC,EAAgBE,EAAgBgC,EACrEsC,EAAiBxO,EAAQkJ,EAAqBG,EAAuBE,EAAQK,EAC7E6E,EAAmBnH,EAAwBgB,EAASxU,EAAME,GA6G3D,OA3GAgM,EAAS0H,EAAe+G,EAAkB,IAC1C7F,EAAwB6F,EAAkB,GAC1CzF,EAA2ByF,EAAkB,GAC7C5F,EAA2B4F,EAAkB,GAC7CvF,EAAsBuF,EAAkB,GACxCpF,EAAwBoF,EAAkB,GAC1ClF,EAAS7B,EAAe+G,EAAkB,KAC1CzE,EAAiBtC,EAAe+G,EAAkB,KAClDvE,EAAiBxC,EAAe+G,EAAkB,KAClDzC,EAAiBtE,EAAe+G,EAAkB,KAClDxC,EAAYvE,EAAe+G,EAAkB,KAC7C7E,EAAYjC,EAAW8G,EAAkB,KAAM,SAAUjD,GACxD,MAAO,CAAEA,EAAM,GAAK9D,EAAe8D,EAAM,QAE1CU,EAAcuC,EAAkB,IAEhCF,EAAoB5G,EA3FS,SAAU7T,GACvC,IAAI6V,EACHC,EAAY,GAEb,IAAMD,KAAUxC,EACfyC,EAAW1C,EAAcC,EAAkBwC,GAAU7V,IAAW6V,EAGjE,OAAOC,EAmFwB8E,CAAyB5a,IAAQ,SAAU0X,GACzE,MAAO,CAAE9D,EAAe8D,EAAM,IAAOA,EAAM,OAG5C4C,EAAWlC,EAAc,IAAMA,EAAc,IAAM,MACnDmC,EAAsBhI,EAAcuD,EAAW,MAC/CuE,EAAkB9H,EAAcuD,EAAW,MAEtCsC,IACJoC,EAAsBpC,EAAY3Y,MAAO,IAAKpB,QAAO,SAAUqE,EAAQmY,EAAgB3c,GAEtF,OADAwE,EAAQmY,GAAmBlJ,OAAQzT,GAC5BwE,IACL,KAGJrB,EAAM,CAAE6K,EAAQuJ,EAAQS,EAAgBE,GAAiBtF,KAAI,SAAU7N,GACtE,OAAOA,EAAM1D,QAAS,wBAAwB,SAAUmZ,EAAWC,GAGlE,OAAKA,EACG7E,EAAqB6E,GAI7BD,EAAYA,EAAUnZ,QAAS,iBAAiB,SAAUsW,GACzD,OAAOC,EAAWD,YAOrB3J,EAAS7K,EAAK,GACdoU,EAASpU,EAAK,GACd6U,EAAiB7U,EAAK,GACtB+U,EAAiB/U,EAAK,GAoBtBqZ,EAAkBJ,EAAW,IAGxBlF,IASJsF,EAAkB,KAPjBrZ,EADIkU,EACE+E,EAAW,MAAQ/E,EAAwB,MAAQgF,EACxDD,EAAW,IAAM/E,EAAwB,OAASgF,EAClDD,EAAW,IAAMlF,EAAsB,MAElCkF,EAAW,MAAQlF,EAAsB,KAAOmF,EACrDD,EAAW,IAAMlF,EAAsB,OAEX,IAAMsF,EAAkB,KAMjD3E,MAAOb,EAA2BH,KACrCD,IAUF4F,EAAkB,KANlBA,EAAkBA,EAAkB,KADpCrZ,EAAMgZ,EAAkBC,EAAW,KACa,IAAMD,EAApCK,OAIVA,EAAkB,KAAOrZ,GAES,KAOpC,CACNoZ,EACAD,EACA,CACCM,SAAU,IAAIpU,OAAQ,IAAM6L,EAAc2F,IAC1C6C,IAAK,IAAIrU,OAAQ,IAAM6L,EAAc4F,IACrCjC,eAAgB,IAAIxP,OAAQ,IAAM6L,EAAc2D,IAChDE,eAAgB,IAAI1P,OAAQ,IAAM6L,EAAc6D,IAChDuB,OAAQ,IAAIjR,OAAQ,IAAMgU,GAC1BxO,OAAQ,IAAIxF,OAAQ,IAAM6L,EAAcrG,IACxCuJ,OAAQ,IAAI/O,OAAQ,IAAM6L,EAAckD,MAolB7BuF,CANR9a,EAAQga,IACFha,EAAQga,IAERnG,EAAe7T,EAAQmM,OAAS,UAAWrM,GAGTA,EAAME,GAEnDF,EAAKwH,IAAK,MAAOiI,GAEjBsK,EAjzBoB,SAAUxD,GAC9B,OAAO,SAAuBtT,GAI7B,OAHA4M,EAA2B5M,EAAO,SAClC8P,EAA6B9P,EAAO,SA1HpB,SAAUA,EAAOsT,GAClC,IAAI0E,EAAST,EAAqBC,EAAmBS,EAAUvD,EAAQzL,EAAQiP,EAC9E1F,EAAQ2F,EA2FT,OApFAH,EAAU,CACT,CAAE,OACF,CAAE,SAAU,WAAY,UACxB,CAAE,SAAU,SAAU,UACtB,CAAE,iBAAkB,WAAY,kBAChC,CAAE,iBAAkB,SAAU,mBAG/BR,EAAoBlE,EAAY,GAChCiE,EAAsBjE,EAAY,IAAO,GACzC6E,EAAY7E,EAAY,IAqDxB,SAAyB8E,EAAQJ,GAChC,OAAOA,EAAQpb,MAAK,SAAUyb,GAC7B,IAAIrY,EAAQoY,EAIZ,OAAOC,EAAUC,OAAM,SAAUzV,GAChC,OAA0C,OAArC7C,EAAM9C,MAAOib,EAAWtV,MAK7B7C,EAAQA,EAAM1D,QAAS6b,EAAWtV,GA7DrC,SAAgBA,GACf,OAAO,SAAU0V,GAShB,OANAA,EAASA,EAAO/b,MAAO,IAAKqR,KAAI,SAAU4H,GACzC,OAAO+B,EAAmB/B,IACzB8B,EAAqB9B,IACrBA,KACCrZ,KAAM,IAEAyG,GACR,IAAK,WACJ6R,EAAS8D,IACT,MAED,IAAK,MACJ9D,EAAS3B,IACT,MAED,IAAK,SAGJwF,EAASA,EAAOjc,QAAS,KAAM,IAE/BoY,GAAU6D,EACV,MAED,IAAK,SACL,IAAK,iBACJtP,EAASsP,EACT,MAED,IAAK,SACJ/F,EAAS+F,EACT,MAED,IAAK,iBACJ/F,EAAS+F,EACTN,GAAW,EACX,MAGD,QACC,MAAM,IAAI5b,MAAO,kBAEnB,MAAO,IAgBoCoc,CAAO5V,KAC1C,QACD7C,EAAMjF,UAIP2d,CArER1Y,EAAQ2Q,EAAe3Q,GAqEQgY,IAGhBlF,MAAO4B,GACd3B,MAM+B,KAHvCmF,EAAgB,GAAKjP,EAASuJ,GAGX5R,QAAS,KAC3B8T,GAAU,KAGwC,IAAvCwD,EAActX,QAAS,OAClC8T,GAAU,KAINuD,IACJvD,IAAW,GAGLA,GAWCiE,CAAa3Y,EAAOsT,IA4yBjBsF,CAAgBtF,GAE3B/D,EAAavU,EAAM+B,EAAM+Z,EAAU,CAAExD,IAE9BwD,GAYR3J,EAAU0L,aACV1L,EAAUrR,UAAU+c,aAAe,SAAU7Y,EAAO/C,GAInD,OAHA2P,EAA2B5M,EAAO,SAClC6P,EAA6B7P,EAAO,SAE7BxE,KAAKob,gBAAiB3Z,EAAtBzB,CAAiCwE,IAYzCmN,EAAU2L,oBACV3L,EAAUrR,UAAUgd,oBAAsB,SAAU9Y,EAAO/C,GAI1D,OAHA2P,EAA2B5M,EAAO,SAClC6P,EAA6B7P,EAAO,SAE7BxE,KAAKqb,uBAAwB5Z,EAA7BzB,CAAwCwE,IAYhDmN,EAAU4L,YACV5L,EAAUrR,UAAUid,YAAc,SAAU/Y,EAAO/C,GAIlD,OAHA2P,EAA2B5M,EAAO,SAClC8P,EAA6B9P,EAAO,SAE7BxE,KAAK2b,aAAcla,EAAnBzB,CAA8BwE,IAMtCmN,EAAU6L,+BAAiCpJ,EAC3CzC,EAAU8L,uBAAyBlJ,EACnC5C,EAAU+L,gCAAkClJ,EAC5C7C,EAAUgM,eAAiBrI,EAC3B3D,EAAUiM,cAAgBjJ,EAC1BhD,EAAUkM,eAAiB1I,EAC3BxD,EAAUmM,qBAAuBzI,EACjC1D,EAAUoB,WAAaiB,EACvBrC,EAAUoM,6BAA+B1J,EACzC1C,EAAUqM,6BAA+B1J,EAElC3C,I;;;;;;mGCvrDP,IAAIsM,EAAY,0BAAQ,gEAGpBtM,EAAY,iCAAQ,+CAGxB,wCAAQ,sDAER,IAAIuM,EAAQ,sBAAQ,4DAChBC,EAAe,sBAAQ,0CAEvBC,EAASH,EAAUG,OACnBC,EAAiBJ,EAAUI,eAC3BC,EAAcL,EAAUK,YACxBC,EAAaN,EAAUM,WACvBC,EAAoBN,EAAMM,kBAG1BC,EAAgB,8BAAQ,oEACxBC,EAA4BD,EAAcC,0BAC1CC,EAA4BF,EAAcE,0BAC1CC,EAAoBH,EAAcG,kBAWtC,IAAIC,EAAgB,aAEhBC,EAAmB,CACrBzO,MAAO,WAEL,OADArQ,KAAK+e,WAAa,QACX/e,MAETgf,gBAAiB,SAASA,GAExB,OADAhf,KAAKgf,gBAAkBA,EAChBhf,OAIXK,OAAO4e,eAAeJ,EAAcve,UAAW,gBAAiB,CAC9D6B,IAAK,WACH,MAAO,CACLyL,MAAO,UACPyI,sBAAuB,EACvBE,sBAAuB,IAG3B2I,YAAY,IAEd,IAAIC,EAAgBN,EAAcve,UAAU6e,cAE5C9e,OAAO4e,eAAeJ,EAAcve,UAAW,wBAAyB,CACtE6B,IAAK,WACH,MAAO,CACLyL,MAAO,UACPyI,sBAAuB,EACvBE,sBAAuB,IAG3B2I,YAAY,IAId,IAAIE,EAAmB,CACrBC,gBAAiB,SACjBC,4BAA6B,OAC7BC,kCAAmC,iBAErClf,OAAO6D,KAAKkb,GAAkBtc,SAAQ,SAAS0c,GAC7Cnf,OAAO4e,eAAeJ,EAAcve,UAAWkf,EAAY,CACzDrd,IAAK,WACH,IAAIsd,EAAcL,EAAiBI,GACnC,OAAOnf,OAAOqf,OAAOZ,GAAkBE,gBAAgBS,IAEzDP,YAAY,OAIhB,IAAIS,EAAyBtf,OAAO6D,KAAKkb,GAAkB/M,KAAI,SAC7DmN,GAEA,OAAOJ,EAAiBI,MA0C1B,SAASI,EAAkBC,EAASC,GAClC,IAAIC,EAAeF,EAAQG,SAASC,eAAeH,GACnD,OAAOC,GAAgBA,EAAa3I,OAGtC,SAAS8I,EAAeL,EAASM,GAC/B,IAAIC,EAAoB,GAexB,MAdoB,CAChB,gBACA,OACA,SACA,YACA,UAEYtd,SAAQ,SAAS8K,GAC/BwS,EAAkBxS,GAStB,SAAgCiS,EAASpe,EAAS0e,GAChD,IACED,EADaL,EAAQG,SACKE,eAC1BG,GAA2B,EAExB5e,IACHA,EAAU,CAAEud,gBAAiB,WAG/B,IAAIpR,EAAQnM,EAAQud,gBAChBjJ,EAAUmK,EAAetS,GAI3BsS,EAAeI,mBACfJ,EAAeI,kBAAkBH,IACjCD,EAAeI,kBAAkBH,GAAUvS,KAE3CmI,EAAUmK,EAAeI,kBAAkBH,GAAUvS,GACrDyS,GAA2B,GAO7B,IAAKA,GAAsC,kBAAVzS,GAA6BuS,EAAU,CACtE,IAAII,EAAiBX,EAAkBC,EAASM,GAChD,IAAKI,EACH,OAEF,GAAIA,EAAehhB,OAAS,GAkBhC,SAAoBihB,EAASC,GAC3B,GAAID,IAAYC,EACd,OAAO,IAKP,IAHA,IAAIC,EAASF,EAAQxf,MAAM,IACzB2f,EAASF,EAAQzf,MAAM,IACvB4f,EAAc,EACPnhB,EAAI,EAAGA,EAAIihB,EAAOnhB,OAAQE,IACjC,IAAmC,IAA/BkhB,EAAOvb,QAAQsb,EAAOjhB,IAAY,CACpC,IAAIohB,EAAWF,EAAOvb,QAAQsb,EAAOjhB,IACrCkhB,EAAOjd,OAAOmd,EAAU,GACxBD,IAIJ,OAAgB,KADHA,EAAcF,EAAOnhB,SA9BpBuhB,CAAWX,EAAUI,IACpB,KACXxK,EAAUA,EAAQjV,QAAQ,QAAS,KAKzC,OAAOiV,EAjDsBgL,CACzBlB,EACA,CAAEb,gBAAiBpR,GACnBuS,MAGGC,EAzDT/f,OAAO4e,eAAeJ,EAAcve,UAAW,eAAgB,CAC7DkE,MAAO,SAAsB0U,EAAQzX,GAUnC,OATAA,EAAU+c,EAAkB/c,EAAS0d,GACrCjG,EAASwF,EAA0BxF,EAAQ,UAC3CqF,EAAW9c,EAAS,UAAW,CAAC,iBAChC2c,OAC8B3a,IAA5BhC,EAAQud,gBACR,iFAEFvd,EAAU0c,EAAa,GAAI1c,GAC3Bmd,EAAkBnd,GACXzB,KAAKghB,UAAU3D,aAAanE,EAAQzX,IAE7Cyd,YAAY,IAMd7e,OAAO4e,eAAeJ,EAAcve,UAAW,kBAAmB,CAChEkE,MAAO,SAAyB0U,EAAQzX,GAItC,OAHAA,EAAU+c,EAAkB/c,EAAS0d,GACrCR,EAA0BzF,EAAQ,UAClCqF,EAAW9c,EAAS,UAAW,CAAC,iBACV,iBAAXyX,EACFA,EAEFlZ,KAAKghB,UAAUzD,YAAYrE,EAAQzX,IAE5Cyd,YAAY,IA0Gd7e,OAAO4e,eAAeJ,EAAcve,UAAW,iBAAkB,CAC/DkE,MAAO,SAAwB2b,EAAU1e,GACvC,IAAIqe,EAAcmB,EA/MWpB,EAASqB,EAgNtCzf,EAAU+c,EAAkB/c,EAASzB,KAAKqf,iBAE1Cd,EAAW4B,EAAU,WAAY,CAAC,iBAClC5B,EAAW4B,EAASA,SAAU,oBAAqB,CAAC,WACpDc,EAAgBvC,EAA0ByB,EAAS3b,MAAO,kBApN7Bqb,EAqNL7f,KArNckhB,EAqNRf,EAASA,SApNzC7B,EACE4C,EACArB,EAAQG,SAASC,eACjB,wDACA,CAAEkB,eAAgBD,IAkNlB3C,EAAW9c,EAAS,UAAW,CAAC,iBAChC8c,EAAW9c,EAAQud,gBAAiB,0BAA2B,CAAC,WAChEV,EACE7c,EAAQud,gBACRW,EACA,0DACA,CAAEwB,eAAgB1f,EAAQud,kBAG5Bc,EAAeK,EAASA,SACxB1e,EAAU0c,EAAa,GAAI1c,GAC3B,IAAI2f,EA5BR,SAA2BvB,EAASC,GAClC,OACED,EAAQG,SAASqB,aAAavB,IAC9BD,EAAQG,SAASqB,aAAavB,GAAcwB,OAyBvBC,CAAkBvhB,KAAM8f,GAC7ClB,EAAkBnd,EAAS2f,GAE3B,IAAII,EA/HR,SAAsB3B,GACpB,OAAOA,EAAQG,SAASyB,YAAY,6BA8HTC,CAAa1hB,MACpC2hB,EAAuBzB,EAAelgB,KAAM8f,GAC5C1I,EAASwI,EAAkB5f,KAAM8f,GACjC8B,EAAoB,GACpB7L,EAAU4L,EAAqBlgB,EAAQud,iBAAiBhe,MAAM,KAAK,GAC1C,UAAvBS,EAAQsd,aACV6C,EAAoB,IAGtB,IAAIC,EAAe,SAASza,EAAK5C,GAC/B,GAA2B,UAAvB/C,EAAQsd,WAAwB,CAClC,IAAI1O,EAAQ,CAAEhJ,KAAMD,EAAK5C,MAAOA,GAChCod,EAAkBnf,KAAK4N,QAEvBuR,GAAqBpd,GAIrByc,EAAgB,IAClBlL,EAAU4L,EAAqBlgB,EAAQud,iBAAiBhe,MAAM,KAAK,GACnEigB,IAAiC,GAEnC,IAAIa,EAAgBjD,EAAcve,UAAU6e,cAC5C2C,EAAczL,sBAAwB5U,EAAQ4U,sBAC9CyL,EAAcvL,sBAAwB9U,EAAQ8U,sBAY9C,IAXA,IAAIwL,EAAkB,CACpB,IAAK,CAAE3a,IAAK,OAAQ5C,MAAOgd,EAAmBQ,WAC9C,IAAK,CAAE5a,IAAK,SAAU5C,MAAO4S,GAC7B,IAAK,CACHhQ,IAAK,QACL5C,MAAOxE,KAAKqd,aAAa4D,EAAea,IAE1CG,EAAG,CAAE7a,IAAK,OAAQ5C,MAAOsb,GACzB,IAAU,CAAE1Y,IAAK,YAAa5C,MAAOmd,EAAqBO,YAGnDziB,EAAI,EAAGA,EAAIsW,EAAQxW,OAAQE,IAAK,CACvC,IAAIwS,EAAO8P,EAAgBhM,EAAQoM,OAAO1iB,KAAO,CAC/C2H,IAAK,UACL5C,MAAOuR,EAAQoM,OAAO1iB,IAExBoiB,EAAa5P,EAAK7K,IAAK6K,EAAKzN,OAG9B,OAAOod,GAET1C,YAAY,IA6BdjgB,EAAOC,QAAU,CAEfkjB,cAAe,SAAuBpC,IA5BxC,SAA0BA,GACxBzB,EAAWyB,EAAU,WAAY,CAAC,iBAClC3B,EAAe2B,EAASze,MACxB8c,EAAe2B,EAASze,KAAK2D,MAC7BmZ,EAAe2B,EAASze,KAAKwJ,cAC7BsT,EAAe2B,EAASqC,SACxBhE,EAAe2B,EAASqC,QAAQnJ,QAEhC,IAAIoJ,EAAoBtC,EAASqC,QAAQnJ,OACzCmF,EAAeiE,EAAkBC,QAAS,CAAC,WAC3ClE,EAAeiE,EAAkBjB,cACjChD,EAAeiE,EAAkBpC,gBAGjC,IAAIsC,EAAaniB,OAAO6D,KAAK8b,EAASze,KAAK2D,MAAM,GACjDmZ,EAAemE,EAAY,CAAC,WAC5B,IAAIC,EAAWzC,EAASze,KAAK2D,KAAKsd,GAClCnE,EAAeoE,GACf,IAAIhB,EAAcgB,EAASC,QAC3BrE,EAAeoD,GACfpD,EAAeoD,EAAY,8BAC3B,IAAIxB,EAAiBwB,EAAYkB,WACjCtE,EAAe4B,GAQb2C,CAAiB5C,GAEjB,IAAIH,EAAU,IAAIhB,EAGd2D,EAAaniB,OAAO6D,KAAK8b,EAASze,KAAK2D,MAAM,GAE7Cuc,EADWzB,EAASze,KAAK2D,KAAKsd,GACPE,QACvBzC,EAAiBwB,EAAYkB,WAE7BL,EAAoBtC,EAASqC,QAAQnJ,OAezC,OAZA2G,EAAQG,SAAW,CACjBuC,QAASD,EAAkBC,QAC3BrC,eAAgBoC,EAAkBpC,eAClCmB,aAAciB,EAAkBjB,aAChCI,YAAaA,EACbxB,eAAgBA,GAIlBtO,EAAU7K,KAAKkZ,EAASze,MACxBse,EAAQmB,UAAYrP,EAAU6Q,GAEvB3C,K;;;;;;mGCnVX,IAAI3B,EAAQ,gBAAQ,4DAChBC,EAAe,sBAAQ,0CAEvBlO,EAAgBiO,EAAMjO,cACtB4S,EAAa3E,EAAM2E,WACnBC,EAAgB5E,EAAM4E,cACtBC,EAAc7E,EAAM6E,YA0BxB,SAAS3E,EAAO4E,EAAWC,EAAcxhB,GACvC,IAAIoC,EAEJ,GAAImf,EACF,OAAO,EAWT,MAHAnf,EAAQ,KALRpC,EAAUA,GAAW,IAEAyhB,YAAcriB,OAEnCoiB,EAAehT,EAAcgT,EAAcxhB,KAErCd,WAAac,EAEboC,EAyCR,SAAS0a,EAAW4C,EAAgBgC,EAAeC,EAAe3hB,GAChE,IAAI4hB,EAAgBP,EAAc3B,GASlC/C,GAPA3c,EAAUA,GAAW,IAEXuhB,YAAuD,IAA1CI,EAAche,QAAQie,GAE3C5hB,EAAQwhB,cACR,yGAE8B,CAC9BC,WAAYI,UACZC,qBAAsBV,EAAWO,EAAe,MAChDD,cAAeA,EACfE,cAAeA,EACflC,eAAgBA,IA2BpBliB,EAAOC,QAAU,CACfkf,OAAQA,EACRC,eA/EF,SAAwBmF,EAAcJ,GAEpC7E,EAAWiF,EAAc,GADzBJ,EAAgBA,GAAiB,CAAC,gBACU,CAC1CH,aAAc,6BA6EhB3E,YAXF,SAAqBnS,EAASsX,EAAYR,EAAcxhB,GACtD2c,EACE2E,EAAY5W,EAASsX,GACrBR,EACA9E,EAAa,CAAE+E,WAAYQ,YAAcjiB,KAQ3C8c,WAAYA,I;;;;;;mGCzId,SAASoF,EAAUxkB,EAAKuB,GACF,iBAATA,IACTA,EAAOA,EAAKM,MAAM,MAEpB,IAAI2E,EAAOjF,EAAKuB,OAAO,GAIvB,OAHWvB,EAAKuB,MAAM,GAAI,GAAGrC,QAAO,SAASmF,EAAM6e,GACjD,OAAO7e,EAAK6e,IAAS,KACpBzkB,GACSwG,GAYd,SAASke,EAAU1kB,EAAKuB,EAAM8D,GACR,iBAAT9D,IACTA,EAAOA,EAAKM,MAAM,MAEpB,IAAI2E,EAAOjF,EAAKuB,OAAO,GAKvB,OAJWvB,EAAKuB,MAAM,GAAI,GAAGrC,QAAO,SAASmF,EAAM6e,GACjD,OAAQ7e,EAAK6e,GAAQ7e,EAAK6e,IAAS,KAClCzkB,GACEwG,GAAQnB,EACNrF,EAOT,SAAS2kB,EAAa7f,GACpB,OAAO5D,OAAO6D,KAAKD,GAAQoO,KAAI,SAASjL,GACtC,OAAOnD,EAAOmD,MAYlB,SAAS2c,EAAW7iB,GAClB,OAAOA,EAAMe,MAAM,GAGrB,SAAS+hB,EAAUC,GACjB,OAAO,IAAI7U,KAAK6U,EAAK5U,WAsHvB,SAASkC,EAActN,GAErB,OACa,OAAXA,GACA,GAAKA,GAAW,mBAChBA,EAAOigB,cAAgB7jB,OA4J3B,SAAS8jB,EAAgBvT,EAAKwT,GAG5BA,EAAMA,GAAO,EACb,IACIC,EAAIC,EADJ1gB,EAAOgN,EAAIC,WAAWuT,GAM1B,OAAI,OAAUxgB,GAAQA,GAAQ,OAC5BygB,EAAKzgB,EACL0gB,EAAM1T,EAAIC,WAAWuT,EAAM,GACvB9M,MAAMgN,GACDD,EAEc,MAAfA,EAAK,QAAmBC,EAAM,OAAU,SAE9C,OAAU1gB,GAAQA,GAAQ,QAWvBA,EAmBT3E,EAAOC,QAAU,CACfykB,UAAWA,EACXE,UAAWA,EACXC,aAAcA,EACdS,YArVF,SAAqBplB,EAAKuB,GAExB,OAAOmjB,EAAU,GADjBnjB,EAAOA,GAAQ,GACYijB,EAAUxkB,EAAKuB,KAoV1C8jB,cA7TF,SAASA,IACP,IAAIhf,EAAc,GACdC,EAAU,GAAGxD,MAAMzB,KAAKlB,UAAW,GAmBvC,OAlBAmG,EAAQ3C,SAAQ,SAAS4C,GACvB,IAAIC,EACJ,IAAKA,KAAQD,EACPvF,MAAMC,QAAQsF,EAAOC,IAEvBH,EAAYG,GAAQoe,EAAWre,EAAOC,IAC7BD,EAAOC,aAAiByJ,KAEjC5J,EAAYG,GAAQqe,EAAUte,EAAOC,IACJ,iBAAjBD,EAAOC,GAEvBH,EAAYG,GAAQ6e,EAAc,GAAIhf,EAAYG,GAAOD,EAAOC,IAGhEH,EAAYG,GAAQD,EAAOC,MAI1BH,GAySPif,QA3EF,SAAiBjS,GACf,IAAKA,EACH,OAAO,EAET,IAAK,IAAI/S,EAAI,EAAGA,EAAI+S,EAAOjT,OAAQE,IACjC,GACE+S,EAAO3B,WAAWpR,GAAK,MACtB+S,EAAO3B,WAAWpR,GAAK,MAAU+S,EAAO3B,WAAWpR,GAAK,MAEzD,OAAO,EAGX,OAAO,GAgEPilB,WAjGF,SAAoBzgB,EAAQ6T,GAC1B,IAAI6M,EAAe,GAWnB,OAVA7M,EAAWhV,SAAQ,SAAS6L,GAC1B,IAAInK,EAAQP,EAAO0K,QACLlL,IAAVe,IAGiB,iBAAVA,IACTA,EAAQA,EAAMogB,QAEhBD,EAAahW,GAAYnK,MAEpBmgB,GAsFPE,sBAlSF,SAA+B5gB,EAAQ0K,EAAUnK,GAC/CnE,OAAO4e,eAAehb,EAAQ0K,EAAU,CACtCnK,MAAOA,KAiSTsgB,iBA1RF,SAA0BjF,EAAS/H,GAWjC,OAVsBzX,OAAO6D,KAAK4T,GAClBhV,SAAQ,SAASsE,GAC/B/G,OAAO4e,eAAeY,EAAQvf,UAAW8G,EAAK,CAC5CjF,IAAK,WACH,OAAO2V,EAAW1Q,IAEpB8X,YAAY,OAIT4E,EAAahM,IAgRpB7H,cAjQF,SAAuBnM,EAASihB,GAC9B,OACEjhB,EAEGhD,QAAQ,2BAA2B,SAASkkB,EAAG9U,GAE9C,MACiC,iBAAxB6U,EAAU7U,IACjBoH,MAAMyN,EAAU7U,IAET,MAEFnM,KAAKC,UAAU+gB,EAAU7U,OAGjCpP,QAAQ,yBAAyB,SAASkkB,EAAG9U,GAC5C,OAAO6U,EAAU7U,OAkPvBsO,kBAtHF,SAA2Bha,EAAOygB,GAChC,YAAiBxhB,IAAVe,EAAsBygB,EAAezgB,GAsH5C+M,cAAeA,EACfsR,WAzMF,SAAoB3hB,EAAOgkB,GACzB,OAAqB,IAAjBhkB,EAAM3B,OACD,GAEY,IAAjB2B,EAAM3B,OACD2B,EAAM,GAEM,IAAjBA,EAAM3B,OACD2B,EAAMN,KAAK,IAAMskB,EAAc,KAEpChkB,EAAM3B,OAAS,EACV2B,EAAMN,KAAK,KAAOskB,EAAc,UADzC,GAgMApC,cAhLF,SAAuB5S,GACrB,OAAiB,OAAbA,EACK,OAELqB,EAAcrB,GACT,eAEL/P,MAAMC,QAAQ8P,GACT,QAELA,aAAoBd,KACf,cAEKc,GAoKd6S,YA9IF,SAAqB5W,EAASsX,GAC5B,OAAOtjB,MAAMC,QAAQqjB,IACgB,IAAjCA,EAAWre,QAAQ+G,GACnBA,KAAWsX,GA4IfU,gBAAiBA,EACjBgB,2BAjCF,SAAoC3S,EAAQ4S,GAE1C,IADA,IAAIC,EACYC,EAAP7lB,EAAI,EAAQA,EAAI+S,EAAOjT,OAAQE,IACtC,GAA+B,OAA3B+S,EAAO/S,GAAGiC,MAAM0jB,GAAiB,CACnC,IAA2C,KAAtCE,EAAMnB,EAAgB3R,EAAQ/S,IACjC,SAEF4lB,EAAYC,EAEZ,MAIJ,OAAOD,K;;;;;;mGCzYT,IACI9G,EADY,oBAAQ,gEACGA,WAgF3Btf,EAAOC,QAAU,CACfwf,0BArDF,SAAmCyC,EAAgBgC,GACjD,IAAIjK,EAASiI,EAWb,OAVA5C,EAAW4C,EAAgBgC,EAAe,GAAI,CAE5CH,UAC4B,iBAAnB7B,GACoB,iBAAnBA,GACa,KAAnBA,IACC7J,MAAO4B,EAASqM,OAAOpE,IAC5B8B,aACE,0JAEG/J,GA0CPsM,gCA3EF,SAAyCrE,EAAgBgC,GACvD,IAAIjK,EAASiI,EAYb,OAXA5C,EAAW4C,EAAgBgC,EAAe,GAAI,CAG5CH,UAC6B,iBAAnB7B,IAAgC7J,MAAM6J,IACnB,iBAAnBA,GACa,KAAnBA,IACC7J,MAAO4B,EAASqM,OAAOpE,IAC5B8B,aACE,0JAEG/J,GA+DPyF,0BArCF,SAAmCwC,EAAgBgC,GACjD5E,EAAW4C,EAAgBgC,EAAe,CAAC,SAAU,UAAW,CAC9DF,aACE,mMAmCJrE,kBAvBF,SAA2Bnd,EAAS2f,GAgBlC,YAdsC3d,IAAlChC,EAAQ8U,wBACV9U,EAAQ8U,2BACa9S,IAAnB2d,EAA+B,EAAIA,SAGH3d,IAAlChC,EAAQ4U,uBACR5U,EAAQ4U,sBAAwB,KAEhC5U,EAAQ4U,2BACa5S,IAAnB2d,EAA+B,EAAIA,GAEnC3f,EAAQ8U,sBAAwB9U,EAAQ4U,wBAC1C5U,EAAQ8U,sBAAwB9U,EAAQ4U,uBAEnC5U,K;;;;;;mGC/ETxC,EAAOC,QAAU,4BAAQ,wD;;;;;;oFCYzBD,EAAOC,QANP,SAAwB+E,GACtB,OAAO,SAASmD,GACd,OAAiB,MAAVnD,OAAiBR,EAAYQ,EAAOmD,M;;;;;;sFCT/C,IAkBIqe,EAlBiB,0BAAQ,4CAkBNC,CAfH,CAClB,QAAS,IACT,OAAQ,IACR,OAAQ,IACR,SAAU,IACV,QAAS,MAYXzmB,EAAOC,QAAUumB,G;;;;;;sFCpBjB,IAAIllB,EAAW,mBAAQ,sCACnBklB,EAAmB,4BAAQ,+CAG3BE,EAAgB,4BAChBC,EAAmB3d,OAAO0d,EAAcjgB,QA4B5CzG,EAAOC,QAPP,SAAkBsT,GAEhB,OADAA,EAASjS,EAASiS,KACAoT,EAAiBxjB,KAAKoQ,GACpCA,EAAO1R,QAAQ6kB,EAAeF,GAC9BjT,I;;;;;;mGC5BNtT,EAAQE,YAAa,EAErB,IAAIymB,EAAWxlB,OAAOylB,QAAU,SAAUC,GAAU,IAAK,IAAItmB,EAAI,EAAGA,EAAIH,UAAUC,OAAQE,IAAK,CAAE,IAAIiG,EAASpG,UAAUG,GAAI,IAAK,IAAI2H,KAAO1B,EAAcrF,OAAOC,UAAU6E,eAAe3E,KAAKkF,EAAQ0B,KAAQ2e,EAAO3e,GAAO1B,EAAO0B,IAAY,OAAO2e,GAInPC,EAAU/Z,EAFD,cAAQ,mCAMjBga,EAAcha,EAFD,mBAAQ,wCAMrBia,EAAoBja,EAFD,0BAAQ,8DAM3Bka,EAA4Bla,EAFD,kCAAQ,sEAInCma,EAAa,0BAAQ,6DAEzB,SAASna,EAAuB9M,GAAO,OAAOA,GAAOA,EAAIC,WAAaD,EAAM,CAAE+M,QAAS/M,GAEvF,SAASknB,EAAgBC,EAAUC,GAAe,KAAMD,aAAoBC,GAAgB,MAAM,IAAIjD,UAAU,qCAEhH,SAASkD,EAA2Bhc,EAAMhK,GAAQ,IAAKgK,EAAQ,MAAM,IAAIic,eAAe,6DAAgE,OAAOjmB,GAAyB,iBAATA,GAAqC,mBAATA,EAA8BgK,EAAPhK,EAKhN4lB,EAAWM,UAAUC,WAEnBV,EAAY/Z,QAAQ0a,KACrBX,EAAY/Z,QAAQ0a,KACpBX,EAAY/Z,QAAQ0a,MACZ,EAAIR,EAAWS,mBAAmB,WACnC,EAAIT,EAAWS,mBAAmB,UAClC,EAAIT,EAAWS,mBAAmB,SAR5D,IAiBIC,EAAqB,SAAUC,GAGjC,SAASD,IACP,IAAIE,EAAOC,EAEXZ,EAAgBrmB,KAAM8mB,GAEtB,IAAK,IAAII,EAAO5nB,UAAUC,OAAQC,EAAOW,MAAM+mB,GAAO3W,EAAO,EAAGA,EAAO2W,EAAM3W,IAC3E/Q,EAAK+Q,GAAQjR,UAAUiR,GAGzB,OAAeyW,EAASC,EAAQT,EAA2BxmB,KAAM+mB,EAAiBvmB,KAAKT,MAAMgnB,EAAkB,CAAC/mB,MAAMkC,OAAO1C,KAAiBynB,EAAME,WAAa,SAAUC,GACzK,OAAOpB,EAAQ9Z,QAAQ4B,cAAcqY,EAA0Bja,QAAS,CACtEnL,KAAMkmB,EAAMI,MAAMC,eAClBC,OAAQN,EAAMI,MAAMG,iBACpBC,MAAOR,EAAMI,MAAMK,gBACnBC,MAAOV,EAAMI,MAAMO,gBACnBC,cAAeZ,EAAMI,MAAMS,wBAC3BC,aAAcd,EAAMI,MAAMW,uBAC1BC,aAAchB,EAAMI,MAAMa,wBACzBd,IACMZ,EAA2BS,EAAnCD,GAYL,OArDF,SAAmBmB,EAAUC,GAAc,GAA0B,mBAAfA,GAA4C,OAAfA,EAAuB,MAAM,IAAI9E,UAAU,kEAAoE8E,GAAeD,EAAS7nB,UAAYD,OAAOqf,OAAO0I,GAAcA,EAAW9nB,UAAW,CAAE4jB,YAAa,CAAE1f,MAAO2jB,EAAUjJ,YAAY,EAAOmJ,UAAU,EAAMC,cAAc,KAAeF,IAAY/nB,OAAOkoB,eAAiBloB,OAAOkoB,eAAeJ,EAAUC,GAAcD,EAASK,UAAYJ,GAoB/dK,CAAU3B,EAAoBC,GA6B9BD,EAAmBxmB,UAAUooB,OAAS,WACpC,OAAO1C,EAAQ9Z,QAAQ4B,cAAcoY,EAAkBha,QAAS2Z,EAAS,GAAI7lB,KAAKqnB,MAAO,CAAEsB,aAAc3oB,KAAKmnB,eAGzGL,EAlCgB,CAmCvBd,EAAQ9Z,QAAQ0c,WAElB9B,EAAmB+B,YAAc,qBAGjC/B,EAAmBgC,UAAgE,GACnFhC,EAAmBiC,aA/CA,CACjBvB,kBAAkB,EAClBE,iBAAiB,EACjBE,iBAAiB,GA8CnB1oB,EAAQgN,QAAU4a,EAClB7nB,EAAOC,QAAUA,EAAiB,S;;;;;;mGC3FlCA,EAAQE,YAAa,EAErB,IAAIymB,EAAWxlB,OAAOylB,QAAU,SAAUC,GAAU,IAAK,IAAItmB,EAAI,EAAGA,EAAIH,UAAUC,OAAQE,IAAK,CAAE,IAAIiG,EAASpG,UAAUG,GAAI,IAAK,IAAI2H,KAAO1B,EAAcrF,OAAOC,UAAU6E,eAAe3E,KAAKkF,EAAQ0B,KAAQ2e,EAAO3e,GAAO1B,EAAO0B,IAAY,OAAO2e,GAInPiD,EAAa/c,EAFD,mCAAQ,kDAMpBgd,EAAgBhd,EAFD,sCAAQ,qDAMvBid,EAA0Bjd,EAFD,+CAAQ,8DAIjCkd,EAAc,0CAAQ,wDAItBnD,EAAU/Z,EAFD,cAAQ,mCAMjBga,EAAcha,EAFD,mBAAQ,wCAIrBmd,EAAY,kBAAQ,sCAEpBhD,EAAa,0BAAQ,6DAEzB,SAASna,EAAuB9M,GAAO,OAAOA,GAAOA,EAAIC,WAAaD,EAAM,CAAE+M,QAAS/M,GAEvF,SAASknB,EAAgBC,EAAUC,GAAe,KAAMD,aAAoBC,GAAgB,MAAM,IAAIjD,UAAU,qCAEhH,SAASkD,EAA2Bhc,EAAMhK,GAAQ,IAAKgK,EAAQ,MAAM,IAAIic,eAAe,6DAAgE,OAAOjmB,GAAyB,iBAATA,GAAqC,mBAATA,EAA8BgK,EAAPhK,EAIlO,IAAIuH,EAAS,GACTohB,EAAYhc,eAAepF,EAAOtF,KAAK0mB,EAAYhc,eACnDgc,EAAYrc,cAAc/E,EAAOtF,KAAK0mB,EAAYrc,cAoB1CmZ,EAAY/Z,QAAQnH,KACxBqhB,EAAWM,UAAUC,WAKnBV,EAAY/Z,QAAQ0a,KACrBX,EAAY/Z,QAAQ0a,KACpBX,EAAY/Z,QAAQ0a,KACZX,EAAY/Z,QAAQgN,OACrB+M,EAAY/Z,QAAQgN,OACpB+M,EAAY/Z,QAAQgN,OAZpC,IAeImQ,EAA0B,SAAUtC,GAGtC,SAASsC,IACP,IAAIrC,EAAOC,EAEXZ,EAAgBrmB,KAAMqpB,GAEtB,IAAK,IAAInC,EAAO5nB,UAAUC,OAAQC,EAAOW,MAAM+mB,GAAO3W,EAAO,EAAGA,EAAO2W,EAAM3W,IAC3E/Q,EAAK+Q,GAAQjR,UAAUiR,GAGzB,OAAeyW,EAASC,EAAQT,EAA2BxmB,KAAM+mB,EAAiBvmB,KAAKT,MAAMgnB,EAAkB,CAAC/mB,MAAMkC,OAAO1C,KAAiBynB,EAAMqC,oBAAsB,SAAUC,GAC9KtC,EAAMI,MAAME,OACdN,EAAMuC,WAAW,SAAUD,EAAMtC,EAAMI,MAAMQ,eAE7C0B,KAEDtC,EAAMwC,mBAAqB,SAAUF,GAClCtC,EAAMI,MAAMI,MACdR,EAAMuC,WAAW,QAASD,EAAMtC,EAAMI,MAAMU,cAE5CwB,KAEDtC,EAAMyC,mBAAqB,SAAUH,GAClCtC,EAAMI,MAAMM,MACdV,EAAMuC,WAAW,QAASD,EAAMtC,EAAMI,MAAMY,cAE5CsB,KAEO/C,EAA2BS,EAAnCD,GAiHL,OArLF,SAAmBmB,EAAUC,GAAc,GAA0B,mBAAfA,GAA4C,OAAfA,EAAuB,MAAM,IAAI9E,UAAU,kEAAoE8E,GAAeD,EAAS7nB,UAAYD,OAAOqf,OAAO0I,GAAcA,EAAW9nB,UAAW,CAAE4jB,YAAa,CAAE1f,MAAO2jB,EAAUjJ,YAAY,EAAOmJ,UAAU,EAAMC,cAAc,KAAeF,IAAY/nB,OAAOkoB,eAAiBloB,OAAOkoB,eAAeJ,EAAUC,GAAcD,EAASK,UAAYJ,GAuC/dK,CAAUY,EAAyBtC,GAgCnCsC,EAAwB/oB,UAAUqpB,mBAAqB,WACrD3pB,KAAK4pB,sBAAwB,GAC7B5pB,KAAK6pB,mBAAqB,IAG5BR,EAAwB/oB,UAAUwpB,qBAAuB,WACvD9pB,KAAK+pB,WAAY,EAEb/pB,KAAKgqB,SACPC,aAAajqB,KAAKgqB,SAEpBhqB,KAAK6pB,mBAAmB/mB,SAAQ,SAAUknB,GACxCC,aAAaD,MAGfhqB,KAAK4pB,sBAAsBrqB,OAAS,GAGtC8pB,EAAwB/oB,UAAUkpB,WAAa,SAAoBU,EAAeC,EAAgBH,GAChG,IAAIjlB,GAAO,EAAIqkB,EAAUgB,aAAapqB,MAEtC,GAAK+E,EAAL,CAOA,IAAIqH,EAAYpM,KAAKqnB,MAAMtmB,KAAKmpB,IAAkBlqB,KAAKqnB,MAAMtmB,KAAO,IAAMmpB,EACtEG,EAAkBrqB,KAAKqnB,MAAMtmB,KAAKmpB,EAAgB,WAAa9d,EAAY,UAC3Eke,EAAQ,KACRphB,OAAkB,GAEtB,EAAI8f,EAAW9c,SAASnH,EAAMqH,GAG9BpM,KAAKuqB,kBAAkBF,EAAiBtlB,GAGxC,IAAIylB,EAAS,SAAgBvc,GACvBA,GAAKA,EAAE8X,SAAWhhB,IAItBklB,aAAaK,GACTphB,GAAiBA,KAErB,EAAI+f,EAAc/c,SAASnH,EAAMqH,IACjC,EAAI6c,EAAc/c,SAASnH,EAAMslB,GAE7BnhB,GAAiBA,IAIjBihB,GACFA,MAIAH,GACFM,EAAQ5a,WAAW8a,EAAQR,GAC3BhqB,KAAK6pB,mBAAmBpnB,KAAK6nB,IACpBnB,EAAYhc,gBACrBjE,EAhIN,SAAwBnE,EAAM2C,GAS5B,OARIK,EAAOxI,OACTwI,EAAOjF,SAAQ,SAAUmL,GACvB,OAAOlJ,EAAK0lB,iBAAiBxc,EAAGvG,GAAU,MAG5CgI,WAAWhI,EAAU,GAGhB,WACAK,EAAOxI,QACZwI,EAAOjF,SAAQ,SAAUmL,GACvB,OAAOlJ,EAAK2lB,oBAAoBzc,EAAGvG,GAAU,OAoH3BijB,CAAe5lB,EAAMylB,SAzCnCL,GACFA,KA4CNd,EAAwB/oB,UAAUiqB,kBAAoB,SAA2Bne,EAAWrH,GAC1F,IAAI6lB,EAAS5qB,KAEbA,KAAK4pB,sBAAsBnnB,KAAK,CAC9B2J,UAAWA,EACXrH,KAAMA,IAGH/E,KAAK6qB,YACR7qB,KAAK6qB,WAAY,EAAI3B,EAAwBhd,UAAS,WACpD,OAAO0e,EAAOE,kCAKpBzB,EAAwB/oB,UAAUwqB,2BAA6B,WACxD9qB,KAAK+pB,WACR/pB,KAAK4pB,sBAAsB9mB,SAAQ,SAAU3D,GAI3CA,EAAI4F,KAAKgmB,WAET,EAAI/B,EAAW9c,SAAS/M,EAAI4F,KAAM5F,EAAIiN,cAG1CpM,KAAK4pB,sBAAsBrqB,OAAS,EACpCS,KAAK6qB,UAAY,MAGnBxB,EAAwB/oB,UAAUooB,OAAS,WACzC,IAAIrB,EAAQxB,EAAS,GAAI7lB,KAAKqnB,OAS9B,cAROA,EAAMtmB,YACNsmB,EAAME,cACNF,EAAMI,aACNJ,EAAMM,aACNN,EAAMQ,qBACNR,EAAMU,oBACNV,EAAMY,oBACNZ,EAAM2D,SACNhF,EAAQ9Z,QAAQ+e,aAAajF,EAAQ9Z,QAAQgf,SAASC,KAAKnrB,KAAKqnB,MAAM2D,UAAW3D,IAGnFgC,EA/IqB,CAgJ5BrD,EAAQ9Z,QAAQ0c,WAElBS,EAAwBR,YAAc,0BAGtCQ,EAAwBP,UAAgE,GAExF5pB,EAAQgN,QAAUmd,EAClBpqB,EAAOC,QAAUA,EAAiB,S;;;;;;mGClOlCA,EAAQE,YAAa,EAErB,IAAIymB,EAAWxlB,OAAOylB,QAAU,SAAUC,GAAU,IAAK,IAAItmB,EAAI,EAAGA,EAAIH,UAAUC,OAAQE,IAAK,CAAE,IAAIiG,EAASpG,UAAUG,GAAI,IAAK,IAAI2H,KAAO1B,EAAcrF,OAAOC,UAAU6E,eAAe3E,KAAKkF,EAAQ0B,KAAQ2e,EAAO3e,GAAO1B,EAAO0B,IAAY,OAAO2e,GAInPqF,EAAkBnf,EAFD,uBAAQ,4CAMzB+Z,EAAU/Z,EAFD,cAAQ,mCAMjBga,EAAcha,EAFD,mBAAQ,wCAQrBof,GAFYpf,EAFD,gBAAQ,2EAIH,6BAAQ,iEAE5B,SAASA,EAAuB9M,GAAO,OAAOA,GAAOA,EAAIC,WAAaD,EAAM,CAAE+M,QAAS/M,GAS1E8mB,EAAY/Z,QAAQof,IACjBrF,EAAY/Z,QAAQqf,KACxBtF,EAAY/Z,QAAQnH,KAHhC,IAaIymB,EAAkB,SAAUzE,GAG9B,SAASyE,EAAgBnE,EAAOoE,IAtBlC,SAAyBnF,EAAUC,GAAe,KAAMD,aAAoBC,GAAgB,MAAM,IAAIjD,UAAU,qCAuB5G+C,CAAgBrmB,KAAMwrB,GAEtB,IAAIvE,EAvBR,SAAoCzc,EAAMhK,GAAQ,IAAKgK,EAAQ,MAAM,IAAIic,eAAe,6DAAgE,OAAOjmB,GAAyB,iBAATA,GAAqC,mBAATA,EAA8BgK,EAAPhK,EAuBlNgmB,CAA2BxmB,KAAM+mB,EAAiBvmB,KAAKR,KAAMqnB,EAAOoE,IA2FhF,OAzFAxE,EAAMyE,cAAgB,SAAUtkB,EAAKukB,GACnC1E,EAAM2E,2BAA2BxkB,IAAO,EAEpCukB,EAAUrC,oBACZqC,EAAUrC,oBAAoBrC,EAAM4E,qBAAqBC,KAAK7E,EAAO7f,EAAKukB,IAE1E1E,EAAM4E,qBAAqBzkB,EAAKukB,IAIpC1E,EAAM4E,qBAAuB,SAAUzkB,EAAKukB,GACtCA,EAAUI,oBACZJ,EAAUI,4BAGL9E,EAAM2E,2BAA2BxkB,GAExC,IAAI4kB,GAAsB,EAAIX,EAAcY,iBAAiBhF,EAAMI,MAAM2D,UAEpEgB,GAAwBA,EAAoB7mB,eAAeiC,IAE9D6f,EAAMiF,aAAa9kB,EAAKukB,IAI5B1E,EAAMkF,aAAe,SAAU/kB,EAAKukB,GAClC1E,EAAM2E,2BAA2BxkB,IAAO,EAEpCukB,EAAUlC,mBACZkC,EAAUlC,mBAAmBxC,EAAMmF,oBAAoBN,KAAK7E,EAAO7f,EAAKukB,IAExE1E,EAAMmF,oBAAoBhlB,EAAKukB,IAInC1E,EAAMmF,oBAAsB,SAAUhlB,EAAKukB,GACrCA,EAAUU,mBACZV,EAAUU,2BAGLpF,EAAM2E,2BAA2BxkB,GAExC,IAAI4kB,GAAsB,EAAIX,EAAcY,iBAAiBhF,EAAMI,MAAM2D,UAEpEgB,GAAwBA,EAAoB7mB,eAAeiC,IAE9D6f,EAAMiF,aAAa9kB,EAAKukB,IAI5B1E,EAAMiF,aAAe,SAAU9kB,EAAKukB,GAClC1E,EAAM2E,2BAA2BxkB,IAAO,EAEpCukB,EAAUjC,mBACZiC,EAAUjC,mBAAmBzC,EAAMqF,mBAAmBR,KAAK7E,EAAO7f,EAAKukB,IAKvE1E,EAAMqF,mBAAmBllB,EAAKukB,IAIlC1E,EAAMqF,mBAAqB,SAAUllB,EAAKukB,GACpCA,EAAUY,mBACZZ,EAAUY,2BAGLtF,EAAM2E,2BAA2BxkB,GAExC,IAAI4kB,GAAsB,EAAIX,EAAcY,iBAAiBhF,EAAMI,MAAM2D,UAErEgB,GAAuBA,EAAoB7mB,eAAeiC,GAE5D6f,EAAMuF,YAAY/pB,KAAK2E,GAEvB6f,EAAMwF,UAAS,SAAUC,GACvB,IAAIC,EAAc9G,EAAS,GAAI6G,EAAM1B,UAErC,cADO2B,EAAYvlB,GACZ,CAAE4jB,SAAU2B,OAKzB1F,EAAM2F,UAAYvsB,OAAOqf,OAAO,MAEhCuH,EAAMyF,MAAQ,CACZ1B,UAAU,EAAIK,EAAcY,iBAAiB5E,EAAM2D,WAE9C/D,EAoHT,OApOF,SAAmBkB,EAAUC,GAAc,GAA0B,mBAAfA,GAA4C,OAAfA,EAAuB,MAAM,IAAI9E,UAAU,kEAAoE8E,GAAeD,EAAS7nB,UAAYD,OAAOqf,OAAO0I,GAAcA,EAAW9nB,UAAW,CAAE4jB,YAAa,CAAE1f,MAAO2jB,EAAUjJ,YAAY,EAAOmJ,UAAU,EAAMC,cAAc,KAAeF,IAAY/nB,OAAOkoB,eAAiBloB,OAAOkoB,eAAeJ,EAAUC,GAAcD,EAASK,UAAYJ,GAgB/dK,CAAU+C,EAAiBzE,GAmG3ByE,EAAgBlrB,UAAUqpB,mBAAqB,WAC7C3pB,KAAK4rB,2BAA6B,GAClC5rB,KAAKwsB,YAAc,GACnBxsB,KAAK6sB,YAAc,IAGrBrB,EAAgBlrB,UAAUwsB,kBAAoB,WAC5C,IAAIC,EAAsB/sB,KAAK0sB,MAAM1B,SACrC,IAAK,IAAI5jB,KAAO2lB,EACVA,EAAoB3lB,IACtBpH,KAAK0rB,cAActkB,EAAKpH,KAAK4sB,UAAUxlB,KAK7CokB,EAAgBlrB,UAAU0sB,0BAA4B,SAAmCC,GACvF,IAAIC,GAAmB,EAAI7B,EAAcY,iBAAiBgB,EAAUjC,UAChEmC,EAAmBntB,KAAK0sB,MAAM1B,SAMlC,IAAK,IAAI5jB,KAJTpH,KAAKysB,SAAS,CACZzB,UAAU,EAAIK,EAAc+B,oBAAoBD,EAAkBD,KAGpDA,EAAkB,CAChC,IAAIG,EAAUF,GAAoBA,EAAiBhoB,eAAeiC,IAC9D8lB,EAAiB9lB,IAASimB,GAAYrtB,KAAK4rB,2BAA2BxkB,IACxEpH,KAAKwsB,YAAY/pB,KAAK2E,GAI1B,IAAK,IAAImJ,KAAQ4c,EAAkB,CACjC,IAAIG,EAAUJ,GAAoBA,EAAiB/nB,eAAeoL,IAC9D4c,EAAiB5c,IAAU+c,GAAYttB,KAAK4rB,2BAA2Brb,IACzEvQ,KAAK6sB,YAAYpqB,KAAK8N,KAO5Bib,EAAgBlrB,UAAUitB,mBAAqB,WAC7C,IAAI3C,EAAS5qB,KAETwsB,EAAcxsB,KAAKwsB,YACvBxsB,KAAKwsB,YAAc,GACnBA,EAAY1pB,SAAQ,SAAUsE,GAC5B,OAAOwjB,EAAOuB,aAAa/kB,EAAKwjB,EAAOgC,UAAUxlB,OAGnD,IAAIylB,EAAc7sB,KAAK6sB,YACvB7sB,KAAK6sB,YAAc,GACnBA,EAAY/pB,SAAQ,SAAUsE,GAC5B,OAAOwjB,EAAOsB,aAAa9kB,EAAKwjB,EAAOgC,UAAUxlB,QAIrDokB,EAAgBlrB,UAAUooB,OAAS,WACjC,IAAI8E,EAASxtB,KAITytB,EAAmB,GAEnBC,EAAQ,SAAetmB,GACzB,IAAIggB,EAAQoG,EAAOd,MAAM1B,SAAS5jB,GAClC,GAAIggB,EAAO,CACT,IAAIuG,EAAqC,iBAAdvG,EAAMwG,IAC7BC,EAAeL,EAAOnG,MAAMsB,aAAavB,GACzCwG,EAAM,SAAaE,GACrBN,EAAOZ,UAAUxlB,GAAO0mB,GAStBD,IAAiBzG,GAASuG,IAC5BC,GAAM,EAAIxC,EAAgBlf,SAASkb,EAAMwG,IAAKA,IAQhDH,EAAiBhrB,KAAKujB,EAAQ9Z,QAAQ+e,aAAa4C,EAAc,CAC/DzmB,IAAKA,EACLwmB,IAAKA,OAKX,IAAK,IAAIxmB,KAAOpH,KAAK0sB,MAAM1B,SACzB0C,EAAMtmB,GAIR,IAAIigB,EAAQxB,EAAS,GAAI7lB,KAAKqnB,OAW9B,cAVOA,EAAMO,uBACNP,EAAMC,sBACND,EAAMG,wBACNH,EAAMK,uBACNL,EAAMsB,oBACNtB,EAAMa,8BACNb,EAAMW,8BACNX,EAAMS,+BACNT,EAAMsE,UAEN3F,EAAQ9Z,QAAQ4B,cAAc9N,KAAKqnB,MAAMsE,UAAWtE,EAAOoG,IAG7DjC,EArNa,CAsNpBxF,EAAQ9Z,QAAQ0c,WAElB4C,EAAgB3C,YAAc,kBAG9B2C,EAAgB1C,UAAgE,GAChF0C,EAAgBzC,aAnOG,CACjB4C,UAAW,OACXhD,aAAc,SAAsBvB,GAClC,OAAOA,IAkOXloB,EAAQgN,QAAUsf,EAClBvsB,EAAOC,QAAUA,EAAiB,S;;;;;;mGC1QlC,IAEI6uB,EAAuB9hB,EAFD,6BAAQ,iEAM9Bia,EAAoBja,EAFD,0BAAQ,8DAI/B,SAASA,EAAuB9M,GAAO,OAAOA,GAAOA,EAAIC,WAAaD,EAAM,CAAE+M,QAAS/M,GAEvFF,EAAOC,QAAU,CACfssB,gBAAiBtF,EAAkBha,QACnC4a,mBAAoBiH,EAAqB7hB,U;;;;;;mGC6C3CjN,EAAOC,QAzCO,c;;;;;;mGChBdA,EAAQE,YAAa,EACrBF,EAAQ+sB,gBAWR,SAAyBjB,GACvB,IAAKA,EACH,OAAOA,EAET,IAAIxoB,EAAS,GAMb,OALAwrB,EAAO9C,SAAS7Y,IAAI2Y,GAAU,SAAU5D,GACtC,OAAOA,KACNtkB,SAAQ,SAAUskB,GACnB5kB,EAAO4kB,EAAMhgB,KAAOggB,KAEf5kB,GApBTtD,EAAQkuB,mBAwCR,SAA4B5d,EAAM1P,GAIhC,SAASmuB,EAAe7mB,GACtB,OAAItH,EAAKqF,eAAeiC,GACftH,EAAKsH,GAGPoI,EAAKpI,GARdoI,EAAOA,GAAQ,GACf1P,EAAOA,GAAQ,GAYf,IAAIouB,EAAkB,GAElBC,EAAc,GAClB,IAAK,IAAIC,KAAW5e,EACd1P,EAAKqF,eAAeipB,GAClBD,EAAY5uB,SACd2uB,EAAgBE,GAAWD,EAC3BA,EAAc,IAGhBA,EAAY1rB,KAAK2rB,GAIrB,IAAI3uB,OAAI,EACJ4uB,EAAe,GACnB,IAAK,IAAIC,KAAWxuB,EAAM,CACxB,GAAIouB,EAAgB/oB,eAAempB,GACjC,IAAK7uB,EAAI,EAAGA,EAAIyuB,EAAgBI,GAAS/uB,OAAQE,IAAK,CACpD,IAAI8uB,EAAiBL,EAAgBI,GAAS7uB,GAC9C4uB,EAAaH,EAAgBI,GAAS7uB,IAAMwuB,EAAeM,GAG/DF,EAAaC,GAAWL,EAAeK,GAIzC,IAAK7uB,EAAI,EAAGA,EAAI0uB,EAAY5uB,OAAQE,IAClC4uB,EAAaF,EAAY1uB,IAAMwuB,EAAeE,EAAY1uB,IAG5D,OAAO4uB,GAnFT,IAAIL,EAAS,cAAQ,mC;;;;;;mGCJrB9uB,EAAQE,YAAa,EACrBF,EAAQwnB,eAAYjjB,EACpBvE,EAAQ2nB,kBAYR,SAA2B2H,GACzB,IAAIC,EAAkB,aAAeD,EAAiB,UAClDE,EAAkB,aAAeF,EAErC,OAAO,SAAUnH,GAEf,GAAIA,EAAMqH,GAAkB,CAE1B,GAA8B,MAA1BrH,EAAMoH,GACR,OAAO,IAAI5tB,MAAM4tB,wNAGZ,GAAsC,iBAA3BpH,EAAMoH,GACtB,OAAO,IAAI5tB,MAAM4tB,EAAkB,uCAIvC,OAAO,OAzBGxiB,EAFD,cAAQ,mCAArB,IAMIga,EAAcha,EAFD,mBAAQ,wCAIzB,SAASA,EAAuB9M,GAAO,OAAOA,GAAOA,EAAIC,WAAaD,EAAM,CAAE+M,QAAS/M,GAuBvED,EAAQwnB,UAAYT,EAAY/Z,QAAQyiB,UAAU,CAAC1I,EAAY/Z,QAAQsG,OAAQyT,EAAY/Z,QAAQ0iB,MAAM,CACvHnH,MAAOxB,EAAY/Z,QAAQsG,OAC3BmV,MAAO1B,EAAY/Z,QAAQsG,OAC3Bqc,OAAQ5I,EAAY/Z,QAAQsG,SAC1ByT,EAAY/Z,QAAQ0iB,MAAM,CAC5BnH,MAAOxB,EAAY/Z,QAAQsG,OAC3Bsc,YAAa7I,EAAY/Z,QAAQsG,OACjCmV,MAAO1B,EAAY/Z,QAAQsG,OAC3Buc,YAAa9I,EAAY/Z,QAAQsG,OACjC+U,OAAQtB,EAAY/Z,QAAQsG,OAC5Bwc,aAAc/I,EAAY/Z,QAAQsG","file":"vendors~ppme-grab~ppme-settings~ppme-slug.bundle.js","sourcesContent":["function _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    \"default\": obj\n  };\n}\nmodule.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","\nmodule.exports = function chain(){\n  var len = arguments.length\n  var args = [];\n\n  for (var i = 0; i < len; i++)\n    args[i] = arguments[i]\n\n  args = args.filter(function(fn){ return fn != null })\n\n  if (args.length === 0) return undefined\n  if (args.length === 1) return args[0]\n\n  return args.reduce(function(current, next){\n    return function chainedFunction() {\n      current.apply(this, arguments);\n      next.apply(this, arguments);\n    };\n  })\n}\n","/**\n * CLDR JavaScript Library v0.5.4\n * http://jquery.com/\n *\n * Copyright 2013 Rafael Xavier de Souza\n * Released under the MIT license\n * http://jquery.org/license\n *\n * Date: 2020-10-22T15:56Z\n */\n/*!\n * CLDR JavaScript Library v0.5.4 2020-10-22T15:56Z MIT license © Rafael Xavier\n * http://git.io/h4lmVg\n */\n(function( root, factory ) {\n\n\tif ( typeof define === \"function\" && define.amd ) {\n\t\t// AMD.\n\t\tdefine( factory );\n\t} else if ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\t\t// Node. CommonJS.\n\t\tmodule.exports = factory();\n\t} else {\n\t\t// Global\n\t\troot.Cldr = factory();\n\t}\n\n}( this, function() {\n\n\n\tvar arrayIsArray = Array.isArray || function( obj ) {\n\t\treturn Object.prototype.toString.call( obj ) === \"[object Array]\";\n\t};\n\n\n\n\n\tvar pathNormalize = function( path, attributes ) {\n\t\tif ( arrayIsArray( path ) ) {\n\t\t\tpath = path.join( \"/\" );\n\t\t}\n\t\tif ( typeof path !== \"string\" ) {\n\t\t\tthrow new Error( \"invalid path \\\"\" + path + \"\\\"\" );\n\t\t}\n\t\t// 1: Ignore leading slash `/`\n\t\t// 2: Ignore leading `cldr/`\n\t\tpath = path\n\t\t\t.replace( /^\\// , \"\" ) /* 1 */\n\t\t\t.replace( /^cldr\\// , \"\" ); /* 2 */\n\n\t\t// Replace {attribute}'s\n\t\tpath = path.replace( /{[a-zA-Z]+}/g, function( name ) {\n\t\t\tname = name.replace( /^{([^}]*)}$/, \"$1\" );\n\t\t\treturn attributes[ name ];\n\t\t});\n\n\t\treturn path.split( \"/\" );\n\t};\n\n\n\n\n\tvar arraySome = function( array, callback ) {\n\t\tvar i, length;\n\t\tif ( array.some ) {\n\t\t\treturn array.some( callback );\n\t\t}\n\t\tfor ( i = 0, length = array.length; i < length; i++ ) {\n\t\t\tif ( callback( array[ i ], i, array ) ) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t};\n\n\n\n\n\t/**\n\t * Return the maximized language id as defined in\n\t * http://www.unicode.org/reports/tr35/#Likely_Subtags\n\t * 1. Canonicalize.\n\t * 1.1 Make sure the input locale is in canonical form: uses the right\n\t * separator, and has the right casing.\n\t * TODO Right casing? What df? It seems languages are lowercase, scripts are\n\t * Capitalized, territory is uppercase. I am leaving this as an exercise to\n\t * the user.\n\t *\n\t * 1.2 Replace any deprecated subtags with their canonical values using the\n\t * <alias> data in supplemental metadata. Use the first value in the\n\t * replacement list, if it exists. Language tag replacements may have multiple\n\t * parts, such as \"sh\" ➞ \"sr_Latn\" or mo\" ➞ \"ro_MD\". In such a case, the\n\t * original script and/or region are retained if there is one. Thus\n\t * \"sh_Arab_AQ\" ➞ \"sr_Arab_AQ\", not \"sr_Latn_AQ\".\n\t * TODO What <alias> data?\n\t *\n\t * 1.3 If the tag is grandfathered (see <variable id=\"$grandfathered\"\n\t * type=\"choice\"> in the supplemental data), then return it.\n\t * TODO grandfathered?\n\t *\n\t * 1.4 Remove the script code 'Zzzz' and the region code 'ZZ' if they occur.\n\t * 1.5 Get the components of the cleaned-up source tag (languages, scripts,\n\t * and regions), plus any variants and extensions.\n\t * 2. Lookup. Lookup each of the following in order, and stop on the first\n\t * match:\n\t * 2.1 languages_scripts_regions\n\t * 2.2 languages_regions\n\t * 2.3 languages_scripts\n\t * 2.4 languages\n\t * 2.5 und_scripts\n\t * 3. Return\n\t * 3.1 If there is no match, either return an error value, or the match for\n\t * \"und\" (in APIs where a valid language tag is required).\n\t * 3.2 Otherwise there is a match = languagem_scriptm_regionm\n\t * 3.3 Let xr = xs if xs is not empty, and xm otherwise.\n\t * 3.4 Return the language tag composed of languager _ scriptr _ regionr +\n\t * variants + extensions.\n\t *\n\t * @subtags [Array] normalized language id subtags tuple (see init.js).\n\t */\n\tvar coreLikelySubtags = function( Cldr, cldr, subtags, options ) {\n\t\tvar match, matchFound,\n\t\t\tlanguage = subtags[ 0 ],\n\t\t\tscript = subtags[ 1 ],\n\t\t\tsep = Cldr.localeSep,\n\t\t\tterritory = subtags[ 2 ],\n\t\t\tvariants = subtags.slice( 3, 4 );\n\t\toptions = options || {};\n\n\t\t// Skip if (language, script, territory) is not empty [3.3]\n\t\tif ( language !== \"und\" && script !== \"Zzzz\" && territory !== \"ZZ\" ) {\n\t\t\treturn [ language, script, territory ].concat( variants );\n\t\t}\n\n\t\t// Skip if no supplemental likelySubtags data is present\n\t\tif ( typeof cldr.get( \"supplemental/likelySubtags\" ) === \"undefined\" ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// [2]\n\t\tmatchFound = arraySome([\n\t\t\t[ language, script, territory ],\n\t\t\t[ language, territory ],\n\t\t\t[ language, script ],\n\t\t\t[ language ],\n\t\t\t[ \"und\", script ]\n\t\t], function( test ) {\n\t\t\treturn match = !(/\\b(Zzzz|ZZ)\\b/).test( test.join( sep ) ) /* [1.4] */ && cldr.get( [ \"supplemental/likelySubtags\", test.join( sep ) ] );\n\t\t});\n\n\t\t// [3]\n\t\tif ( matchFound ) {\n\t\t\t// [3.2 .. 3.4]\n\t\t\tmatch = match.split( sep );\n\t\t\treturn [\n\t\t\t\tlanguage !== \"und\" ? language : match[ 0 ],\n\t\t\t\tscript !== \"Zzzz\" ? script : match[ 1 ],\n\t\t\t\tterritory !== \"ZZ\" ? territory : match[ 2 ]\n\t\t\t].concat( variants );\n\t\t} else if ( options.force ) {\n\t\t\t// [3.1.2]\n\t\t\treturn cldr.get( \"supplemental/likelySubtags/und\" ).split( sep );\n\t\t} else {\n\t\t\t// [3.1.1]\n\t\t\treturn;\n\t\t}\n\t};\n\n\n\n\t/**\n\t * Given a locale, remove any fields that Add Likely Subtags would add.\n\t * http://www.unicode.org/reports/tr35/#Likely_Subtags\n\t * 1. First get max = AddLikelySubtags(inputLocale). If an error is signaled,\n\t * return it.\n\t * 2. Remove the variants from max.\n\t * 3. Then for trial in {language, language _ region, language _ script}. If\n\t * AddLikelySubtags(trial) = max, then return trial + variants.\n\t * 4. If you do not get a match, return max + variants.\n\t * \n\t * @maxLanguageId [Array] maxLanguageId tuple (see init.js).\n\t */\n\tvar coreRemoveLikelySubtags = function( Cldr, cldr, maxLanguageId ) {\n\t\tvar match, matchFound,\n\t\t\tlanguage = maxLanguageId[ 0 ],\n\t\t\tscript = maxLanguageId[ 1 ],\n\t\t\tterritory = maxLanguageId[ 2 ],\n\t\t\tvariants = maxLanguageId[ 3 ];\n\n\t\t// [3]\n\t\tmatchFound = arraySome([\n\t\t\t[ [ language, \"Zzzz\", \"ZZ\" ], [ language ] ],\n\t\t\t[ [ language, \"Zzzz\", territory ], [ language, territory ] ],\n\t\t\t[ [ language, script, \"ZZ\" ], [ language, script ] ]\n\t\t], function( test ) {\n\t\t\tvar result = coreLikelySubtags( Cldr, cldr, test[ 0 ] );\n\t\t\tmatch = test[ 1 ];\n\t\t\treturn result && result[ 0 ] === maxLanguageId[ 0 ] &&\n\t\t\t\tresult[ 1 ] === maxLanguageId[ 1 ] &&\n\t\t\t\tresult[ 2 ] === maxLanguageId[ 2 ];\n\t\t});\n\n\t\tif ( matchFound ) {\n\t\t\tif ( variants ) {\n\t\t\t\tmatch.push( variants );\n\t\t\t}\n\t\t\treturn match;\n\t\t}\n\n\t\t// [4]\n\t\treturn maxLanguageId;\n\t};\n\n\n\n\n\t/**\n\t * subtags( locale )\n\t *\n\t * @locale [String]\n\t */\n\tvar coreSubtags = function( locale ) {\n\t\tvar aux, unicodeLanguageId,\n\t\t\tsubtags = [];\n\n\t\tlocale = locale.replace( /_/, \"-\" );\n\n\t\t// Unicode locale extensions.\n\t\taux = locale.split( \"-u-\" );\n\t\tif ( aux[ 1 ] ) {\n\t\t\taux[ 1 ] = aux[ 1 ].split( \"-t-\" );\n\t\t\tlocale = aux[ 0 ] + ( aux[ 1 ][ 1 ] ? \"-t-\" + aux[ 1 ][ 1 ] : \"\");\n\t\t\tsubtags[ 4 /* unicodeLocaleExtensions */ ] = aux[ 1 ][ 0 ];\n\t\t}\n\n\t\t// TODO normalize transformed extensions. Currently, skipped.\n\t\t// subtags[ x ] = locale.split( \"-t-\" )[ 1 ];\n\t\tunicodeLanguageId = locale.split( \"-t-\" )[ 0 ];\n\n\t\t// unicode_language_id = \"root\"\n\t\t//   | unicode_language_subtag         \n\t\t//     (sep unicode_script_subtag)? \n\t\t//     (sep unicode_region_subtag)?\n\t\t//     (sep unicode_variant_subtag)* ;\n\t\t//\n\t\t// Although unicode_language_subtag = alpha{2,8}, I'm using alpha{2,3}. Because, there's no language on CLDR lengthier than 3.\n\t\taux = unicodeLanguageId.match( /^(([a-z]{2,3})(-([A-Z][a-z]{3}))?(-([A-Z]{2}|[0-9]{3}))?)((-([a-zA-Z0-9]{5,8}|[0-9][a-zA-Z0-9]{3}))*)$|^(root)$/ );\n\t\tif ( aux === null ) {\n\t\t\treturn [ \"und\", \"Zzzz\", \"ZZ\" ];\n\t\t}\n\t\tsubtags[ 0 /* language */ ] = aux[ 10 ] /* root */ || aux[ 2 ] || \"und\";\n\t\tsubtags[ 1 /* script */ ] = aux[ 4 ] || \"Zzzz\";\n\t\tsubtags[ 2 /* territory */ ] = aux[ 6 ] || \"ZZ\";\n\t\tif ( aux[ 7 ] && aux[ 7 ].length ) {\n\t\t\tsubtags[ 3 /* variant */ ] = aux[ 7 ].slice( 1 ) /* remove leading \"-\" */;\n\t\t}\n\n\t\t// 0: language\n\t\t// 1: script\n\t\t// 2: territory (aka region)\n\t\t// 3: variant\n\t\t// 4: unicodeLocaleExtensions\n\t\treturn subtags;\n\t};\n\n\n\n\n\tvar arrayForEach = function( array, callback ) {\n\t\tvar i, length;\n\t\tif ( array.forEach ) {\n\t\t\treturn array.forEach( callback );\n\t\t}\n\t\tfor ( i = 0, length = array.length; i < length; i++ ) {\n\t\t\tcallback( array[ i ], i, array );\n\t\t}\n\t};\n\n\n\n\n\t/**\n\t * bundleLookup( minLanguageId )\n\t *\n\t * @Cldr [Cldr class]\n\t *\n\t * @cldr [Cldr instance]\n\t *\n\t * @minLanguageId [String] requested languageId after applied remove likely subtags.\n\t */\n\tvar bundleLookup = function( Cldr, cldr, minLanguageId ) {\n\t\tvar availableBundleMap = Cldr._availableBundleMap,\n\t\t\tavailableBundleMapQueue = Cldr._availableBundleMapQueue;\n\n\t\tif ( availableBundleMapQueue.length ) {\n\t\t\tarrayForEach( availableBundleMapQueue, function( bundle, i ) {\n\t\t\t\tvar existing, maxBundle, minBundle, subtags;\n\t\t\t\tsubtags = coreSubtags( bundle );\n\t\t\t\tmaxBundle = coreLikelySubtags( Cldr, cldr, subtags );\n\t\t\t\tif ( maxBundle === undefined ) {\n\t\t\t\t\tavailableBundleMapQueue.splice( i, 1 );\n\t\t\t\t\tthrow new Error( \"Could not find likelySubtags for \" + bundle );\n\t\t\t\t}\n\t\t\t\tminBundle = coreRemoveLikelySubtags( Cldr, cldr, maxBundle );\n\t\t\t\tminBundle = minBundle.join( Cldr.localeSep );\n\t\t\t\texisting = availableBundleMap[ minBundle ];\n\t\t\t\tif ( existing && existing.length < bundle.length ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tavailableBundleMap[ minBundle ] = bundle;\n\t\t\t});\n\t\t\tCldr._availableBundleMapQueue = [];\n\t\t}\n\n\t\treturn availableBundleMap[ minLanguageId ] || null;\n\t};\n\n\n\n\n\tvar objectKeys = function( object ) {\n\t\tvar i,\n\t\t\tresult = [];\n\n\t\tif ( Object.keys ) {\n\t\t\treturn Object.keys( object );\n\t\t}\n\n\t\tfor ( i in object ) {\n\t\t\tresult.push( i );\n\t\t}\n\n\t\treturn result;\n\t};\n\n\n\n\n\tvar createError = function( code, attributes ) {\n\t\tvar error, message;\n\n\t\tmessage = code + ( attributes && JSON ? \": \" + JSON.stringify( attributes ) : \"\" );\n\t\terror = new Error( message );\n\t\terror.code = code;\n\n\t\t// extend( error, attributes );\n\t\tarrayForEach( objectKeys( attributes ), function( attribute ) {\n\t\t\terror[ attribute ] = attributes[ attribute ];\n\t\t});\n\n\t\treturn error;\n\t};\n\n\n\n\n\tvar validate = function( code, check, attributes ) {\n\t\tif ( !check ) {\n\t\t\tthrow createError( code, attributes );\n\t\t}\n\t};\n\n\n\n\n\tvar validatePresence = function( value, name ) {\n\t\tvalidate( \"E_MISSING_PARAMETER\", typeof value !== \"undefined\", {\n\t\t\tname: name\n\t\t});\n\t};\n\n\n\n\n\tvar validateType = function( value, name, check, expected ) {\n\t\tvalidate( \"E_INVALID_PAR_TYPE\", check, {\n\t\t\texpected: expected,\n\t\t\tname: name,\n\t\t\tvalue: value\n\t\t});\n\t};\n\n\n\n\n\tvar validateTypePath = function( value, name ) {\n\t\tvalidateType( value, name, typeof value === \"string\" || arrayIsArray( value ), \"String or Array\" );\n\t};\n\n\n\n\n\t/**\n\t * Function inspired by jQuery Core, but reduced to our use case.\n\t */\n\tvar isPlainObject = function( obj ) {\n\t\treturn obj !== null && \"\" + obj === \"[object Object]\";\n\t};\n\n\n\n\n\tvar validateTypePlainObject = function( value, name ) {\n\t\tvalidateType( value, name, typeof value === \"undefined\" || isPlainObject( value ), \"Plain Object\" );\n\t};\n\n\n\n\n\tvar validateTypeString = function( value, name ) {\n\t\tvalidateType( value, name, typeof value === \"string\", \"a string\" );\n\t};\n\n\n\n\n\t// @path: normalized path\n\tvar resourceGet = function( data, path ) {\n\t\tvar i,\n\t\t\tnode = data,\n\t\t\tlength = path.length;\n\n\t\tfor ( i = 0; i < length - 1; i++ ) {\n\t\t\tnode = node[ path[ i ] ];\n\t\t\tif ( !node ) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t}\n\t\treturn node[ path[ i ] ];\n\t};\n\n\n\n\n\t/**\n\t * setAvailableBundles( Cldr, json )\n\t *\n\t * @Cldr [Cldr class]\n\t *\n\t * @json resolved/unresolved cldr data.\n\t *\n\t * Set available bundles queue based on passed json CLDR data. Considers a bundle as any String at /main/{bundle}.\n\t */\n\tvar coreSetAvailableBundles = function( Cldr, json ) {\n\t\tvar bundle,\n\t\t\tavailableBundleMapQueue = Cldr._availableBundleMapQueue,\n\t\t\tmain = resourceGet( json, [ \"main\" ] );\n\n\t\tif ( main ) {\n\t\t\tfor ( bundle in main ) {\n\t\t\t\tif ( main.hasOwnProperty( bundle ) && bundle !== \"root\" &&\n\t\t\t\t\t\t\tavailableBundleMapQueue.indexOf( bundle ) === -1 ) {\n\t\t\t\t\tavailableBundleMapQueue.push( bundle );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n\n\n\n\tvar alwaysArray = function( somethingOrArray ) {\n\t\treturn arrayIsArray( somethingOrArray ) ?  somethingOrArray : [ somethingOrArray ];\n\t};\n\n\n\tvar jsonMerge = (function() {\n\n\t// Returns new deeply merged JSON.\n\t//\n\t// Eg.\n\t// merge( { a: { b: 1, c: 2 } }, { a: { b: 3, d: 4 } } )\n\t// -> { a: { b: 3, c: 2, d: 4 } }\n\t//\n\t// @arguments JSON's\n\t// \n\tvar merge = function() {\n\t\tvar destination = {},\n\t\t\tsources = [].slice.call( arguments, 0 );\n\t\tarrayForEach( sources, function( source ) {\n\t\t\tvar prop;\n\t\t\tfor ( prop in source ) {\n\t\t\t\tif ( prop in destination && typeof destination[ prop ] === \"object\" && !arrayIsArray( destination[ prop ] ) ) {\n\n\t\t\t\t\t// Merge Objects\n\t\t\t\t\tdestination[ prop ] = merge( destination[ prop ], source[ prop ] );\n\n\t\t\t\t} else {\n\n\t\t\t\t\t// Set new values\n\t\t\t\t\tdestination[ prop ] = source[ prop ];\n\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t\treturn destination;\n\t};\n\n\treturn merge;\n\n}());\n\n\n\t/**\n\t * load( Cldr, source, jsons )\n\t *\n\t * @Cldr [Cldr class]\n\t *\n\t * @source [Object]\n\t *\n\t * @jsons [arguments]\n\t */\n\tvar coreLoad = function( Cldr, source, jsons ) {\n\t\tvar i, j, json;\n\n\t\tvalidatePresence( jsons[ 0 ], \"json\" );\n\n\t\t// Support arbitrary parameters, e.g., `Cldr.load({...}, {...})`.\n\t\tfor ( i = 0; i < jsons.length; i++ ) {\n\n\t\t\t// Support array parameters, e.g., `Cldr.load([{...}, {...}])`.\n\t\t\tjson = alwaysArray( jsons[ i ] );\n\n\t\t\tfor ( j = 0; j < json.length; j++ ) {\n\t\t\t\tvalidateTypePlainObject( json[ j ], \"json\" );\n\t\t\t\tsource = jsonMerge( source, json[ j ] );\n\t\t\t\tcoreSetAvailableBundles( Cldr, json[ j ] );\n\t\t\t}\n\t\t}\n\n\t\treturn source;\n\t};\n\n\n\n\tvar itemGetResolved = function( Cldr, path, attributes ) {\n\t\t// Resolve path\n\t\tvar normalizedPath = pathNormalize( path, attributes );\n\n\t\treturn resourceGet( Cldr._resolved, normalizedPath );\n\t};\n\n\n\n\n\t/**\n\t * new Cldr()\n\t */\n\tvar Cldr = function( locale ) {\n\t\tthis.init( locale );\n\t};\n\n\t// Build optimization hack to avoid duplicating functions across modules.\n\tCldr._alwaysArray = alwaysArray;\n\tCldr._coreLoad = coreLoad;\n\tCldr._createError = createError;\n\tCldr._itemGetResolved = itemGetResolved;\n\tCldr._jsonMerge = jsonMerge;\n\tCldr._pathNormalize = pathNormalize;\n\tCldr._resourceGet = resourceGet;\n\tCldr._validatePresence = validatePresence;\n\tCldr._validateType = validateType;\n\tCldr._validateTypePath = validateTypePath;\n\tCldr._validateTypePlainObject = validateTypePlainObject;\n\n\tCldr._availableBundleMap = {};\n\tCldr._availableBundleMapQueue = [];\n\tCldr._resolved = {};\n\n\t// Allow user to override locale separator \"-\" (default) | \"_\". According to http://www.unicode.org/reports/tr35/#Unicode_language_identifier, both \"-\" and \"_\" are valid locale separators (eg. \"en_GB\", \"en-GB\"). According to http://unicode.org/cldr/trac/ticket/6786 its usage must be consistent throughout the data set.\n\tCldr.localeSep = \"-\";\n\n\t/**\n\t * Cldr.load( json [, json, ...] )\n\t *\n\t * @json [JSON] CLDR data or [Array] Array of @json's.\n\t *\n\t * Load resolved cldr data.\n\t */\n\tCldr.load = function() {\n\t\tCldr._resolved = coreLoad( Cldr, Cldr._resolved, arguments );\n\t};\n\n\t/**\n\t * .init() automatically run on instantiation/construction.\n\t */\n\tCldr.prototype.init = function( locale ) {\n\t\tvar attributes, language, maxLanguageId, minLanguageId, script, subtags, territory, unicodeLocaleExtensions, variant,\n\t\t\tsep = Cldr.localeSep,\n\t\t\tunicodeLocaleExtensionsRaw = \"\";\n\n\t\tvalidatePresence( locale, \"locale\" );\n\t\tvalidateTypeString( locale, \"locale\" );\n\n\t\tsubtags = coreSubtags( locale );\n\n\t\tif ( subtags.length === 5 ) {\n\t\t\tunicodeLocaleExtensions = subtags.pop();\n\t\t\tunicodeLocaleExtensionsRaw = sep + \"u\" + sep + unicodeLocaleExtensions;\n\t\t\t// Remove trailing null when there is unicodeLocaleExtensions but no variants.\n\t\t\tif ( !subtags[ 3 ] ) {\n\t\t\t\tsubtags.pop();\n\t\t\t}\n\t\t}\n\t\tvariant = subtags[ 3 ];\n\n\t\t// Normalize locale code.\n\t\t// Get (or deduce) the \"triple subtags\": language, territory (also aliased as region), and script subtags.\n\t\t// Get the variant subtags (calendar, collation, currency, etc).\n\t\t// refs:\n\t\t// - http://www.unicode.org/reports/tr35/#Field_Definitions\n\t\t// - http://www.unicode.org/reports/tr35/#Language_and_Locale_IDs\n\t\t// - http://www.unicode.org/reports/tr35/#Unicode_locale_identifier\n\n\t\t// When a locale id does not specify a language, or territory (region), or script, they are obtained by Likely Subtags.\n\t\tmaxLanguageId = coreLikelySubtags( Cldr, this, subtags, { force: true } ) || subtags;\n\t\tlanguage = maxLanguageId[ 0 ];\n\t\tscript = maxLanguageId[ 1 ];\n\t\tterritory = maxLanguageId[ 2 ];\n\n\t\tminLanguageId = coreRemoveLikelySubtags( Cldr, this, maxLanguageId ).join( sep );\n\n\t\t// Set attributes\n\t\tthis.attributes = attributes = {\n\t\t\tbundle: bundleLookup( Cldr, this, minLanguageId ),\n\n\t\t\t// Unicode Language Id\n\t\t\tminLanguageId: minLanguageId + unicodeLocaleExtensionsRaw,\n\t\t\tmaxLanguageId: maxLanguageId.join( sep ) + unicodeLocaleExtensionsRaw,\n\n\t\t\t// Unicode Language Id Subtabs\n\t\t\tlanguage: language,\n\t\t\tscript: script,\n\t\t\tterritory: territory,\n\t\t\tregion: territory, /* alias */\n\t\t\tvariant: variant\n\t\t};\n\n\t\t// Unicode locale extensions.\n\t\tunicodeLocaleExtensions && ( \"-\" + unicodeLocaleExtensions ).replace( /-[a-z]{3,8}|(-[a-z]{2})-([a-z]{3,8})/g, function( attribute, key, type ) {\n\n\t\t\tif ( key ) {\n\n\t\t\t\t// Extension is in the `keyword` form.\n\t\t\t\tattributes[ \"u\" + key ] = type;\n\t\t\t} else {\n\n\t\t\t\t// Extension is in the `attribute` form.\n\t\t\t\tattributes[ \"u\" + attribute ] = true;\n\t\t\t}\n\t\t});\n\n\t\tthis.locale = locale;\n\t};\n\n\t/**\n\t * .get()\n\t */\n\tCldr.prototype.get = function( path ) {\n\n\t\tvalidatePresence( path, \"path\" );\n\t\tvalidateTypePath( path, \"path\" );\n\n\t\treturn itemGetResolved( Cldr, path, this.attributes );\n\t};\n\n\t/**\n\t * .main()\n\t */\n\tCldr.prototype.main = function( path ) {\n\t\tvalidatePresence( path, \"path\" );\n\t\tvalidateTypePath( path, \"path\" );\n\n\t\tvalidate( \"E_MISSING_BUNDLE\", this.attributes.bundle !== null, {\n\t\t\tlocale: this.locale\n\t\t});\n\n\t\tpath = alwaysArray( path );\n\t\treturn this.get( [ \"main/{bundle}\" ].concat( path ) );\n\t};\n\n\treturn Cldr;\n\n\n\n\n}));\n","/**\n * CLDR JavaScript Library v0.5.4\n * http://jquery.com/\n *\n * Copyright 2013 Rafael Xavier de Souza\n * Released under the MIT license\n * http://jquery.org/license\n *\n * Date: 2020-10-22T15:56Z\n */\n/*!\n * CLDR JavaScript Library v0.5.4 2020-10-22T15:56Z MIT license © Rafael Xavier\n * http://git.io/h4lmVg\n */\n(function( factory ) {\n\n\tif ( typeof define === \"function\" && define.amd ) {\n\t\t// AMD.\n\t\tdefine( [ \"../cldr\" ], factory );\n\t} else if ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\t\t// Node. CommonJS.\n\t\tmodule.exports = factory( require( \"../cldr\" ) );\n\t} else {\n\t\t// Global\n\t\tfactory( Cldr );\n\t}\n\n}(function( Cldr ) {\n\n\t// Build optimization hack to avoid duplicating functions across modules.\n\tvar pathNormalize = Cldr._pathNormalize,\n\t\tvalidatePresence = Cldr._validatePresence,\n\t\tvalidateType = Cldr._validateType;\n\n/*!\n * EventEmitter v4.2.7 - git.io/ee\n * Oliver Caldwell\n * MIT license\n * @preserve\n */\n\nvar EventEmitter;\n/* jshint ignore:start */\nEventEmitter = (function () {\n\n\n\t/**\n\t * Class for managing events.\n\t * Can be extended to provide event functionality in other classes.\n\t *\n\t * @class EventEmitter Manages event registering and emitting.\n\t */\n\tfunction EventEmitter() {}\n\n\t// Shortcuts to improve speed and size\n\tvar proto = EventEmitter.prototype;\n\tvar exports = {};\n\t\n\n\t/**\n\t * Finds the index of the listener for the event in it's storage array.\n\t *\n\t * @param {Function[]} listeners Array of listeners to search through.\n\t * @param {Function} listener Method to look for.\n\t * @return {Number} Index of the specified listener, -1 if not found\n\t * @api private\n\t */\n\tfunction indexOfListener(listeners, listener) {\n\t\tvar i = listeners.length;\n\t\twhile (i--) {\n\t\t\tif (listeners[i].listener === listener) {\n\t\t\t\treturn i;\n\t\t\t}\n\t\t}\n\n\t\treturn -1;\n\t}\n\n\t/**\n\t * Alias a method while keeping the context correct, to allow for overwriting of target method.\n\t *\n\t * @param {String} name The name of the target method.\n\t * @return {Function} The aliased method\n\t * @api private\n\t */\n\tfunction alias(name) {\n\t\treturn function aliasClosure() {\n\t\t\treturn this[name].apply(this, arguments);\n\t\t};\n\t}\n\n\t/**\n\t * Returns the listener array for the specified event.\n\t * Will initialise the event object and listener arrays if required.\n\t * Will return an object if you use a regex search. The object contains keys for each matched event. So /ba[rz]/ might return an object containing bar and baz. But only if you have either defined them with defineEvent or added some listeners to them.\n\t * Each property in the object response is an array of listener functions.\n\t *\n\t * @param {String|RegExp} evt Name of the event to return the listeners from.\n\t * @return {Function[]|Object} All listener functions for the event.\n\t */\n\tproto.getListeners = function getListeners(evt) {\n\t\tvar events = this._getEvents();\n\t\tvar response;\n\t\tvar key;\n\n\t\t// Return a concatenated array of all matching events if\n\t\t// the selector is a regular expression.\n\t\tif (evt instanceof RegExp) {\n\t\t\tresponse = {};\n\t\t\tfor (key in events) {\n\t\t\t\tif (events.hasOwnProperty(key) && evt.test(key)) {\n\t\t\t\t\tresponse[key] = events[key];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\tresponse = events[evt] || (events[evt] = []);\n\t\t}\n\n\t\treturn response;\n\t};\n\n\t/**\n\t * Takes a list of listener objects and flattens it into a list of listener functions.\n\t *\n\t * @param {Object[]} listeners Raw listener objects.\n\t * @return {Function[]} Just the listener functions.\n\t */\n\tproto.flattenListeners = function flattenListeners(listeners) {\n\t\tvar flatListeners = [];\n\t\tvar i;\n\n\t\tfor (i = 0; i < listeners.length; i += 1) {\n\t\t\tflatListeners.push(listeners[i].listener);\n\t\t}\n\n\t\treturn flatListeners;\n\t};\n\n\t/**\n\t * Fetches the requested listeners via getListeners but will always return the results inside an object. This is mainly for internal use but others may find it useful.\n\t *\n\t * @param {String|RegExp} evt Name of the event to return the listeners from.\n\t * @return {Object} All listener functions for an event in an object.\n\t */\n\tproto.getListenersAsObject = function getListenersAsObject(evt) {\n\t\tvar listeners = this.getListeners(evt);\n\t\tvar response;\n\n\t\tif (listeners instanceof Array) {\n\t\t\tresponse = {};\n\t\t\tresponse[evt] = listeners;\n\t\t}\n\n\t\treturn response || listeners;\n\t};\n\n\t/**\n\t * Adds a listener function to the specified event.\n\t * The listener will not be added if it is a duplicate.\n\t * If the listener returns true then it will be removed after it is called.\n\t * If you pass a regular expression as the event name then the listener will be added to all events that match it.\n\t *\n\t * @param {String|RegExp} evt Name of the event to attach the listener to.\n\t * @param {Function} listener Method to be called when the event is emitted. If the function returns true then it will be removed after calling.\n\t * @return {Object} Current instance of EventEmitter for chaining.\n\t */\n\tproto.addListener = function addListener(evt, listener) {\n\t\tvar listeners = this.getListenersAsObject(evt);\n\t\tvar listenerIsWrapped = typeof listener === 'object';\n\t\tvar key;\n\n\t\tfor (key in listeners) {\n\t\t\tif (listeners.hasOwnProperty(key) && indexOfListener(listeners[key], listener) === -1) {\n\t\t\t\tlisteners[key].push(listenerIsWrapped ? listener : {\n\t\t\t\t\tlistener: listener,\n\t\t\t\t\tonce: false\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t};\n\n\t/**\n\t * Alias of addListener\n\t */\n\tproto.on = alias('addListener');\n\n\t/**\n\t * Semi-alias of addListener. It will add a listener that will be\n\t * automatically removed after it's first execution.\n\t *\n\t * @param {String|RegExp} evt Name of the event to attach the listener to.\n\t * @param {Function} listener Method to be called when the event is emitted. If the function returns true then it will be removed after calling.\n\t * @return {Object} Current instance of EventEmitter for chaining.\n\t */\n\tproto.addOnceListener = function addOnceListener(evt, listener) {\n\t\treturn this.addListener(evt, {\n\t\t\tlistener: listener,\n\t\t\tonce: true\n\t\t});\n\t};\n\n\t/**\n\t * Alias of addOnceListener.\n\t */\n\tproto.once = alias('addOnceListener');\n\n\t/**\n\t * Defines an event name. This is required if you want to use a regex to add a listener to multiple events at once. If you don't do this then how do you expect it to know what event to add to? Should it just add to every possible match for a regex? No. That is scary and bad.\n\t * You need to tell it what event names should be matched by a regex.\n\t *\n\t * @param {String} evt Name of the event to create.\n\t * @return {Object} Current instance of EventEmitter for chaining.\n\t */\n\tproto.defineEvent = function defineEvent(evt) {\n\t\tthis.getListeners(evt);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Uses defineEvent to define multiple events.\n\t *\n\t * @param {String[]} evts An array of event names to define.\n\t * @return {Object} Current instance of EventEmitter for chaining.\n\t */\n\tproto.defineEvents = function defineEvents(evts) {\n\t\tfor (var i = 0; i < evts.length; i += 1) {\n\t\t\tthis.defineEvent(evts[i]);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Removes a listener function from the specified event.\n\t * When passed a regular expression as the event name, it will remove the listener from all events that match it.\n\t *\n\t * @param {String|RegExp} evt Name of the event to remove the listener from.\n\t * @param {Function} listener Method to remove from the event.\n\t * @return {Object} Current instance of EventEmitter for chaining.\n\t */\n\tproto.removeListener = function removeListener(evt, listener) {\n\t\tvar listeners = this.getListenersAsObject(evt);\n\t\tvar index;\n\t\tvar key;\n\n\t\tfor (key in listeners) {\n\t\t\tif (listeners.hasOwnProperty(key)) {\n\t\t\t\tindex = indexOfListener(listeners[key], listener);\n\n\t\t\t\tif (index !== -1) {\n\t\t\t\t\tlisteners[key].splice(index, 1);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t};\n\n\t/**\n\t * Alias of removeListener\n\t */\n\tproto.off = alias('removeListener');\n\n\t/**\n\t * Adds listeners in bulk using the manipulateListeners method.\n\t * If you pass an object as the second argument you can add to multiple events at once. The object should contain key value pairs of events and listeners or listener arrays. You can also pass it an event name and an array of listeners to be added.\n\t * You can also pass it a regular expression to add the array of listeners to all events that match it.\n\t * Yeah, this function does quite a bit. That's probably a bad thing.\n\t *\n\t * @param {String|Object|RegExp} evt An event name if you will pass an array of listeners next. An object if you wish to add to multiple events at once.\n\t * @param {Function[]} [listeners] An optional array of listener functions to add.\n\t * @return {Object} Current instance of EventEmitter for chaining.\n\t */\n\tproto.addListeners = function addListeners(evt, listeners) {\n\t\t// Pass through to manipulateListeners\n\t\treturn this.manipulateListeners(false, evt, listeners);\n\t};\n\n\t/**\n\t * Removes listeners in bulk using the manipulateListeners method.\n\t * If you pass an object as the second argument you can remove from multiple events at once. The object should contain key value pairs of events and listeners or listener arrays.\n\t * You can also pass it an event name and an array of listeners to be removed.\n\t * You can also pass it a regular expression to remove the listeners from all events that match it.\n\t *\n\t * @param {String|Object|RegExp} evt An event name if you will pass an array of listeners next. An object if you wish to remove from multiple events at once.\n\t * @param {Function[]} [listeners] An optional array of listener functions to remove.\n\t * @return {Object} Current instance of EventEmitter for chaining.\n\t */\n\tproto.removeListeners = function removeListeners(evt, listeners) {\n\t\t// Pass through to manipulateListeners\n\t\treturn this.manipulateListeners(true, evt, listeners);\n\t};\n\n\t/**\n\t * Edits listeners in bulk. The addListeners and removeListeners methods both use this to do their job. You should really use those instead, this is a little lower level.\n\t * The first argument will determine if the listeners are removed (true) or added (false).\n\t * If you pass an object as the second argument you can add/remove from multiple events at once. The object should contain key value pairs of events and listeners or listener arrays.\n\t * You can also pass it an event name and an array of listeners to be added/removed.\n\t * You can also pass it a regular expression to manipulate the listeners of all events that match it.\n\t *\n\t * @param {Boolean} remove True if you want to remove listeners, false if you want to add.\n\t * @param {String|Object|RegExp} evt An event name if you will pass an array of listeners next. An object if you wish to add/remove from multiple events at once.\n\t * @param {Function[]} [listeners] An optional array of listener functions to add/remove.\n\t * @return {Object} Current instance of EventEmitter for chaining.\n\t */\n\tproto.manipulateListeners = function manipulateListeners(remove, evt, listeners) {\n\t\tvar i;\n\t\tvar value;\n\t\tvar single = remove ? this.removeListener : this.addListener;\n\t\tvar multiple = remove ? this.removeListeners : this.addListeners;\n\n\t\t// If evt is an object then pass each of it's properties to this method\n\t\tif (typeof evt === 'object' && !(evt instanceof RegExp)) {\n\t\t\tfor (i in evt) {\n\t\t\t\tif (evt.hasOwnProperty(i) && (value = evt[i])) {\n\t\t\t\t\t// Pass the single listener straight through to the singular method\n\t\t\t\t\tif (typeof value === 'function') {\n\t\t\t\t\t\tsingle.call(this, i, value);\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\t// Otherwise pass back to the multiple function\n\t\t\t\t\t\tmultiple.call(this, i, value);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\t// So evt must be a string\n\t\t\t// And listeners must be an array of listeners\n\t\t\t// Loop over it and pass each one to the multiple method\n\t\t\ti = listeners.length;\n\t\t\twhile (i--) {\n\t\t\t\tsingle.call(this, evt, listeners[i]);\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t};\n\n\t/**\n\t * Removes all listeners from a specified event.\n\t * If you do not specify an event then all listeners will be removed.\n\t * That means every event will be emptied.\n\t * You can also pass a regex to remove all events that match it.\n\t *\n\t * @param {String|RegExp} [evt] Optional name of the event to remove all listeners for. Will remove from every event if not passed.\n\t * @return {Object} Current instance of EventEmitter for chaining.\n\t */\n\tproto.removeEvent = function removeEvent(evt) {\n\t\tvar type = typeof evt;\n\t\tvar events = this._getEvents();\n\t\tvar key;\n\n\t\t// Remove different things depending on the state of evt\n\t\tif (type === 'string') {\n\t\t\t// Remove all listeners for the specified event\n\t\t\tdelete events[evt];\n\t\t}\n\t\telse if (evt instanceof RegExp) {\n\t\t\t// Remove all events matching the regex.\n\t\t\tfor (key in events) {\n\t\t\t\tif (events.hasOwnProperty(key) && evt.test(key)) {\n\t\t\t\t\tdelete events[key];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\t// Remove all listeners in all events\n\t\t\tdelete this._events;\n\t\t}\n\n\t\treturn this;\n\t};\n\n\t/**\n\t * Alias of removeEvent.\n\t *\n\t * Added to mirror the node API.\n\t */\n\tproto.removeAllListeners = alias('removeEvent');\n\n\t/**\n\t * Emits an event of your choice.\n\t * When emitted, every listener attached to that event will be executed.\n\t * If you pass the optional argument array then those arguments will be passed to every listener upon execution.\n\t * Because it uses `apply`, your array of arguments will be passed as if you wrote them out separately.\n\t * So they will not arrive within the array on the other side, they will be separate.\n\t * You can also pass a regular expression to emit to all events that match it.\n\t *\n\t * @param {String|RegExp} evt Name of the event to emit and execute listeners for.\n\t * @param {Array} [args] Optional array of arguments to be passed to each listener.\n\t * @return {Object} Current instance of EventEmitter for chaining.\n\t */\n\tproto.emitEvent = function emitEvent(evt, args) {\n\t\tvar listeners = this.getListenersAsObject(evt);\n\t\tvar listener;\n\t\tvar i;\n\t\tvar key;\n\t\tvar response;\n\n\t\tfor (key in listeners) {\n\t\t\tif (listeners.hasOwnProperty(key)) {\n\t\t\t\ti = listeners[key].length;\n\n\t\t\t\twhile (i--) {\n\t\t\t\t\t// If the listener returns true then it shall be removed from the event\n\t\t\t\t\t// The function is executed either with a basic call or an apply if there is an args array\n\t\t\t\t\tlistener = listeners[key][i];\n\n\t\t\t\t\tif (listener.once === true) {\n\t\t\t\t\t\tthis.removeListener(evt, listener.listener);\n\t\t\t\t\t}\n\n\t\t\t\t\tresponse = listener.listener.apply(this, args || []);\n\n\t\t\t\t\tif (response === this._getOnceReturnValue()) {\n\t\t\t\t\t\tthis.removeListener(evt, listener.listener);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t};\n\n\t/**\n\t * Alias of emitEvent\n\t */\n\tproto.trigger = alias('emitEvent');\n\n\t/**\n\t * Subtly different from emitEvent in that it will pass its arguments on to the listeners, as opposed to taking a single array of arguments to pass on.\n\t * As with emitEvent, you can pass a regex in place of the event name to emit to all events that match it.\n\t *\n\t * @param {String|RegExp} evt Name of the event to emit and execute listeners for.\n\t * @param {...*} Optional additional arguments to be passed to each listener.\n\t * @return {Object} Current instance of EventEmitter for chaining.\n\t */\n\tproto.emit = function emit(evt) {\n\t\tvar args = Array.prototype.slice.call(arguments, 1);\n\t\treturn this.emitEvent(evt, args);\n\t};\n\n\t/**\n\t * Sets the current value to check against when executing listeners. If a\n\t * listeners return value matches the one set here then it will be removed\n\t * after execution. This value defaults to true.\n\t *\n\t * @param {*} value The new value to check for when executing listeners.\n\t * @return {Object} Current instance of EventEmitter for chaining.\n\t */\n\tproto.setOnceReturnValue = function setOnceReturnValue(value) {\n\t\tthis._onceReturnValue = value;\n\t\treturn this;\n\t};\n\n\t/**\n\t * Fetches the current value to check against when executing listeners. If\n\t * the listeners return value matches this one then it should be removed\n\t * automatically. It will return true by default.\n\t *\n\t * @return {*|Boolean} The current value to check for or the default, true.\n\t * @api private\n\t */\n\tproto._getOnceReturnValue = function _getOnceReturnValue() {\n\t\tif (this.hasOwnProperty('_onceReturnValue')) {\n\t\t\treturn this._onceReturnValue;\n\t\t}\n\t\telse {\n\t\t\treturn true;\n\t\t}\n\t};\n\n\t/**\n\t * Fetches the events object and creates one if required.\n\t *\n\t * @return {Object} The events storage object.\n\t * @api private\n\t */\n\tproto._getEvents = function _getEvents() {\n\t\treturn this._events || (this._events = {});\n\t};\n\n\t/**\n\t * Reverts the global {@link EventEmitter} to its previous value and returns a reference to this version.\n\t *\n\t * @return {Function} Non conflicting EventEmitter class.\n\t */\n\tEventEmitter.noConflict = function noConflict() {\n\t\texports.EventEmitter = originalGlobalValue;\n\t\treturn EventEmitter;\n\t};\n\n\treturn EventEmitter;\n}());\n/* jshint ignore:end */\n\n\n\n\tvar validateTypeFunction = function( value, name ) {\n\t\tvalidateType( value, name, typeof value === \"undefined\" || typeof value === \"function\", \"Function\" );\n\t};\n\n\n\n\n\tvar superGet, superInit,\n\t\tglobalEe = new EventEmitter();\n\n\tfunction validateTypeEvent( value, name ) {\n\t\tvalidateType( value, name, typeof value === \"string\" || value instanceof RegExp, \"String or RegExp\" );\n\t}\n\n\tfunction validateThenCall( method, self ) {\n\t\treturn function( event, listener ) {\n\t\t\tvalidatePresence( event, \"event\" );\n\t\t\tvalidateTypeEvent( event, \"event\" );\n\n\t\t\tvalidatePresence( listener, \"listener\" );\n\t\t\tvalidateTypeFunction( listener, \"listener\" );\n\n\t\t\treturn self[ method ].apply( self, arguments );\n\t\t};\n\t}\n\n\tfunction off( self ) {\n\t\treturn validateThenCall( \"off\", self );\n\t}\n\n\tfunction on( self ) {\n\t\treturn validateThenCall( \"on\", self );\n\t}\n\n\tfunction once( self ) {\n\t\treturn validateThenCall( \"once\", self );\n\t}\n\n\tCldr.off = off( globalEe );\n\tCldr.on = on( globalEe );\n\tCldr.once = once( globalEe );\n\n\t/**\n\t * Overload Cldr.prototype.init().\n\t */\n\tsuperInit = Cldr.prototype.init;\n\tCldr.prototype.init = function() {\n\t\tvar ee;\n\t\tthis.ee = ee = new EventEmitter();\n\t\tthis.off = off( ee );\n\t\tthis.on = on( ee );\n\t\tthis.once = once( ee );\n\t\tsuperInit.apply( this, arguments );\n\t};\n\n\t/**\n\t * getOverload is encapsulated, because of cldr/unresolved. If it's loaded\n\t * after cldr/event (and note it overwrites .get), it can trigger this\n\t * overload again.\n\t */\n\tfunction getOverload() {\n\n\t\t/**\n\t\t * Overload Cldr.prototype.get().\n\t\t */\n\t\tsuperGet = Cldr.prototype.get;\n\t\tCldr.prototype.get = function( path ) {\n\t\t\tvar value = superGet.apply( this, arguments );\n\t\t\tpath = pathNormalize( path, this.attributes ).join( \"/\" );\n\t\t\tglobalEe.trigger( \"get\", [ path, value ] );\n\t\t\tthis.ee.trigger( \"get\", [ path, value ] );\n\t\t\treturn value;\n\t\t};\n\t}\n\n\tCldr._eventInit = getOverload;\n\tgetOverload();\n\n\treturn Cldr;\n\n\n\n\n}));\n","/**\n * CLDR JavaScript Library v0.5.4\n * http://jquery.com/\n *\n * Copyright 2013 Rafael Xavier de Souza\n * Released under the MIT license\n * http://jquery.org/license\n *\n * Date: 2020-10-22T15:56Z\n */\n/*!\n * CLDR JavaScript Library v0.5.4 2020-10-22T15:56Z MIT license © Rafael Xavier\n * http://git.io/h4lmVg\n */\n(function( factory ) {\n\n\tif ( typeof define === \"function\" && define.amd ) {\n\t\t// AMD.\n\t\tdefine( [ \"../cldr\" ], factory );\n\t} else if ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\t\t// Node. CommonJS.\n\t\tmodule.exports = factory( require( \"../cldr\" ) );\n\t} else {\n\t\t// Global\n\t\tfactory( Cldr );\n\t}\n\n}(function( Cldr ) {\n\n\t// Build optimization hack to avoid duplicating functions across modules.\n\tvar alwaysArray = Cldr._alwaysArray;\n\n\n\n\tvar supplementalMain = function( cldr ) {\n\n\t\tvar prepend, supplemental;\n\t\t\n\t\tprepend = function( prepend ) {\n\t\t\treturn function( path ) {\n\t\t\t\tpath = alwaysArray( path );\n\t\t\t\treturn cldr.get( [ prepend ].concat( path ) );\n\t\t\t};\n\t\t};\n\n\t\tsupplemental = prepend( \"supplemental\" );\n\n\t\t// Week Data\n\t\t// http://www.unicode.org/reports/tr35/tr35-dates.html#Week_Data\n\t\tsupplemental.weekData = prepend( \"supplemental/weekData\" );\n\n\t\tsupplemental.weekData.firstDay = function() {\n\t\t\treturn cldr.get( \"supplemental/weekData/firstDay/{territory}\" ) ||\n\t\t\t\tcldr.get( \"supplemental/weekData/firstDay/001\" );\n\t\t};\n\n\t\tsupplemental.weekData.minDays = function() {\n\t\t\tvar minDays = cldr.get( \"supplemental/weekData/minDays/{territory}\" ) ||\n\t\t\t\tcldr.get( \"supplemental/weekData/minDays/001\" );\n\t\t\treturn parseInt( minDays, 10 );\n\t\t};\n\n\t\t// Time Data\n\t\t// http://www.unicode.org/reports/tr35/tr35-dates.html#Time_Data\n\t\tsupplemental.timeData = prepend( \"supplemental/timeData\" );\n\n\t\tsupplemental.timeData.allowed = function() {\n\t\t\treturn cldr.get( \"supplemental/timeData/{territory}/_allowed\" ) ||\n\t\t\t\tcldr.get( \"supplemental/timeData/001/_allowed\" );\n\t\t};\n\n\t\tsupplemental.timeData.preferred = function() {\n\t\t\treturn cldr.get( \"supplemental/timeData/{territory}/_preferred\" ) ||\n\t\t\t\tcldr.get( \"supplemental/timeData/001/_preferred\" );\n\t\t};\n\n\t\treturn supplemental;\n\n\t};\n\n\n\n\n\tvar initSuper = Cldr.prototype.init;\n\n\t/**\n\t * .init() automatically ran on construction.\n\t *\n\t * Overload .init().\n\t */\n\tCldr.prototype.init = function() {\n\t\tinitSuper.apply( this, arguments );\n\t\tthis.supplemental = supplementalMain( this );\n\t};\n\n\treturn Cldr;\n\n\n\n\n}));\n","/**\n * CLDR JavaScript Library v0.5.4\n * http://jquery.com/\n *\n * Copyright 2013 Rafael Xavier de Souza\n * Released under the MIT license\n * http://jquery.org/license\n *\n * Date: 2020-10-22T15:56Z\n */\n/*!\n * CLDR JavaScript Library v0.5.4 2020-10-22T15:56Z MIT license © Rafael Xavier\n * http://git.io/h4lmVg\n */\n(function( factory ) {\n\n\tif ( typeof define === \"function\" && define.amd ) {\n\t\t// AMD.\n\t\tdefine( [ \"../cldr\" ], factory );\n\t} else if ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\t\t// Node. CommonJS.\n\t\tmodule.exports = factory( require( \"../cldr\" ) );\n\t} else {\n\t\t// Global\n\t\tfactory( Cldr );\n\t}\n\n}(function( Cldr ) {\n\n\t// Build optimization hack to avoid duplicating functions across modules.\n\tvar coreLoad = Cldr._coreLoad;\n\tvar jsonMerge = Cldr._jsonMerge;\n\tvar pathNormalize = Cldr._pathNormalize;\n\tvar resourceGet = Cldr._resourceGet;\n\tvar validatePresence = Cldr._validatePresence;\n\tvar validateTypePath = Cldr._validateTypePath;\n\n\n\n\tvar bundleParentLookup = function( Cldr, locale ) {\n\t\tvar normalizedPath, parent;\n\n\t\tif ( locale === \"root\" ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// First, try to find parent on supplemental data.\n\t\tnormalizedPath = pathNormalize( [ \"supplemental/parentLocales/parentLocale\", locale ] );\n\t\tparent = resourceGet( Cldr._resolved, normalizedPath ) || resourceGet( Cldr._raw, normalizedPath );\n\t\tif ( parent ) {\n\t\t\treturn parent;\n\t\t}\n\n\t\t// Or truncate locale.\n\t\tparent = locale.substr( 0, locale.lastIndexOf( Cldr.localeSep ) );\n\t\tif ( !parent ) {\n\t\t\treturn \"root\";\n\t\t}\n\n\t\treturn parent;\n\t};\n\n\n\n\n\t// @path: normalized path\n\tvar resourceSet = function( data, path, value ) {\n\t\tvar i,\n\t\t\tnode = data,\n\t\t\tlength = path.length;\n\n\t\tfor ( i = 0; i < length - 1; i++ ) {\n\t\t\tif ( !node[ path[ i ] ] ) {\n\t\t\t\tnode[ path[ i ] ] = {};\n\t\t\t}\n\t\t\tnode = node[ path[ i ] ];\n\t\t}\n\t\tnode[ path[ i ] ] = value;\n\t};\n\n\n\tvar itemLookup = (function() {\n\n\tvar lookup;\n\n\tlookup = function( Cldr, locale, path, attributes, childLocale ) {\n\t\tvar normalizedPath, parent, value;\n\n\t\t// 1: Finish recursion\n\t\t// 2: Avoid infinite loop\n\t\tif ( typeof locale === \"undefined\" /* 1 */ || locale === childLocale /* 2 */ ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Resolve path\n\t\tnormalizedPath = pathNormalize( path, attributes );\n\n\t\t// Check resolved (cached) data first\n\t\t// 1: Due to #16, never use the cached resolved non-leaf nodes. It may not\n\t\t//    represent its leafs in its entirety.\n\t\tvalue = resourceGet( Cldr._resolved, normalizedPath );\n\t\tif ( value !== undefined && typeof value !== \"object\" /* 1 */ ) {\n\t\t\treturn value;\n\t\t}\n\n\t\t// Check raw data\n\t\tvalue = resourceGet( Cldr._raw, normalizedPath );\n\n\t\tif ( value === undefined ) {\n\t\t\t// Or, lookup at parent locale\n\t\t\tparent = bundleParentLookup( Cldr, locale );\n\t\t\tvalue = lookup( Cldr, parent, path, jsonMerge( attributes, { bundle: parent }), locale );\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\t// Set resolved (cached)\n\t\t\tresourceSet( Cldr._resolved, normalizedPath, value );\n\t\t}\n\n\t\treturn value;\n\t};\n\n\treturn lookup;\n\n}());\n\n\n\tCldr._raw = {};\n\n\t/**\n\t * Cldr.load( json [, json, ...] )\n\t *\n\t * @json [JSON] CLDR data or [Array] Array of @json's.\n\t *\n\t * Load resolved or unresolved cldr data.\n\t * Overwrite Cldr.load().\n\t */\n\tCldr.load = function() {\n\t\tCldr._raw = coreLoad( Cldr, Cldr._raw, arguments );\n\t};\n\n\t/**\n\t * Overwrite Cldr.prototype.get().\n\t */\n\tCldr.prototype.get = function( path ) {\n\t\tvalidatePresence( path, \"path\" );\n\t\tvalidateTypePath( path, \"path\" );\n\n\t\t// 1: use bundle as locale on item lookup for simplification purposes, because no other extended subtag is used anyway on bundle parent lookup.\n\t\t// 2: during init(), this method is called, but bundle is yet not defined. Use \"\" as a workaround in this very specific scenario.\n\t\treturn itemLookup( Cldr, this.attributes && this.attributes.bundle /* 1 */ || \"\" /* 2 */, path, this.attributes );\n\t};\n\n\t// In case cldr/unresolved is loaded after cldr/event, we trigger its overloads again. Because, .get is overwritten in here.\n\tif ( Cldr._eventInit ) {\n\t\tCldr._eventInit();\n\t}\n\n\treturn Cldr;\n\n\n\n\n}));\n","/**\n * CLDR JavaScript Library v0.5.4\n * http://jquery.com/\n *\n * Copyright 2013 Rafael Xavier de Souza\n * Released under the MIT license\n * http://jquery.org/license\n *\n * Date: 2020-10-22T15:56Z\n */\n/*!\n * CLDR JavaScript Library v0.5.4 2020-10-22T15:56Z MIT license © Rafael Xavier\n * http://git.io/h4lmVg\n */\n\n// Cldr\nmodule.exports = require( \"./cldr\" );\n\n// Extent Cldr with the following modules\nrequire( \"./cldr/event\" );\nrequire( \"./cldr/supplemental\" );\nrequire( \"./cldr/unresolved\" );\n","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nexports.__esModule = true;\nexports.default = addClass;\n\nvar _hasClass = _interopRequireDefault(require(\"./hasClass\"));\n\nfunction addClass(element, className) {\n  if (element.classList) element.classList.add(className);else if (!(0, _hasClass.default)(element, className)) if (typeof element.className === 'string') element.className = element.className + ' ' + className;else element.setAttribute('class', (element.className && element.className.baseVal || '') + ' ' + className);\n}\n\nmodule.exports = exports[\"default\"];","\"use strict\";\n\nexports.__esModule = true;\nexports.default = hasClass;\n\nfunction hasClass(element, className) {\n  if (element.classList) return !!className && element.classList.contains(className);else return (\" \" + (element.className.baseVal || element.className) + \" \").indexOf(\" \" + className + \" \") !== -1;\n}\n\nmodule.exports = exports[\"default\"];","'use strict';\n\nfunction replaceClassName(origClass, classToRemove) {\n  return origClass.replace(new RegExp('(^|\\\\s)' + classToRemove + '(?:\\\\s|$)', 'g'), '$1').replace(/\\s+/g, ' ').replace(/^\\s*|\\s*$/g, '');\n}\n\nmodule.exports = function removeClass(element, className) {\n  if (element.classList) element.classList.remove(className);else if (typeof element.className === 'string') element.className = replaceClassName(element.className, className);else element.setAttribute('class', replaceClassName(element.className && element.className.baseVal || '', className));\n};","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nexports.__esModule = true;\nexports.default = exports.animationEnd = exports.animationDelay = exports.animationTiming = exports.animationDuration = exports.animationName = exports.transitionEnd = exports.transitionDuration = exports.transitionDelay = exports.transitionTiming = exports.transitionProperty = exports.transform = void 0;\n\nvar _inDOM = _interopRequireDefault(require(\"../util/inDOM\"));\n\nvar transform = 'transform';\nexports.transform = transform;\nvar prefix, transitionEnd, animationEnd;\nexports.animationEnd = animationEnd;\nexports.transitionEnd = transitionEnd;\nvar transitionProperty, transitionDuration, transitionTiming, transitionDelay;\nexports.transitionDelay = transitionDelay;\nexports.transitionTiming = transitionTiming;\nexports.transitionDuration = transitionDuration;\nexports.transitionProperty = transitionProperty;\nvar animationName, animationDuration, animationTiming, animationDelay;\nexports.animationDelay = animationDelay;\nexports.animationTiming = animationTiming;\nexports.animationDuration = animationDuration;\nexports.animationName = animationName;\n\nif (_inDOM.default) {\n  var _getTransitionPropert = getTransitionProperties();\n\n  prefix = _getTransitionPropert.prefix;\n  exports.transitionEnd = transitionEnd = _getTransitionPropert.transitionEnd;\n  exports.animationEnd = animationEnd = _getTransitionPropert.animationEnd;\n  exports.transform = transform = prefix + \"-\" + transform;\n  exports.transitionProperty = transitionProperty = prefix + \"-transition-property\";\n  exports.transitionDuration = transitionDuration = prefix + \"-transition-duration\";\n  exports.transitionDelay = transitionDelay = prefix + \"-transition-delay\";\n  exports.transitionTiming = transitionTiming = prefix + \"-transition-timing-function\";\n  exports.animationName = animationName = prefix + \"-animation-name\";\n  exports.animationDuration = animationDuration = prefix + \"-animation-duration\";\n  exports.animationTiming = animationTiming = prefix + \"-animation-delay\";\n  exports.animationDelay = animationDelay = prefix + \"-animation-timing-function\";\n}\n\nvar _default = {\n  transform: transform,\n  end: transitionEnd,\n  property: transitionProperty,\n  timing: transitionTiming,\n  delay: transitionDelay,\n  duration: transitionDuration\n};\nexports.default = _default;\n\nfunction getTransitionProperties() {\n  var style = document.createElement('div').style;\n  var vendorMap = {\n    O: function O(e) {\n      return \"o\" + e.toLowerCase();\n    },\n    Moz: function Moz(e) {\n      return e.toLowerCase();\n    },\n    Webkit: function Webkit(e) {\n      return \"webkit\" + e;\n    },\n    ms: function ms(e) {\n      return \"MS\" + e;\n    }\n  };\n  var vendors = Object.keys(vendorMap);\n  var transitionEnd, animationEnd;\n  var prefix = '';\n\n  for (var i = 0; i < vendors.length; i++) {\n    var vendor = vendors[i];\n\n    if (vendor + \"TransitionProperty\" in style) {\n      prefix = \"-\" + vendor.toLowerCase();\n      transitionEnd = vendorMap[vendor]('TransitionEnd');\n      animationEnd = vendorMap[vendor]('AnimationEnd');\n      break;\n    }\n  }\n\n  if (!transitionEnd && 'transitionProperty' in style) transitionEnd = 'transitionend';\n  if (!animationEnd && 'animationName' in style) animationEnd = 'animationend';\n  style = null;\n  return {\n    animationEnd: animationEnd,\n    transitionEnd: transitionEnd,\n    prefix: prefix\n  };\n}","\"use strict\";\n\nexports.__esModule = true;\nexports.default = void 0;\n\nvar _default = !!(typeof window !== 'undefined' && window.document && window.document.createElement);\n\nexports.default = _default;\nmodule.exports = exports[\"default\"];","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nexports.__esModule = true;\nexports.default = void 0;\n\nvar _inDOM = _interopRequireDefault(require(\"./inDOM\"));\n\nvar vendors = ['', 'webkit', 'moz', 'o', 'ms'];\nvar cancel = 'clearTimeout';\nvar raf = fallback;\nvar compatRaf;\n\nvar getKey = function getKey(vendor, k) {\n  return vendor + (!vendor ? k : k[0].toUpperCase() + k.substr(1)) + 'AnimationFrame';\n};\n\nif (_inDOM.default) {\n  vendors.some(function (vendor) {\n    var rafKey = getKey(vendor, 'request');\n\n    if (rafKey in window) {\n      cancel = getKey(vendor, 'cancel');\n      return raf = function raf(cb) {\n        return window[rafKey](cb);\n      };\n    }\n  });\n}\n/* https://github.com/component/raf */\n\n\nvar prev = new Date().getTime();\n\nfunction fallback(fn) {\n  var curr = new Date().getTime(),\n      ms = Math.max(0, 16 - (curr - prev)),\n      req = setTimeout(fn, ms);\n  prev = curr;\n  return req;\n}\n\ncompatRaf = function compatRaf(cb) {\n  return raf(cb);\n};\n\ncompatRaf.cancel = function (id) {\n  window[cancel] && typeof window[cancel] === 'function' && window[cancel](id);\n};\n\nvar _default = compatRaf;\nexports.default = _default;\nmodule.exports = exports[\"default\"];","/**\n * Globalize v1.7.0\n *\n * https://github.com/globalizejs/globalize\n *\n * Copyright OpenJS Foundation and other contributors\n * Released under the MIT license\n * https://jquery.org/license\n *\n * Date: 2021-08-02T11:53Z\n */\n/*!\n * Globalize v1.7.0 2021-08-02T11:53Z Released under the MIT license\n * http://git.io/TrdQbw\n */\n(function( root, factory ) {\n\n\t// UMD returnExports\n\tif ( typeof define === \"function\" && define.amd ) {\n\n\t\t// AMD\n\t\tdefine([\n\t\t\t\"cldr\",\n\t\t\t\"cldr/event\"\n\t\t], factory );\n\t} else if ( typeof exports === \"object\" ) {\n\n\t\t// Node, CommonJS\n\t\tmodule.exports = factory( require( \"cldrjs\" ) );\n\t} else {\n\n\t\t// Global\n\t\troot.Globalize = factory( root.Cldr );\n\t}\n}( this, function( Cldr ) {\n\n\n/**\n * A toString method that outputs meaningful values for objects or arrays and\n * still performs as fast as a plain string in case variable is string, or as\n * fast as `\"\" + number` in case variable is a number.\n * Ref: http://jsperf.com/my-stringify\n */\nvar toString = function( variable ) {\n\treturn typeof variable === \"string\" ? variable : ( typeof variable === \"number\" ? \"\" +\n\t\tvariable : JSON.stringify( variable ) );\n};\n\n\n\n\n/**\n * formatMessage( message, data )\n *\n * @message [String] A message with optional {vars} to be replaced.\n *\n * @data [Array or JSON] Object with replacing-variables content.\n *\n * Return the formatted message. For example:\n *\n * - formatMessage( \"{0} second\", [ 1 ] ); // 1 second\n *\n * - formatMessage( \"{0}/{1}\", [\"m\", \"s\"] ); // m/s\n *\n * - formatMessage( \"{name} <{email}>\", {\n *     name: \"Foo\",\n *     email: \"bar@baz.qux\"\n *   }); // Foo <bar@baz.qux>\n */\nvar formatMessage = function( message, data ) {\n\n\t// Replace {attribute}'s\n\tmessage = message.replace( /{[0-9a-zA-Z-_. ]+}/g, function( name ) {\n\t\tname = name.replace( /^{([^}]*)}$/, \"$1\" );\n\t\treturn toString( data[ name ] );\n\t});\n\n\treturn message;\n};\n\n\n\n\nvar objectExtend = function() {\n\tvar destination = arguments[ 0 ],\n\t\tsources = [].slice.call( arguments, 1 );\n\n\tsources.forEach(function( source ) {\n\t\tvar prop;\n\t\tfor ( prop in source ) {\n\t\t\tdestination[ prop ] = source[ prop ];\n\t\t}\n\t});\n\n\treturn destination;\n};\n\n\n\n\nvar createError = function( code, message, attributes ) {\n\tvar error;\n\n\tmessage = code + ( message ? \": \" + formatMessage( message, attributes ) : \"\" );\n\terror = new Error( message );\n\terror.code = code;\n\n\tobjectExtend( error, attributes );\n\n\treturn error;\n};\n\n\n\n\n/**\n * Pushes part to parts array, concat two consecutive parts of the same type.\n */\nvar partsPush = function( parts, type, value ) {\n\n\t\t// Concat two consecutive parts of same type\n\t\tif ( parts.length && parts[ parts.length - 1 ].type === type ) {\n\t\t\tparts[ parts.length - 1 ].value += value;\n\t\t\treturn;\n\t\t}\n\n\t\tparts.push( { type: type, value: value } );\n};\n\n\n\n\n/**\n * formatMessage( message, data )\n *\n * @message [String] A message with optional {vars} to be replaced.\n *\n * @data [Array or JSON] Object with replacing-variables content.\n *\n * Return the formatted message. For example:\n *\n * - formatMessage( \"{0} second\", [ 1 ] );\n * > [{type: \"variable\", value: \"1\", name: \"0\"}, {type: \"literal\", value: \" second\"}]\n *\n * - formatMessage( \"{0}/{1}\", [\"m\", \"s\"] );\n * > [\n *     { type: \"variable\", value: \"m\", name: \"0\" },\n *     { type: \"literal\", value: \" /\" },\n *     { type: \"variable\", value: \"s\", name: \"1\" }\n *   ]\n */\nvar formatMessageToParts = function( message, data ) {\n\n\tvar lastOffset = 0,\n\t\tparts = [];\n\n\t// Create parts.\n\tmessage.replace( /{[0-9a-zA-Z-_. ]+}/g, function( nameIncludingBrackets, offset ) {\n\t\tvar name = nameIncludingBrackets.slice( 1, -1 );\n\t\tpartsPush( parts, \"literal\", message.slice( lastOffset, offset ));\n\t\tpartsPush( parts, \"variable\", data[ name ] );\n\t\tparts[ parts.length - 1 ].name = name;\n\t\tlastOffset += offset + nameIncludingBrackets.length;\n\t});\n\n\t// Skip empty ones such as `{ type: 'literal', value: '' }`.\n\treturn parts.filter(function( part ) {\n\t\treturn part.value !== \"\";\n\t});\n};\n\n\n\n\n/**\n * Returns joined parts values.\n */\nvar partsJoin = function( parts ) {\n\treturn parts.map( function( part ) {\n\t\treturn part.value;\n\t}).join( \"\" );\n};\n\n\n\n\nvar runtimeStringify = function( args ) {\n\treturn JSON.stringify( args, function( _key, value ) {\n\t\tif ( value && value.runtimeKey ) {\n\t\t\treturn value.runtimeKey;\n\t\t}\n\t\treturn value;\n\t} );\n};\n\n\n\n\n// Based on http://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript-jquery\nvar stringHash = function( str ) {\n\treturn [].reduce.call( str, function( hash, i ) {\n\t\tvar chr = i.charCodeAt( 0 );\n\t\thash = ( ( hash << 5 ) - hash ) + chr;\n\t\treturn hash | 0;\n\t}, 0 );\n};\n\n\n\n\nvar runtimeKey = function( fnName, locale, args, argsStr ) {\n\tvar hash;\n\targsStr = argsStr || runtimeStringify( args );\n\thash = stringHash( fnName + locale + argsStr );\n\treturn hash > 0 ? \"a\" + hash : \"b\" + Math.abs( hash );\n};\n\n\n\n\nvar functionName = function( fn ) {\n\tif ( fn.name !== undefined ) {\n\t\treturn fn.name;\n\t}\n\n\t// fn.name is not supported by IE.\n\tvar matches = /^function\\s+([\\w\\$]+)\\s*\\(/.exec( fn.toString() );\n\n\tif ( matches && matches.length > 0 ) {\n\t\treturn matches[ 1 ];\n\t}\n};\n\n\n\n\nvar runtimeBind = function( args, cldr, fn, runtimeArgs ) {\n\n\tvar argsStr = runtimeStringify( args ),\n\t\tfnName = functionName( fn ),\n\t\tlocale = cldr.locale;\n\n\t// If name of the function is not available, this is most likely due to uglification,\n\t// which most likely means we are in production, and runtimeBind here is not necessary.\n\tif ( !fnName ) {\n\t\treturn fn;\n\t}\n\n\tfn.runtimeKey = runtimeKey( fnName, locale, null, argsStr );\n\n\tfn.generatorString = function() {\n\t\treturn \"Globalize(\\\"\" + locale + \"\\\").\" + fnName + \"(\" + argsStr.slice( 1, -1 ) + \")\";\n\t};\n\n\tfn.runtimeArgs = runtimeArgs;\n\n\treturn fn;\n};\n\n\n\n\nvar validate = function( code, message, check, attributes ) {\n\tif ( !check ) {\n\t\tthrow createError( code, message, attributes );\n\t}\n};\n\n\n\n\nvar alwaysArray = function( stringOrArray ) {\n\treturn Array.isArray( stringOrArray ) ? stringOrArray : stringOrArray ? [ stringOrArray ] : [];\n};\n\n\n\n\nvar validateCldr = function( path, value, options ) {\n\tvar skipBoolean;\n\toptions = options || {};\n\n\tskipBoolean = alwaysArray( options.skip ).some(function( pathRe ) {\n\t\treturn pathRe.test( path );\n\t});\n\n\tvalidate( \"E_MISSING_CLDR\", \"Missing required CLDR content `{path}`.\", value || skipBoolean, {\n\t\tpath: path\n\t});\n};\n\n\n\n\nvar validateDefaultLocale = function( value ) {\n\tvalidate( \"E_DEFAULT_LOCALE_NOT_DEFINED\", \"Default locale has not been defined.\",\n\t\tvalue !== undefined, {} );\n};\n\n\n\n\nvar validateParameterPresence = function( value, name ) {\n\tvalidate( \"E_MISSING_PARAMETER\", \"Missing required parameter `{name}`.\",\n\t\tvalue !== undefined, { name: name });\n};\n\n\n\n\n/**\n * range( value, name, minimum, maximum )\n *\n * @value [Number].\n *\n * @name [String] name of variable.\n *\n * @minimum [Number]. The lowest valid value, inclusive.\n *\n * @maximum [Number]. The greatest valid value, inclusive.\n */\nvar validateParameterRange = function( value, name, minimum, maximum ) {\n\tvalidate(\n\t\t\"E_PAR_OUT_OF_RANGE\",\n\t\t\"Parameter `{name}` has value `{value}` out of range [{minimum}, {maximum}].\",\n\t\tvalue === undefined || value >= minimum && value <= maximum,\n\t\t{\n\t\t\tmaximum: maximum,\n\t\t\tminimum: minimum,\n\t\t\tname: name,\n\t\t\tvalue: value\n\t\t}\n\t);\n};\n\n\n\n\nvar validateParameterType = function( value, name, check, expected ) {\n\tvalidate(\n\t\t\"E_INVALID_PAR_TYPE\",\n\t\t\"Invalid `{name}` parameter ({value}). {expected} expected.\",\n\t\tcheck,\n\t\t{\n\t\t\texpected: expected,\n\t\t\tname: name,\n\t\t\tvalue: value\n\t\t}\n\t);\n};\n\n\n\n\nvar validateParameterTypeLocale = function( value, name ) {\n\tvalidateParameterType(\n\t\tvalue,\n\t\tname,\n\t\tvalue === undefined || typeof value === \"string\" || value instanceof Cldr,\n\t\t\"String or Cldr instance\"\n\t);\n};\n\n\n\n\n/**\n * Function inspired by jQuery Core, but reduced to our use case.\n */\nvar isPlainObject = function( obj ) {\n\treturn obj !== null && \"\" + obj === \"[object Object]\";\n};\n\n\n\n\nvar validateParameterTypePlainObject = function( value, name ) {\n\tvalidateParameterType(\n\t\tvalue,\n\t\tname,\n\t\tvalue === undefined || isPlainObject( value ),\n\t\t\"Plain Object\"\n\t);\n};\n\n\n\n\nvar alwaysCldr = function( localeOrCldr ) {\n\treturn localeOrCldr instanceof Cldr ? localeOrCldr : new Cldr( localeOrCldr );\n};\n\n\n\n\n// ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions?redirectlocale=en-US&redirectslug=JavaScript%2FGuide%2FRegular_Expressions\nvar regexpEscape = function( string ) {\n\treturn string.replace( /([.*+?^=!:${}()|\\[\\]\\/\\\\])/g, \"\\\\$1\" );\n};\n\n\n\n\nvar stringPad = function( str, count, right ) {\n\tvar length;\n\tif ( typeof str !== \"string\" ) {\n\t\tstr = String( str );\n\t}\n\tfor ( length = str.length; length < count; length += 1 ) {\n\t\tstr = ( right ? ( str + \"0\" ) : ( \"0\" + str ) );\n\t}\n\treturn str;\n};\n\n\n\n\nfunction validateLikelySubtags( cldr ) {\n\tcldr.once( \"get\", validateCldr );\n\tcldr.get( \"supplemental/likelySubtags\" );\n}\n\n/**\n * [new] Globalize( locale|cldr )\n *\n * @locale [String]\n *\n * @cldr [Cldr instance]\n *\n * Create a Globalize instance.\n */\nfunction Globalize( locale ) {\n\tif ( !( this instanceof Globalize ) ) {\n\t\treturn new Globalize( locale );\n\t}\n\n\tvalidateParameterPresence( locale, \"locale\" );\n\tvalidateParameterTypeLocale( locale, \"locale\" );\n\n\tthis.cldr = alwaysCldr( locale );\n\n\tvalidateLikelySubtags( this.cldr );\n}\n\n/**\n * Globalize.load( json, ... )\n *\n * @json [JSON]\n *\n * Load resolved or unresolved cldr data.\n * Somewhat equivalent to previous Globalize.addCultureInfo(...).\n */\nGlobalize.load = function() {\n\n\t// validations are delegated to Cldr.load().\n\tCldr.load.apply( Cldr, arguments );\n};\n\n/**\n * Globalize.locale( [locale|cldr] )\n *\n * @locale [String]\n *\n * @cldr [Cldr instance]\n *\n * Set default Cldr instance if locale or cldr argument is passed.\n *\n * Return the default Cldr instance.\n */\nGlobalize.locale = function( locale ) {\n\tvalidateParameterTypeLocale( locale, \"locale\" );\n\n\tif ( arguments.length ) {\n\t\tthis.cldr = alwaysCldr( locale );\n\t\tvalidateLikelySubtags( this.cldr );\n\t}\n\treturn this.cldr;\n};\n\n/**\n * Optimization to avoid duplicating some internal functions across modules.\n */\nGlobalize._alwaysArray = alwaysArray;\nGlobalize._createError = createError;\nGlobalize._formatMessage = formatMessage;\nGlobalize._formatMessageToParts = formatMessageToParts;\nGlobalize._isPlainObject = isPlainObject;\nGlobalize._objectExtend = objectExtend;\nGlobalize._partsJoin = partsJoin;\nGlobalize._partsPush = partsPush;\nGlobalize._regexpEscape = regexpEscape;\nGlobalize._runtimeBind = runtimeBind;\nGlobalize._stringPad = stringPad;\nGlobalize._validate = validate;\nGlobalize._validateCldr = validateCldr;\nGlobalize._validateDefaultLocale = validateDefaultLocale;\nGlobalize._validateParameterPresence = validateParameterPresence;\nGlobalize._validateParameterRange = validateParameterRange;\nGlobalize._validateParameterTypePlainObject = validateParameterTypePlainObject;\nGlobalize._validateParameterType = validateParameterType;\n\nreturn Globalize;\n\n\n\n\n}));\n","/**\n * Globalize v1.7.0\n *\n * https://github.com/globalizejs/globalize\n *\n * Copyright OpenJS Foundation and other contributors\n * Released under the MIT license\n * https://jquery.org/license\n *\n * Date: 2021-08-02T11:53Z\n */\n/*!\n * Globalize v1.7.0 2021-08-02T11:53Z Released under the MIT license\n * http://git.io/TrdQbw\n */\n(function( root, factory ) {\n\n\t// UMD returnExports\n\tif ( typeof define === \"function\" && define.amd ) {\n\n\t\t// AMD\n\t\tdefine([\n\t\t\t\"cldr\",\n\t\t\t\"../globalize\",\n\t\t\t\"cldr/event\",\n\t\t\t\"cldr/supplemental\"\n\t\t], factory );\n\t} else if ( typeof exports === \"object\" ) {\n\n\t\t// Node, CommonJS\n\t\tmodule.exports = factory( require( \"cldrjs\" ), require( \"../globalize\" ) );\n\t} else {\n\n\t\t// Global\n\t\tfactory( root.Cldr, root.Globalize );\n\t}\n}(this, function( Cldr, Globalize ) {\n\nvar createError = Globalize._createError,\n\tpartsJoin = Globalize._partsJoin,\n\tpartsPush = Globalize._partsPush,\n\tregexpEscape = Globalize._regexpEscape,\n\truntimeBind = Globalize._runtimeBind,\n\tstringPad = Globalize._stringPad,\n\tvalidateCldr = Globalize._validateCldr,\n\tvalidateDefaultLocale = Globalize._validateDefaultLocale,\n\tvalidateParameterPresence = Globalize._validateParameterPresence,\n\tvalidateParameterRange = Globalize._validateParameterRange,\n\tvalidateParameterType = Globalize._validateParameterType,\n\tvalidateParameterTypePlainObject = Globalize._validateParameterTypePlainObject;\n\n\nvar createErrorUnsupportedFeature = function( feature ) {\n\treturn createError( \"E_UNSUPPORTED\", \"Unsupported {feature}.\", {\n\t\tfeature: feature\n\t});\n};\n\n\n\n\nvar validateParameterTypeNumber = function( value, name ) {\n\tvalidateParameterType(\n\t\tvalue,\n\t\tname,\n\t\tvalue === undefined || typeof value === \"number\",\n\t\t\"Number\"\n\t);\n};\n\n\n\n\nvar validateParameterTypeString = function( value, name ) {\n\tvalidateParameterType(\n\t\tvalue,\n\t\tname,\n\t\tvalue === undefined || typeof value === \"string\",\n\t\t\"a string\"\n\t);\n};\n\n\n\n\nvar numberFormatterFn = function( numberToPartsFormatter ) {\n\treturn function numberFormatter( value ) {\n\t\treturn partsJoin( numberToPartsFormatter( value ));\n\t};\n};\n\n\n\n\n/**\n * NumberingSystem( cldr )\n *\n * - http://www.unicode.org/reports/tr35/tr35-numbers.html#otherNumberingSystems\n * - http://cldr.unicode.org/index/bcp47-extension\n * - http://www.unicode.org/reports/tr35/#u_Extension\n */\nvar numberNumberingSystem = function( cldr ) {\n\tvar nu = cldr.attributes[ \"u-nu\" ];\n\n\tif ( nu ) {\n\t\tif ( nu === \"traditio\" ) {\n\t\t\tnu = \"traditional\";\n\t\t}\n\t\tif ( [ \"native\", \"traditional\", \"finance\" ].indexOf( nu ) !== -1 ) {\n\n\t\t\t// Unicode locale extension `u-nu` is set using either (native, traditional or\n\t\t\t// finance). So, lookup the respective locale's numberingSystem and return it.\n\t\t\treturn cldr.main([ \"numbers/otherNumberingSystems\", nu ]);\n\t\t}\n\n\t\t// Unicode locale extension `u-nu` is set with an explicit numberingSystem. Return it.\n\t\treturn nu;\n\t}\n\n\t// Return the default numberingSystem.\n\treturn cldr.main( \"numbers/defaultNumberingSystem\" );\n};\n\n\n\n\n/**\n * Compact( name, cldr )\n *\n * @compactType [String] Compact mode, `short` or `long`.\n *\n * @cldr [Cldr instance].\n *\n * Return the localized compact map for the given compact mode.\n */\nvar numberCompact = function( compactType, cldr ) {\n\tvar maxExponent = 0;\n\n\tvar object = cldr.main([\n\t\t\"numbers/decimalFormats-numberSystem-\" + numberNumberingSystem( cldr ),\n\t\tcompactType,\n\t\t\"decimalFormat\"\n\t]);\n\n\tobject = Object.keys( object ).reduce(function( newObject, compactKey ) {\n\t\tvar numberExponent = compactKey.split( \"0\" ).length - 1;\n\t\tvar pluralForm = compactKey.split( \"-\" )[ 2 ];\n\t\tnewObject[ numberExponent ] = newObject[ numberExponent ] || {};\n\t\tnewObject[ numberExponent ][ pluralForm ] = object[ compactKey ];\n\t\tmaxExponent = Math.max( numberExponent, maxExponent );\n\t\treturn newObject;\n\t}, {});\n\n\tobject.maxExponent = maxExponent;\n\n\treturn object;\n};\n\n\n\n\n/**\n * nuMap( cldr )\n *\n * @cldr [Cldr instance].\n *\n * Return digits map if numbering system is different than `latn`.\n */\nvar numberNumberingSystemDigitsMap = function( cldr ) {\n\tvar aux,\n\t\tnu = numberNumberingSystem( cldr );\n\n\tif ( nu === \"latn\" ) {\n\t\treturn;\n\t}\n\n\taux = cldr.supplemental([ \"numberingSystems\", nu ]);\n\n\tif ( aux._type !== \"numeric\" ) {\n\t\tthrow createErrorUnsupportedFeature( \"`\" + aux._type + \"` numbering system\" );\n\t}\n\n\treturn aux._digits;\n};\n\n\n\n\n/**\n * EBNF representation:\n *\n * number_pattern_re =        prefix?\n *                            padding?\n *                            (integer_fraction_pattern | significant_pattern)\n *                            scientific_notation?\n *                            suffix?\n *\n * prefix =                   non_number_stuff\n *\n * padding =                  \"*\" regexp(.)\n *\n * integer_fraction_pattern = integer_pattern\n *                            fraction_pattern?\n *\n * integer_pattern =          regexp([#,]*[0,]*0+)\n *\n * fraction_pattern =         \".\" regexp(0*[0-9]*#*)\n *\n * significant_pattern =      regexp([#,]*@+#*)\n *\n * scientific_notation =      regexp(E\\+?0+)\n *\n * suffix =                   non_number_stuff\n *\n * non_number_stuff =         regexp(('[^']+'|''|[^*#@0,.E])*)\n *\n *\n * Regexp groups:\n *\n *  0: number_pattern_re\n *  1: prefix\n *  2: -\n *  3: -\n *  4: padding\n *  5: (integer_fraction_pattern | significant_pattern)\n *  6: integer_fraction_pattern\n *  7: integer_pattern\n *  8: fraction_pattern\n *  9: significant_pattern\n * 10: scientific_notation\n * 11: suffix\n * 12: -\n */\nvar numberPatternRe = ( /^(('([^']|'')*'|[^*#@0,.E])*)(\\*.)?((([#,]*[0,]*0+)(\\.0*[0-9]*#*)?)|([#,]*@+#*))(E\\+?0+)?(('[^']+'|''|[^*#@0,.E])*)$/ );\n\n\n\n\n/**\n * format( number, pattern )\n *\n * @number [Number].\n *\n * @pattern [String] raw pattern for numbers.\n *\n * Return the formatted number.\n * ref: http://www.unicode.org/reports/tr35/tr35-numbers.html\n */\nvar numberPatternProperties = function( pattern ) {\n\tvar aux1, aux2, fractionPattern, integerFractionOrSignificantPattern, integerPattern,\n\t\tmaximumFractionDigits, maximumSignificantDigits, minimumFractionDigits,\n\t\tminimumIntegerDigits, minimumSignificantDigits, padding, prefix, primaryGroupingSize,\n\t\troundIncrement, scientificNotation, secondaryGroupingSize, significantPattern, suffix;\n\n\tpattern = pattern.match( numberPatternRe );\n\tif ( !pattern ) {\n\t\tthrow new Error( \"Invalid pattern: \" + pattern );\n\t}\n\n\tprefix = pattern[ 1 ];\n\tpadding = pattern[ 4 ];\n\tintegerFractionOrSignificantPattern = pattern[ 5 ];\n\tsignificantPattern = pattern[ 9 ];\n\tscientificNotation = pattern[ 10 ];\n\tsuffix = pattern[ 11 ];\n\n\t// Significant digit format\n\tif ( significantPattern ) {\n\t\tsignificantPattern.replace( /(@+)(#*)/, function( _match, minimumSignificantDigitsMatch, maximumSignificantDigitsMatch ) {\n\t\t\tminimumSignificantDigits = minimumSignificantDigitsMatch.length;\n\t\t\tmaximumSignificantDigits = minimumSignificantDigits +\n\t\t\t\tmaximumSignificantDigitsMatch.length;\n\t\t});\n\n\t// Integer and fractional format\n\t} else {\n\t\tfractionPattern = pattern[ 8 ];\n\t\tintegerPattern = pattern[ 7 ];\n\n\t\tif ( fractionPattern ) {\n\n\t\t\t// Minimum fraction digits, and rounding.\n\t\t\tfractionPattern.replace( /[0-9]+/, function( match ) {\n\t\t\t\tminimumFractionDigits = match;\n\t\t\t});\n\t\t\tif ( minimumFractionDigits ) {\n\t\t\t\troundIncrement = +( \"0.\" + minimumFractionDigits );\n\t\t\t\tminimumFractionDigits = minimumFractionDigits.length;\n\t\t\t} else {\n\t\t\t\tminimumFractionDigits = 0;\n\t\t\t}\n\n\t\t\t// Maximum fraction digits\n\t\t\t// 1: ignore decimal character\n\t\t\tmaximumFractionDigits = fractionPattern.length - 1; /* 1 */\n\t\t} else {\n\t\t\tminimumFractionDigits = 0;\n\t\t\tmaximumFractionDigits = 0;\n\t\t}\n\n\t\t// Minimum integer digits\n\t\tintegerPattern.replace( /0+$/, function( match ) {\n\t\t\tminimumIntegerDigits = match.length;\n\t\t});\n\t}\n\n\t// Scientific notation\n\tif ( scientificNotation ) {\n\t\tthrow createErrorUnsupportedFeature({\n\t\t\tfeature: \"scientific notation (not implemented)\"\n\t\t});\n\t}\n\n\t// Padding\n\tif ( padding ) {\n\t\tthrow createErrorUnsupportedFeature({\n\t\t\tfeature: \"padding (not implemented)\"\n\t\t});\n\t}\n\n\t// Grouping\n\tif ( ( aux1 = integerFractionOrSignificantPattern.lastIndexOf( \",\" ) ) !== -1 ) {\n\n\t\t// Primary grouping size is the interval between the last group separator and the end of\n\t\t// the integer (or the end of the significant pattern).\n\t\taux2 = integerFractionOrSignificantPattern.split( \".\" )[ 0 ];\n\t\tprimaryGroupingSize = aux2.length - aux1 - 1;\n\n\t\t// Secondary grouping size is the interval between the last two group separators.\n\t\tif ( ( aux2 = integerFractionOrSignificantPattern.lastIndexOf( \",\", aux1 - 1 ) ) !== -1 ) {\n\t\t\tsecondaryGroupingSize = aux1 - 1 - aux2;\n\t\t}\n\t}\n\n\t// Return:\n\t//  0: @prefix String\n\t//  1: @padding Array [ <character>, <count> ] TODO\n\t//  2: @minimumIntegerDigits non-negative integer Number value indicating the minimum integer\n\t//        digits to be used. Numbers will be padded with leading zeroes if necessary.\n\t//  3: @minimumFractionDigits and\n\t//  4: @maximumFractionDigits are non-negative integer Number values indicating the minimum and\n\t//        maximum fraction digits to be used. Numbers will be rounded or padded with trailing\n\t//        zeroes if necessary.\n\t//  5: @minimumSignificantDigits and\n\t//  6: @maximumSignificantDigits are positive integer Number values indicating the minimum and\n\t//        maximum fraction digits to be shown. Either none or both of these properties are\n\t//        present; if they are, they override minimum and maximum integer and fraction digits\n\t//        – the formatter uses however many integer and fraction digits are required to display\n\t//        the specified number of significant digits.\n\t//  7: @roundIncrement Decimal round increment or null\n\t//  8: @primaryGroupingSize\n\t//  9: @secondaryGroupingSize\n\t// 10: @suffix String\n\treturn [\n\t\tprefix,\n\t\tpadding,\n\t\tminimumIntegerDigits,\n\t\tminimumFractionDigits,\n\t\tmaximumFractionDigits,\n\t\tminimumSignificantDigits,\n\t\tmaximumSignificantDigits,\n\t\troundIncrement,\n\t\tprimaryGroupingSize,\n\t\tsecondaryGroupingSize,\n\t\tsuffix\n\t];\n};\n\n\n\n\n/**\n * Symbol( name, cldr )\n *\n * @name [String] Symbol name.\n *\n * @cldr [Cldr instance].\n *\n * Return the localized symbol given its name.\n */\nvar numberSymbol = function( name, cldr ) {\n\treturn cldr.main([\n\t\t\"numbers/symbols-numberSystem-\" + numberNumberingSystem( cldr ),\n\t\tname\n\t]);\n};\n\n\n\n\nvar numberSymbolName = {\n\t\".\": \"decimal\",\n\t\",\": \"group\",\n\t\"%\": \"percentSign\",\n\t\"+\": \"plusSign\",\n\t\"-\": \"minusSign\",\n\t\"E\": \"exponential\",\n\t\"\\u2030\": \"perMille\"\n};\n\n\n\n\n/**\n * symbolMap( cldr )\n *\n * @cldr [Cldr instance].\n *\n * Return the (localized symbol, pattern symbol) key value pair, eg. {\n *   \".\": \"٫\",\n *   \",\": \"٬\",\n *   \"%\": \"٪\",\n *   ...\n * };\n */\nvar numberSymbolMap = function( cldr ) {\n\tvar symbol,\n\t\tsymbolMap = {};\n\n\tfor ( symbol in numberSymbolName ) {\n\t\tsymbolMap[ symbol ] = numberSymbol( numberSymbolName[ symbol ], cldr );\n\t}\n\n\treturn symbolMap;\n};\n\n\n\n\nvar numberTruncate = function( value ) {\n\tif ( isNaN( value ) ) {\n\t\treturn NaN;\n\t}\n\treturn Math[ value < 0 ? \"ceil\" : \"floor\" ]( value );\n};\n\n\n\n\n/**\n * round( method )\n *\n * @method [String] with either \"round\", \"ceil\", \"floor\", or \"truncate\".\n *\n * Return function( value, incrementOrExp ):\n *\n *   @value [Number] eg. 123.45.\n *\n *   @incrementOrExp [Number] optional, eg. 0.1; or\n *     [Object] Either { increment: <value> } or { exponent: <value> }\n *\n *   Return the rounded number, eg:\n *   - round( \"round\" )( 123.45 ): 123;\n *   - round( \"ceil\" )( 123.45 ): 124;\n *   - round( \"floor\" )( 123.45 ): 123;\n *   - round( \"truncate\" )( 123.45 ): 123;\n *   - round( \"round\" )( 123.45, 0.1 ): 123.5;\n *   - round( \"round\" )( 123.45, 10 ): 120;\n *\n *   Based on https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round\n *   Ref: #376\n */\nvar numberRound = function( method ) {\n\tmethod = method || \"round\";\n\tmethod = method === \"truncate\" ? numberTruncate : Math[ method ];\n\n\treturn function( value, incrementOrExp ) {\n\t\tvar exp, increment;\n\n\t\tvalue = +value;\n\n\t\t// If the value is not a number, return NaN.\n\t\tif ( isNaN( value ) ) {\n\t\t\treturn NaN;\n\t\t}\n\n\t\t// Exponent given.\n\t\tif ( typeof incrementOrExp === \"object\" && incrementOrExp.exponent ) {\n\t\t\texp = +incrementOrExp.exponent;\n\t\t\tincrement = 1;\n\n\t\t\tif ( exp === 0 ) {\n\t\t\t\treturn method( value );\n\t\t\t}\n\n\t\t\t// If the exp is not an integer, return NaN.\n\t\t\tif ( !( typeof exp === \"number\" && exp % 1 === 0 ) ) {\n\t\t\t\treturn NaN;\n\t\t\t}\n\n\t\t// Increment given.\n\t\t} else {\n\t\t\tincrement = +incrementOrExp || 1;\n\n\t\t\tif ( increment === 1 ) {\n\t\t\t\treturn method( value );\n\t\t\t}\n\n\t\t\t// If the increment is not a number, return NaN.\n\t\t\tif ( isNaN( increment ) ) {\n\t\t\t\treturn NaN;\n\t\t\t}\n\n\t\t\tincrement = increment.toExponential().split( \"e\" );\n\t\t\texp = +increment[ 1 ];\n\t\t\tincrement = +increment[ 0 ];\n\t\t}\n\n\t\t// Shift & Round\n\t\tvalue = value.toString().split( \"e\" );\n\t\tvalue[ 0 ] = +value[ 0 ] / increment;\n\t\tvalue[ 1 ] = value[ 1 ] ? ( +value[ 1 ] - exp ) : -exp;\n\t\tvalue = method( +( value[ 0 ] + \"e\" + value[ 1 ] ) );\n\n\t\t// Shift back\n\t\tvalue = value.toString().split( \"e\" );\n\t\tvalue[ 0 ] = +value[ 0 ] * increment;\n\t\tvalue[ 1 ] = value[ 1 ] ? ( +value[ 1 ] + exp ) : exp;\n\t\treturn +( value[ 0 ] + \"e\" + value[ 1 ] );\n\t};\n};\n\n\n\n\n/**\n * formatProperties( pattern, cldr [, options] )\n *\n * @pattern [String] raw pattern for numbers.\n *\n * @cldr [Cldr instance].\n *\n * @options [Object]:\n * - minimumIntegerDigits [Number]\n * - minimumFractionDigits, maximumFractionDigits [Number]\n * - minimumSignificantDigits, maximumSignificantDigits [Number]\n * - round [String] \"ceil\", \"floor\", \"round\" (default), or \"truncate\".\n * - useGrouping [Boolean] default true.\n *\n * Return the processed properties that will be used in number/format.\n * ref: http://www.unicode.org/reports/tr35/tr35-numbers.html\n */\nvar numberFormatProperties = function( pattern, cldr, options ) {\n\tvar negativePattern, negativePrefix, negativeProperties, negativeSuffix, positivePattern,\n\t\troundFn, properties;\n\n\tfunction getOptions( attribute, propertyIndex ) {\n\t\tif ( attribute in options ) {\n\t\t\tproperties[ propertyIndex ] = options[ attribute ];\n\t\t}\n\t}\n\n\toptions = options || {};\n\tpattern = pattern.split( \";\" );\n\n\tpositivePattern = pattern[ 0 ];\n\n\tnegativePattern = pattern[ 1 ] || \"-\" + positivePattern;\n\tnegativeProperties = numberPatternProperties( negativePattern );\n\tnegativePrefix = negativeProperties[ 0 ];\n\tnegativeSuffix = negativeProperties[ 10 ];\n\n\t// Have runtime code to refer to numberRound() instead of including it explicitly.\n\troundFn = numberRound( options.round );\n\troundFn.generatorString = function() {\n\t\treturn \"numberRound(\" + ( options.round ? \"\\\"\" + options.round + \"\\\"\" : \"\" ) + \")\";\n\t};\n\n\tproperties = numberPatternProperties( positivePattern ).concat([\n\t\tpositivePattern,\n\t\tnegativePrefix + positivePattern + negativeSuffix,\n\t\tnegativePrefix,\n\t\tnegativeSuffix,\n\t\troundFn,\n\t\tnumberSymbol( \"infinity\", cldr ),\n\t\tnumberSymbol( \"nan\", cldr ),\n\t\tnumberSymbolMap( cldr ),\n\t\tnumberNumberingSystemDigitsMap( cldr )\n\t]);\n\n\tif ( options.compact ) {\n\n\t\t// The compact digits number pattern is always `0+`, so override the following properties.\n\t\t// Note: minimumIntegerDigits would actually range from `0` to `000` based on the scale of\n\t\t// the value to be formatted, though we're always using 1 as a simplification, because the\n\t\t// number won't be zero-padded since we chose the right format based on the scale, i.e.,\n\t\t// we'd never see something like `003M` anyway.\n\t\tproperties[ 2 ] = 1; // minimumIntegerDigits\n\t\tproperties[ 3 ] = 0; // minimumFractionDigits\n\t\tproperties[ 4 ] = 0; // maximumFractionDigits\n\t\tproperties[ 5 ] = // minimumSignificantDigits &\n\t\t\tproperties[ 6 ] = undefined; // maximumSignificantDigits\n\n\t\tproperties[ 20 ] = numberCompact( options.compact, cldr );\n\t}\n\n\tgetOptions( \"minimumIntegerDigits\", 2 );\n\tgetOptions( \"minimumFractionDigits\", 3 );\n\tgetOptions( \"maximumFractionDigits\", 4 );\n\tgetOptions( \"minimumSignificantDigits\", 5 );\n\tgetOptions( \"maximumSignificantDigits\", 6 );\n\n\t// Grouping separators\n\tif ( options.useGrouping === false ) {\n\t\tproperties[ 8 ] = null;\n\t}\n\n\t// Normalize number of digits if only one of either minimumFractionDigits or\n\t// maximumFractionDigits is passed in as an option\n\tif ( \"minimumFractionDigits\" in options && !( \"maximumFractionDigits\" in options ) ) {\n\n\t\t// maximumFractionDigits = Math.max( minimumFractionDigits, maximumFractionDigits );\n\t\tproperties[ 4 ] = Math.max( properties[ 3 ], properties[ 4 ] );\n\t} else if ( !( \"minimumFractionDigits\" in options ) &&\n\t\t\t\"maximumFractionDigits\" in options ) {\n\n\t\t// minimumFractionDigits = Math.min( minimumFractionDigits, maximumFractionDigits );\n\t\tproperties[ 3 ] = Math.min( properties[ 3 ], properties[ 4 ] );\n\t}\n\n\t// Return:\n\t// 0-10: see number/pattern-properties.\n\t// 11: @positivePattern [String] Positive pattern.\n\t// 12: @negativePattern [String] Negative pattern.\n\t// 13: @negativePrefix [String] Negative prefix.\n\t// 14: @negativeSuffix [String] Negative suffix.\n\t// 15: @round [Function] Round function.\n\t// 16: @infinitySymbol [String] Infinity symbol.\n\t// 17: @nanSymbol [String] NaN symbol.\n\t// 18: @symbolMap [Object] A bunch of other symbols.\n\t// 19: @nuDigitsMap [Array] Digits map if numbering system is different than `latn`.\n\t// 20: @compactMap [Object] Map of per-digit-count format patterns for specified compact mode.\n\treturn properties;\n};\n\n\n\n\n/**\n * Generated by:\n *\n * var regenerate = require( \"regenerate\" );\n * var formatSymbols = require( \"@unicode/unicode-13.0.0/General_Category/Format/symbols\" );\n * regenerate().add( formatSymbols ).toString();\n *\n * https://github.com/mathiasbynens/regenerate\n * https://github.com/node-unicode/unicode-13.0.0\n */\nvar regexpCfG = /[\\xAD\\u0600-\\u0605\\u061C\\u06DD\\u070F\\u08E2\\u180E\\u200B-\\u200F\\u202A-\\u202E\\u2060-\\u2064\\u2066-\\u206F\\uFEFF\\uFFF9-\\uFFFB]|\\uD804[\\uDCBD\\uDCCD]|\\uD80D[\\uDC30-\\uDC38]|\\uD82F[\\uDCA0-\\uDCA3]|\\uD834[\\uDD73-\\uDD7A]|\\uDB40[\\uDC01\\uDC20-\\uDC7F]/g;\n\n\n\n\n/**\n * Generated by:\n *\n * var regenerate = require( \"regenerate\" );\n * var dashSymbols = require( \"https://github.com/node-unicode/unicode-13.0.0/General_Category/Dash_Punctuation/symbols\" );\n * regenerate().add( dashSymbols ).toString();\n *\n * https://github.com/mathiasbynens/regenerate\n * https://github.com/node-unicode/unicode-13.0.0\n *\n * NOTE: In addition to [:dash:],  the below includes MINUS SIGN U+2212.\n */\nvar regexpDashG = /[\\x2D\\u058A\\u05BE\\u1400\\u1806\\u2010-\\u2015\\u2E17\\u2E1A\\u2E3A\\u2E3B\\u2E40\\u301C\\u3030\\u30A0\\uFE31\\uFE32\\uFE58\\uFE63\\uFF0D\\u2212]|\\uD803\\uDEAD/g;\n\n\n\n\n/**\n * Generated by:\n *\n * var regenerate = require( \"regenerate\" );\n * var spaceSeparatorSymbols = require( \"@unicode/unicode-13.0.0/General_Category/Space_Separator/symbols\" );\n * regenerate().add( spaceSeparatorSymbols ).toString();\n *\n * https://github.com/mathiasbynens/regenerate\n * https://github.com/node-unicode/unicode-13.0.0\n */\nvar regexpZsG = /[ \\xA0\\u1680\\u2000-\\u200A\\u202F\\u205F\\u3000]/g;\n\n\n\n\n/**\n * Loose Matching:\n * - Ignore all format characters, which includes RLM, LRM or ALM used to control BIDI\n *   formatting.\n * - Map all characters in [:Zs:] to U+0020 SPACE;\n * - Map all characters in [:Dash:] to U+002D HYPHEN-MINUS;\n */\nvar looseMatching = function( value ) {\n\treturn value\n\t\t.replace( regexpCfG, \"\" )\n\t\t.replace( regexpDashG, \"-\" )\n\t\t.replace( regexpZsG, \" \" );\n};\n\n\n\n\n/**\n * parse( value, properties )\n *\n * @value [String].\n *\n * @properties [Object] Parser properties is a reduced pre-processed cldr\n * data set returned by numberParserProperties().\n *\n * Return the parsed Number (including Infinity) or NaN when value is invalid.\n * ref: http://www.unicode.org/reports/tr35/tr35-numbers.html\n */\nvar numberParse = function( value, properties ) {\n\tvar grammar, invertedNuDigitsMap, invertedSymbolMap, negative, number, prefix, prefixNSuffix,\n\t\tsuffix, tokenizer, valid;\n\n\t// Grammar:\n\t// - Value <=           NaN | PositiveNumber | NegativeNumber\n\t// - PositiveNumber <=  PositivePrefix NumberOrInf PositiveSufix\n\t// - NegativeNumber <=  NegativePrefix NumberOrInf\n\t// - NumberOrInf <=     Number | Inf\n\tgrammar = [\n\t\t[ \"nan\" ],\n\t\t[ \"prefix\", \"infinity\", \"suffix\" ],\n\t\t[ \"prefix\", \"number\", \"suffix\" ],\n\t\t[ \"negativePrefix\", \"infinity\", \"negativeSuffix\" ],\n\t\t[ \"negativePrefix\", \"number\", \"negativeSuffix\" ]\n\t];\n\n\tinvertedSymbolMap = properties[ 0 ];\n\tinvertedNuDigitsMap = properties[ 1 ] || {};\n\ttokenizer = properties[ 2 ];\n\n\tvalue = looseMatching( value );\n\n\tfunction parse( type ) {\n\t\treturn function( lexeme ) {\n\n\t\t\t// Reverse localized symbols and numbering system.\n\t\t\tlexeme = lexeme.split( \"\" ).map(function( character ) {\n\t\t\t\treturn invertedSymbolMap[ character ] ||\n\t\t\t\t\tinvertedNuDigitsMap[ character ] ||\n\t\t\t\t\tcharacter;\n\t\t\t}).join( \"\" );\n\n\t\t\tswitch ( type ) {\n\t\t\t\tcase \"infinity\":\n\t\t\t\t\tnumber = Infinity;\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase \"nan\":\n\t\t\t\t\tnumber = NaN;\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase \"number\":\n\n\t\t\t\t\t// Remove grouping separators.\n\t\t\t\t\tlexeme = lexeme.replace( /,/g, \"\" );\n\n\t\t\t\t\tnumber = +lexeme;\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase \"prefix\":\n\t\t\t\tcase \"negativePrefix\":\n\t\t\t\t\tprefix = lexeme;\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase \"suffix\":\n\t\t\t\t\tsuffix = lexeme;\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase \"negativeSuffix\":\n\t\t\t\t\tsuffix = lexeme;\n\t\t\t\t\tnegative = true;\n\t\t\t\t\tbreak;\n\n\t\t\t\t// This should never be reached.\n\t\t\t\tdefault:\n\t\t\t\t\tthrow new Error( \"Internal error\" );\n\t\t\t}\n\t\t\treturn \"\";\n\t\t};\n\t}\n\n\tfunction tokenizeNParse( _value, grammar ) {\n\t\treturn grammar.some(function( statement ) {\n\t\t\tvar value = _value;\n\n\t\t\t// The whole grammar statement should be used (i.e., .every() return true) and value be\n\t\t\t// entirely consumed (i.e., !value.length).\n\t\t\treturn statement.every(function( type ) {\n\t\t\t\tif ( value.match( tokenizer[ type ] ) === null ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\n\t\t\t\t// Consume and parse it.\n\t\t\t\tvalue = value.replace( tokenizer[ type ], parse( type ) );\n\t\t\t\treturn true;\n\t\t\t}) && !value.length;\n\t\t});\n\t}\n\n\tvalid = tokenizeNParse( value, grammar );\n\n\t// NaN\n\tif ( !valid || isNaN( number ) ) {\n\t\treturn NaN;\n\t}\n\n\tprefixNSuffix = \"\" + prefix + suffix;\n\n\t// Percent\n\tif ( prefixNSuffix.indexOf( \"%\" ) !== -1 ) {\n\t\tnumber /= 100;\n\n\t// Per mille\n\t} else if ( prefixNSuffix.indexOf( \"\\u2030\" ) !== -1 ) {\n\t\tnumber /= 1000;\n\t}\n\n\t// Negative number\n\tif ( negative ) {\n\t\tnumber *= -1;\n\t}\n\n\treturn number;\n};\n\n\n\n\nvar numberParserFn = function( properties ) {\n\treturn function numberParser( value ) {\n\t\tvalidateParameterPresence( value, \"value\" );\n\t\tvalidateParameterTypeString( value, \"value\" );\n\n\t\treturn numberParse( value, properties );\n\t};\n\n};\n\n\n\n\n/**\n * symbolMap( cldr )\n *\n * @cldr [Cldr instance].\n *\n * Return the (localized symbol, pattern symbol) key value pair, eg. {\n *   \"٫\": \".\",\n *   \"٬\": \",\",\n *   \"٪\": \"%\",\n *   ...\n * };\n */\nvar numberSymbolInvertedMap = function( cldr ) {\n\tvar symbol,\n\t\tsymbolMap = {};\n\n\tfor ( symbol in numberSymbolName ) {\n\t\tsymbolMap[ numberSymbol( numberSymbolName[ symbol ], cldr ) ] = symbol;\n\t}\n\n\treturn symbolMap;\n};\n\n\n\n\n/**\n * objectMap( object, fn)\n *\n * - object\n *\n * - fn( pair ) => pair\n */\nvar objectMap = function( object, fn ) {\n\treturn Object.keys( object ).map(function( key ) {\n\t\treturn fn([ key, object[ key ] ]);\n\t}).reduce(function( object, pair ) {\n\t\tobject[ pair[ 0 ] ] = pair[ 1 ];\n\t\treturn object;\n\t}, {});\n};\n\n\n\n\n/**\n * removeLiteralQuotes( string )\n *\n * Return:\n * - `'` if input string is `''`.\n * - `o'clock` if input string is `'o''clock'`.\n * - `foo` if input string is `foo`, i.e., return the same value in case it isn't a single-quoted\n *   string.\n */\nvar removeLiteralQuotes = function( string ) {\n\tif ( string[ 0 ] + string[ string.length - 1 ] !== \"''\" ) {\n\t\treturn string;\n\t}\n\tif ( string === \"''\" ) {\n\t\treturn \"'\";\n\t}\n\treturn string.replace( /''/g, \"'\" ).slice( 1, -1 );\n};\n\n\n\n\n/**\n * parseProperties( pattern, cldr )\n *\n * @pattern [String] raw pattern for numbers.\n *\n * @cldr [Cldr instance].\n *\n * Return parser properties, used to feed parser function.\n *\n * TODO:\n * - Scientific_notation;\n * - Padding;\n */\nvar numberParseProperties = function( pattern, cldr, options ) {\n\tvar aux, decimalSymbolRe, digitsRe, groupingSeparatorRe, infinitySymbol, invertedNuDigitsMap,\n\t\tinvertedSymbolMap, maximumFractionDigits, maximumSignificantDigits,\n\t\tminimumSignificantDigits, nanSymbol, negativePrefix, negativeSuffix, nuDigitsMap,\n\t\tnumberTokenizer, prefix, primaryGroupingSize, secondaryGroupingSize, suffix, symbolMap,\n\t\tformatProperties = numberFormatProperties( pattern, cldr, options );\n\n\tprefix = looseMatching( formatProperties[ 0 ] );\n\tmaximumFractionDigits = formatProperties[ 4 ];\n\tminimumSignificantDigits = formatProperties[ 5 ];\n\tmaximumSignificantDigits = formatProperties[ 6 ];\n\tprimaryGroupingSize = formatProperties[ 8 ];\n\tsecondaryGroupingSize = formatProperties[ 9 ];\n\tsuffix = looseMatching( formatProperties[ 10 ] );\n\tnegativePrefix = looseMatching( formatProperties[ 13 ] );\n\tnegativeSuffix = looseMatching( formatProperties[ 14 ] );\n\tinfinitySymbol = looseMatching( formatProperties[ 16 ] );\n\tnanSymbol = looseMatching( formatProperties[ 17 ] );\n\tsymbolMap = objectMap( formatProperties[ 18 ], function( pair ) {\n\t\treturn [ pair[ 0 ], looseMatching( pair[ 1 ] ) ];\n\t});\n\tnuDigitsMap = formatProperties[ 19 ];\n\n\tinvertedSymbolMap = objectMap( numberSymbolInvertedMap( cldr ), function( pair ) {\n\t\treturn [ looseMatching( pair[ 0 ] ), pair[ 1 ] ];\n\t});\n\n\tdigitsRe = nuDigitsMap ? \"[\" + nuDigitsMap + \"]\" : \"\\\\d\";\n\tgroupingSeparatorRe = regexpEscape( symbolMap[ \",\" ] );\n\tdecimalSymbolRe = regexpEscape( symbolMap[ \".\" ] );\n\n\tif ( nuDigitsMap ) {\n\t\tinvertedNuDigitsMap = nuDigitsMap.split( \"\" ).reduce(function( object, localizedDigit, i ) {\n\t\t\tobject[ localizedDigit ] = String( i );\n\t\t\treturn object;\n\t\t}, {} );\n\t}\n\n\taux = [ prefix, suffix, negativePrefix, negativeSuffix ].map(function( value ) {\n\t\treturn value.replace( /('([^']|'')+'|'')|./g, function( character, literal ) {\n\n\t\t\t// Literals\n\t\t\tif ( literal ) {\n\t\t\t\treturn removeLiteralQuotes( literal );\n\t\t\t}\n\n\t\t\t// Symbols\n\t\t\tcharacter = character.replace( /[\\-+E%\\u2030]/, function( symbol ) {\n\t\t\t\treturn symbolMap[ symbol ];\n\t\t\t});\n\n\t\t\treturn character;\n\t\t});\n\t});\n\n\tprefix = aux[ 0 ];\n\tsuffix = aux[ 1 ];\n\tnegativePrefix = aux[ 2 ];\n\tnegativeSuffix = aux[ 3 ];\n\n\t// Number\n\t//\n\t// number_re =                       integer fraction?\n\t//\n\t// integer =                         digits | digits_using_grouping_separators\n\t//\n\t// fraction =                        regexp((.\\d+)?)\n\t//\n\t// digits =                          regexp(\\d+)\n\t//\n\t// digits_w_grouping_separators =    digits_w_1_grouping_separators |\n\t//                                   digits_w_2_grouping_separators\n\t//\n\t// digits_w_1_grouping_separators =  regexp(\\d{1,3}(,\\d{3})+)\n\t//\n\t// digits_w_2_grouping_separators =  regexp(\\d{1,2}((,\\d{2})*(,\\d{3})))\n\n\t// Integer part\n\tnumberTokenizer = digitsRe + \"+\";\n\n\t// Grouping separators\n\tif ( primaryGroupingSize ) {\n\t\tif ( secondaryGroupingSize ) {\n\t\t\taux = digitsRe + \"{1,\" + secondaryGroupingSize + \"}((\" + groupingSeparatorRe +\n\t\t\t\tdigitsRe + \"{\" + secondaryGroupingSize + \"})*(\" + groupingSeparatorRe +\n\t\t\t\tdigitsRe + \"{\" + primaryGroupingSize + \"}))\";\n\t\t} else {\n\t\t\taux = digitsRe + \"{1,\" + primaryGroupingSize + \"}(\" + groupingSeparatorRe +\n\t\t\t\tdigitsRe + \"{\" + primaryGroupingSize + \"})+\";\n\t\t}\n\t\tnumberTokenizer = \"(\" + aux + \"|\" + numberTokenizer + \")\";\n\t}\n\n\t// Fraction part? Only included if 1 or 2.\n\t// 1: Using significant digit format.\n\t// 2: Using integer and fractional format && it has a maximumFractionDigits.\n\tif ( !isNaN( minimumSignificantDigits * maximumSignificantDigits ) || /* 1 */\n\t\t\t\tmaximumFractionDigits /* 2 */ ) {\n\n\t\t// 1: Handle trailing decimal separator, e.g., `\"1.\" => `1``.\n\t\taux = decimalSymbolRe + digitsRe + \"+\";\n\t\tnumberTokenizer = numberTokenizer + \"(\" + aux + \"|\" + decimalSymbolRe /* 1 */ + \")?\" +\n\n\t\t\t// Handle non-padded decimals, e.g., `\".12\"` => `0.12` by making the integer part\n\t\t\t// optional.\n\t\t\t\"|(\" + numberTokenizer + \")?\" + aux;\n\n\t\tnumberTokenizer = \"(\" + numberTokenizer + \")\";\n\t}\n\n\t// 0: @invertedSymbolMap [Object] Inverted symbol map.\n\t// 1: @invertedNuDigitsMap [Object] Inverted digits map if numbering system is different than\n\t//    `latn`.\n\t// 2: @tokenizer [Object] Tokenizer map, used by parser to consume input.\n\treturn [\n\t\tinvertedSymbolMap,\n\t\tinvertedNuDigitsMap,\n\t\t{\n\t\t\tinfinity: new RegExp( \"^\" + regexpEscape( infinitySymbol ) ),\n\t\t\tnan: new RegExp( \"^\" + regexpEscape( nanSymbol ) ),\n\t\t\tnegativePrefix: new RegExp( \"^\" + regexpEscape( negativePrefix ) ),\n\t\t\tnegativeSuffix: new RegExp( \"^\" + regexpEscape( negativeSuffix ) ),\n\t\t\tnumber: new RegExp( \"^\" + numberTokenizer ),\n\t\t\tprefix: new RegExp( \"^\" + regexpEscape( prefix ) ),\n\t\t\tsuffix: new RegExp( \"^\" + regexpEscape( suffix ) )\n\t\t}\n\t];\n\n};\n\n\n\n\n/**\n * Pattern( style )\n *\n * @style [String] \"decimal\" (default) or \"percent\".\n *\n * @cldr [Cldr instance].\n */\nvar numberPattern = function( style, cldr ) {\n\tif ( style !== \"decimal\" && style !== \"percent\" ) {\n\t\tthrow new Error( \"Invalid style\" );\n\t}\n\n\treturn cldr.main([\n\t\t\"numbers\",\n\t\tstyle + \"Formats-numberSystem-\" + numberNumberingSystem( cldr ),\n\t\t\"standard\"\n\t]);\n};\n\n\n\n\n/**\n * EBNF representation:\n *\n * compact_pattern_re =       prefix?\n *                            number_pattern_re\n *                            suffix?\n *\n * number_pattern_re =        0+\n *\n * Regexp groups:\n *\n *  0: compact_pattern_re\n *  1: prefix\n *  2: number_pattern_re (the number pattern to use in compact mode)\n *  3: suffix\n */\nvar numberCompactPatternRe = ( /^([^0]*)(0+)([^0]*)$/ );\n\n\n\n\n/**\n * goupingSeparator( number, primaryGroupingSize, secondaryGroupingSize )\n *\n * @number [Number].\n *\n * @primaryGroupingSize [Number]\n *\n * @secondaryGroupingSize [Number]\n *\n * Return the formatted number with group separator.\n */\nvar numberFormatGroupingSeparator = function( number, primaryGroupingSize, secondaryGroupingSize ) {\n\tvar index,\n\t\tcurrentGroupingSize = primaryGroupingSize,\n\t\tret = \"\",\n\t\tsep = \",\",\n\t\tswitchToSecondary = secondaryGroupingSize ? true : false;\n\n\tnumber = String( number ).split( \".\" );\n\tindex = number[ 0 ].length;\n\n\twhile ( index > currentGroupingSize ) {\n\t\tret = number[ 0 ].slice( index - currentGroupingSize, index ) +\n\t\t\t( ret.length ? sep : \"\" ) + ret;\n\t\tindex -= currentGroupingSize;\n\t\tif ( switchToSecondary ) {\n\t\t\tcurrentGroupingSize = secondaryGroupingSize;\n\t\t\tswitchToSecondary = false;\n\t\t}\n\t}\n\n\tnumber[ 0 ] = number[ 0 ].slice( 0, index ) + ( ret.length ? sep : \"\" ) + ret;\n\treturn number.join( \".\" );\n};\n\n\n\n\n/**\n * integerFractionDigits( number, minimumIntegerDigits, minimumFractionDigits,\n * maximumFractionDigits, round, roundIncrement )\n *\n * @number [Number]\n *\n * @minimumIntegerDigits [Number]\n *\n * @minimumFractionDigits [Number]\n *\n * @maximumFractionDigits [Number]\n *\n * @round [Function]\n *\n * @roundIncrement [Function]\n *\n * Return the formatted integer and fraction digits.\n */\nvar numberFormatIntegerFractionDigits = function( number, minimumIntegerDigits, minimumFractionDigits, maximumFractionDigits, round,\n\troundIncrement ) {\n\n\t// Fraction\n\tif ( maximumFractionDigits ) {\n\n\t\t// Rounding\n\t\tif ( roundIncrement ) {\n\t\t\tnumber = round( number, roundIncrement );\n\n\t\t// Maximum fraction digits\n\t\t} else {\n\t\t\tnumber = round( number, { exponent: -maximumFractionDigits } );\n\t\t}\n\n\t} else {\n\t\tnumber = round( number );\n\t}\n\n\tnumber = String( number );\n\n\t// Maximum integer digits (post string phase)\n\tif ( maximumFractionDigits && /e-/.test( number ) ) {\n\n\t\t// Use toFixed( maximumFractionDigits ) to make sure small numbers like 1e-7 are\n\t\t// displayed using plain digits instead of scientific notation.\n\t\t// 1: Remove leading decimal zeros.\n\t\t// 2: Remove leading decimal separator.\n\t\t// Note: String() is still preferred so it doesn't mess up with a number precision\n\t\t// unnecessarily, e.g., (123456789.123).toFixed(10) === \"123456789.1229999959\",\n\t\t// String(123456789.123) === \"123456789.123\".\n\t\tnumber = ( +number ).toFixed( maximumFractionDigits )\n\t\t\t.replace( /0+$/, \"\" ) /* 1 */\n\t\t\t.replace( /\\.$/, \"\" ); /* 2 */\n\t}\n\n\t// Minimum fraction digits (post string phase)\n\tif ( minimumFractionDigits ) {\n\t\tnumber = number.split( \".\" );\n\t\tnumber[ 1 ] = stringPad( number[ 1 ] || \"\", minimumFractionDigits, true );\n\t\tnumber = number.join( \".\" );\n\t}\n\n\t// Minimum integer digits\n\tif ( minimumIntegerDigits ) {\n\t\tnumber = number.split( \".\" );\n\t\tnumber[ 0 ] = stringPad( number[ 0 ], minimumIntegerDigits );\n\t\tnumber = number.join( \".\" );\n\t}\n\n\treturn number;\n};\n\n\n\n\n/**\n * toPrecision( number, precision, round )\n *\n * @number (Number)\n *\n * @precision (Number) significant figures precision (not decimal precision).\n *\n * @round (Function)\n *\n * Return number.toPrecision( precision ) using the given round function.\n */\nvar numberToPrecision = function( number, precision, round ) {\n\tvar roundOrder;\n\n\tif ( number === 0 ) {  // Fix #706\n\t\treturn number;\n\t}\n\n\troundOrder = Math.ceil( Math.log( Math.abs( number ) ) / Math.log( 10 ) );\n\troundOrder -= precision;\n\n\treturn round( number, { exponent: roundOrder } );\n};\n\n\n\n\n/**\n * toPrecision( number, minimumSignificantDigits, maximumSignificantDigits, round )\n *\n * @number [Number]\n *\n * @minimumSignificantDigits [Number]\n *\n * @maximumSignificantDigits [Number]\n *\n * @round [Function]\n *\n * Return the formatted significant digits number.\n */\nvar numberFormatSignificantDigits = function( number, minimumSignificantDigits, maximumSignificantDigits, round ) {\n\tvar atMinimum, atMaximum;\n\n\t// Sanity check.\n\tif ( minimumSignificantDigits > maximumSignificantDigits ) {\n\t\tmaximumSignificantDigits = minimumSignificantDigits;\n\t}\n\n\tatMinimum = numberToPrecision( number, minimumSignificantDigits, round );\n\tatMaximum = numberToPrecision( number, maximumSignificantDigits, round );\n\n\t// Use atMaximum only if it has more significant digits than atMinimum.\n\tnumber = +atMinimum === +atMaximum ? atMinimum : atMaximum;\n\n\t// Expand integer numbers, eg. 123e5 to 12300.\n\tnumber = ( +number ).toString( 10 );\n\n\tif ( ( /e/ ).test( number ) ) {\n\t\tthrow createErrorUnsupportedFeature({\n\t\t\tfeature: \"integers out of (1e21, 1e-7)\"\n\t\t});\n\t}\n\n\t// Add trailing zeros if necessary.\n\tif ( minimumSignificantDigits - number.replace( /^0+|\\./g, \"\" ).length > 0 ) {\n\t\tnumber = number.split( \".\" );\n\t\tnumber[ 1 ] = stringPad( number[ 1 ] || \"\", minimumSignificantDigits - number[ 0 ].replace( /^0+/, \"\" ).length, true );\n\t\tnumber = number.join( \".\" );\n\t}\n\n\treturn number;\n};\n\n\n\n\n/**\n * format( number, properties )\n *\n * @number [Number].\n *\n * @properties [Object] Output of number/format-properties.\n *\n * Return the formatted number.\n * ref: http://www.unicode.org/reports/tr35/tr35-numbers.html\n */\nvar numberFormat = function( number, properties, pluralGenerator ) {\n\tvar aux, compactMap, infinitySymbol, maximumFractionDigits, maximumSignificantDigits,\n\t\tminimumFractionDigits, minimumIntegerDigits, minimumSignificantDigits, nanSymbol,\n\t\tnuDigitsMap, prefix, primaryGroupingSize, pattern, round, roundIncrement,\n\t\tsecondaryGroupingSize, stringToParts, suffix, symbolMap;\n\n\tminimumIntegerDigits = properties[ 2 ];\n\tminimumFractionDigits = properties[ 3 ];\n\tmaximumFractionDigits = properties[ 4 ];\n\tminimumSignificantDigits = properties[ 5 ];\n\tmaximumSignificantDigits = properties[ 6 ];\n\troundIncrement = properties[ 7 ];\n\tprimaryGroupingSize = properties[ 8 ];\n\tsecondaryGroupingSize = properties[ 9 ];\n\tround = properties[ 15 ];\n\tinfinitySymbol = properties[ 16 ];\n\tnanSymbol = properties[ 17 ];\n\tsymbolMap = properties[ 18 ];\n\tnuDigitsMap = properties[ 19 ];\n\tcompactMap = properties[ 20 ];\n\n\t// NaN\n\tif ( isNaN( number ) ) {\n\t\treturn [ { type: \"nan\", value: nanSymbol } ];\n\t}\n\n\tif ( number < 0 ) {\n\t\tpattern = properties[ 12 ];\n\t\tprefix = properties[ 13 ];\n\t\tsuffix = properties[ 14 ];\n\t} else {\n\t\tpattern = properties[ 11 ];\n\t\tprefix = properties[ 0 ];\n\t\tsuffix = properties[ 10 ];\n\t}\n\n\t// For prefix, suffix, and number parts.\n\tstringToParts = function( string ) {\n\t\tvar numberType = \"integer\",\n\t\t\tparts = [];\n\n\t\t// TODO Move the tokenization of all parts that don't depend on number into\n\t\t// format-properties.\n\t\tstring.replace( /('([^']|'')+'|'')|./g, function( character, literal ) {\n\n\t\t\t// Literals\n\t\t\tif ( literal ) {\n\t\t\t\tpartsPush( parts, \"literal\", removeLiteralQuotes( literal ) );\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Currency symbol\n\t\t\tif ( character === \"\\u00A4\" ) {\n\t\t\t\tpartsPush( parts, \"currency\", character );\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Symbols\n\t\t\tcharacter = character.replace( /[.,\\-+E%\\u2030]/, function( symbol ) {\n\t\t\t\tif ( symbol === \".\" ) {\n\t\t\t\t\tnumberType = \"fraction\";\n\t\t\t\t}\n\t\t\t\tpartsPush( parts, numberSymbolName[ symbol ], symbolMap[ symbol ] );\n\n\t\t\t\t// \"Erase\" handled character.\n\t\t\t\treturn \"\";\n\t\t\t});\n\n\t\t\t// Number\n\t\t\tcharacter = character.replace( /[0-9]/, function( digit ) {\n\n\t\t\t\t// Numbering system\n\t\t\t\tif ( nuDigitsMap ) {\n\t\t\t\t\tdigit = nuDigitsMap[ +digit ];\n\t\t\t\t}\n\t\t\t\tpartsPush( parts, numberType, digit );\n\n\t\t\t\t// \"Erase\" handled character.\n\t\t\t\treturn \"\";\n\t\t\t});\n\n\t\t\t// Etc\n\t\t\tcharacter.replace( /./, function( etc ) {\n\t\t\t\tpartsPush( parts, \"literal\", etc );\n\t\t\t});\n\t\t});\n\t\treturn parts;\n\t};\n\n\tprefix = stringToParts( prefix );\n\tsuffix = stringToParts( suffix );\n\n\t// Infinity\n\tif ( !isFinite( number ) ) {\n\t\treturn prefix.concat(\n\t\t\t{ type: \"infinity\", value: infinitySymbol },\n\t\t\tsuffix\n\t\t);\n\t}\n\n\t// Percent\n\tif ( pattern.indexOf( \"%\" ) !== -1 ) {\n\t\tnumber *= 100;\n\n\t// Per mille\n\t} else if ( pattern.indexOf( \"\\u2030\" ) !== -1 ) {\n\t\tnumber *= 1000;\n\t}\n\n\tvar compactPattern, compactDigits, compactProperties, divisor, numberExponent, pluralForm;\n\n\t// Compact mode: initial number digit processing\n\tif ( compactMap ) {\n\t\tnumberExponent = Math.abs( Math.floor( number ) ).toString().length - 1;\n\t\tnumberExponent = Math.min( numberExponent, compactMap.maxExponent );\n\n\t\t// Use default plural form to perform initial decimal shift\n\t\tif ( numberExponent >= 3 ) {\n\t\t\tcompactPattern = compactMap[ numberExponent ] && compactMap[ numberExponent ].other;\n\t\t}\n\n\t\tif ( compactPattern === \"0\" ) {\n\t\t\tcompactPattern = null;\n\t\t} else if ( compactPattern ) {\n\t\t\tcompactDigits = compactPattern.split( \"0\" ).length - 1;\n\t\t\tdivisor = numberExponent - ( compactDigits - 1 );\n\t\t\tnumber = number / Math.pow( 10, divisor );\n\t\t}\n\t}\n\n\t// Significant digit format\n\tif ( !isNaN( minimumSignificantDigits * maximumSignificantDigits ) ) {\n\t\tnumber = numberFormatSignificantDigits( number, minimumSignificantDigits,\n\t\t\tmaximumSignificantDigits, round );\n\n\t// Integer and fractional format\n\t} else {\n\t\tnumber = numberFormatIntegerFractionDigits( number, minimumIntegerDigits,\n\t\t\tminimumFractionDigits, maximumFractionDigits, round, roundIncrement );\n\t}\n\n\t// Compact mode: apply formatting\n\tif ( compactMap && compactPattern ) {\n\n\t\t// Get plural form after possible roundings\n\t\tpluralForm = pluralGenerator ? pluralGenerator( +number ) : \"other\";\n\n\t\tcompactPattern = compactMap[ numberExponent ][ pluralForm ] || compactPattern;\n\t\tcompactProperties = compactPattern.match( numberCompactPatternRe );\n\n\t\t// TODO Move the tokenization of all parts that don't depend on number into\n\t\t// format-properties.\n\t\taux = function( string ) {\n\t\t\tvar parts = [];\n\t\t\tstring.replace( /(\\s+)|([^\\s0]+)/g, function( _garbage, space, compact ) {\n\n\t\t\t\t// Literals\n\t\t\t\tif ( space ) {\n\t\t\t\t\tpartsPush( parts, \"literal\", space );\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\t// Compact value\n\t\t\t\tif ( compact ) {\n\t\t\t\t\tpartsPush( parts, \"compact\", compact );\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t});\n\t\t\treturn parts;\n\t\t};\n\n\t\t// update prefix/suffix with compact prefix/suffix\n\t\tprefix = prefix.concat( aux( compactProperties[ 1 ] ) );\n\t\tsuffix = aux( compactProperties[ 3 ] ).concat( suffix );\n\t}\n\n\t// Remove the possible number minus sign\n\tnumber = number.replace( /^-/, \"\" );\n\n\t// Grouping separators\n\tif ( primaryGroupingSize ) {\n\t\tnumber = numberFormatGroupingSeparator( number, primaryGroupingSize,\n\t\t\tsecondaryGroupingSize );\n\t}\n\n\t// Scientific notation\n\t// TODO implement here\n\n\t// Padding/'([^']|'')+'|''|[.,\\-+E%\\u2030]/g\n\t// TODO implement here\n\n\treturn prefix.concat(\n\t\tstringToParts( number ),\n\t\tsuffix\n\t);\n};\n\n\n\n\nvar numberToPartsFormatterFn = function( properties, pluralGenerator ) {\n\treturn function numberToPartsFormatter( value ) {\n\t\tvalidateParameterPresence( value, \"value\" );\n\t\tvalidateParameterTypeNumber( value, \"value\" );\n\n\t\treturn numberFormat( value, properties, pluralGenerator );\n\t};\n};\n\n\n\n\nfunction validateDigits( properties ) {\n\tvar minimumIntegerDigits = properties[ 2 ],\n\t\tminimumFractionDigits = properties[ 3 ],\n\t\tmaximumFractionDigits = properties[ 4 ],\n\t\tminimumSignificantDigits = properties[ 5 ],\n\t\tmaximumSignificantDigits = properties[ 6 ];\n\n\t// Validate significant digit format properties\n\tif ( !isNaN( minimumSignificantDigits * maximumSignificantDigits ) ) {\n\t\tvalidateParameterRange( minimumSignificantDigits, \"minimumSignificantDigits\", 1, 21 );\n\t\tvalidateParameterRange( maximumSignificantDigits, \"maximumSignificantDigits\",\n\t\t\tminimumSignificantDigits, 21 );\n\n\t} else if ( !isNaN( minimumSignificantDigits ) || !isNaN( maximumSignificantDigits ) ) {\n\t\tthrow new Error( \"Neither or both the minimum and maximum significant digits must be \" +\n\t\t\t\"present\" );\n\n\t// Validate integer and fractional format\n\t} else {\n\t\tvalidateParameterRange( minimumIntegerDigits, \"minimumIntegerDigits\", 1, 21 );\n\t\tvalidateParameterRange( minimumFractionDigits, \"minimumFractionDigits\", 0, 20 );\n\t\tvalidateParameterRange( maximumFractionDigits, \"maximumFractionDigits\",\n\t\t\tminimumFractionDigits, 20 );\n\t}\n}\n\n/**\n * .numberFormatter( [options] )\n *\n * @options [Object]:\n * - style: [String] \"decimal\" (default) or \"percent\".\n * - see also number/format options.\n *\n * Return a function that formats a number according to the given options and default/instance\n * locale.\n */\nGlobalize.numberFormatter =\nGlobalize.prototype.numberFormatter = function( options ) {\n\tvar args, numberToPartsFormatter, returnFn;\n\n\tvalidateParameterTypePlainObject( options, \"options\" );\n\n\toptions = options || {};\n\targs = [ options ];\n\n\tnumberToPartsFormatter = this.numberToPartsFormatter( options );\n\treturnFn = numberFormatterFn( numberToPartsFormatter );\n\truntimeBind( args, this.cldr, returnFn, [ numberToPartsFormatter ] );\n\n\treturn returnFn;\n};\n\n/**\n * .numberToPartsFormatter( [options] )\n *\n * @options [Object]:\n * - style: [String] \"symbol\" (default), \"accounting\", \"code\" or \"name\".\n * - see also number/format options.\n *\n * Return a function that formats a number to parts according to the given options and\n * default/instance locale.\n */\nGlobalize.numberToPartsFormatter =\nGlobalize.prototype.numberToPartsFormatter = function( options ) {\n\tvar args, cldr, fnArgs, pattern, properties, returnFn;\n\n\tvalidateParameterTypePlainObject( options, \"options\" );\n\n\toptions = options || {};\n\tcldr = this.cldr;\n\n\targs = [ options ];\n\n\tvalidateDefaultLocale( cldr );\n\n\tcldr.on( \"get\", validateCldr );\n\ttry {\n\t\tif ( options.raw ) {\n\t\t\tpattern = options.raw;\n\t\t} else {\n\t\t\tpattern = numberPattern( options.style || \"decimal\", cldr );\n\t\t}\n\n\t\tproperties = numberFormatProperties( pattern, cldr, options );\n\t\tfnArgs = [ properties ];\n\t} finally {\n\t\tcldr.off( \"get\", validateCldr );\n\t}\n\n\tvalidateDigits( properties );\n\n\tif ( options.compact ) {\n\t\tfnArgs.push( this.pluralGenerator() );\n\t}\n\treturnFn = numberToPartsFormatterFn.apply( null, fnArgs );\n\truntimeBind( args, cldr, returnFn, fnArgs );\n\n\treturn returnFn;\n};\n\n/**\n * .numberParser( [options] )\n *\n * @options [Object]:\n * - style: [String] \"decimal\" (default) or \"percent\".\n *\n * Return the number parser according to the default/instance locale.\n */\nGlobalize.numberParser =\nGlobalize.prototype.numberParser = function( options ) {\n\tvar args, cldr, pattern, properties, returnFn;\n\n\tvalidateParameterTypePlainObject( options, \"options\" );\n\n\toptions = options || {};\n\tcldr = this.cldr;\n\n\targs = [ options ];\n\n\tvalidateDefaultLocale( cldr );\n\tif ( options.compact ) {\n\t\tthrow createErrorUnsupportedFeature({\n\t\t\tfeature: \"compact number parsing (not implemented)\"\n\t\t});\n\t}\n\n\tcldr.on( \"get\", validateCldr );\n\n\tif ( options.raw ) {\n\t\tpattern = options.raw;\n\t} else {\n\t\tpattern = numberPattern( options.style || \"decimal\", cldr );\n\t}\n\n\tproperties = numberParseProperties( pattern, cldr, options );\n\n\tcldr.off( \"get\", validateCldr );\n\n\treturnFn = numberParserFn( properties );\n\n\truntimeBind( args, cldr, returnFn, [ properties ] );\n\n\treturn returnFn;\n};\n\n/**\n * .formatNumber( value [, options] )\n *\n * @value [Number] number to be formatted.\n *\n * @options [Object]: see number/format-properties.\n *\n * Format a number according to the given options and default/instance locale.\n */\nGlobalize.formatNumber =\nGlobalize.prototype.formatNumber = function( value, options ) {\n\tvalidateParameterPresence( value, \"value\" );\n\tvalidateParameterTypeNumber( value, \"value\" );\n\n\treturn this.numberFormatter( options )( value );\n};\n\n/**\n * .formatNumberToParts( value [, options] )\n *\n * @value [Number] number to be formatted.\n *\n * @options [Object]: see number/format-properties.\n *\n * Format a number to pars according to the given options and default/instance locale.\n */\nGlobalize.formatNumberToParts =\nGlobalize.prototype.formatNumberToParts = function( value, options ) {\n\tvalidateParameterPresence( value, \"value\" );\n\tvalidateParameterTypeNumber( value, \"value\" );\n\n\treturn this.numberToPartsFormatter( options )( value );\n};\n\n/**\n * .parseNumber( value [, options] )\n *\n * @value [String]\n *\n * @options [Object]: See numberParser().\n *\n * Return the parsed Number (including Infinity) or NaN when value is invalid.\n */\nGlobalize.parseNumber =\nGlobalize.prototype.parseNumber = function( value, options ) {\n\tvalidateParameterPresence( value, \"value\" );\n\tvalidateParameterTypeString( value, \"value\" );\n\n\treturn this.numberParser( options )( value );\n};\n\n/**\n * Optimization to avoid duplicating some internal functions across modules.\n */\nGlobalize._createErrorUnsupportedFeature = createErrorUnsupportedFeature;\nGlobalize._numberNumberingSystem = numberNumberingSystem;\nGlobalize._numberNumberingSystemDigitsMap = numberNumberingSystemDigitsMap;\nGlobalize._numberPattern = numberPattern;\nGlobalize._numberSymbol = numberSymbol;\nGlobalize._looseMatching = looseMatching;\nGlobalize._removeLiteralQuotes = removeLiteralQuotes;\nGlobalize._stringPad = stringPad;\nGlobalize._validateParameterTypeNumber = validateParameterTypeNumber;\nGlobalize._validateParameterTypeString = validateParameterTypeString;\n\nreturn Globalize;\n\n\n\n\n}));\n","\"use strict\";\n\nvar assertion = require(\"./utils/assertion\");\n\n// Load Globalize main module.\nvar Globalize = require(\"globalize/dist/globalize\");\n\n// Extend Globalize with number and currency modules.\nrequire(\"globalize/dist/globalize/number\");\n\nvar basic = require(\"./utils/basic\");\nvar objectAssign = require(\"object-assign\");\n\nvar assert = assertion.assert;\nvar assertMetadata = assertion.assertMetadata;\nvar assertRange = assertion.assertRange;\nvar assertType = assertion.assertType;\nvar getValueOrDefault = basic.getValueOrDefault;\n\n// Load functions shared with Node\nvar numberHelpers = require(\"./utils/numberHelpers\");\nvar assertCanonicalNumberType = numberHelpers.assertCanonicalNumberType;\nvar assertLocalizedNumberType = numberHelpers.assertLocalizedNumberType;\nvar setFractionDigits = numberHelpers.setFractionDigits;\n\nfunction assertRangeCurrencyCode(handler, parameter) {\n  assertRange(\n    parameter,\n    handler.metadata.cldrCurrencies,\n    'The ISO currency code `\"{parameterValue}\"` is invalid',\n    { parameterValue: parameter }\n  );\n}\n\nvar NumberHandler = function() {};\n\nvar optionsPrototype = {\n  parts: function() {\n    this.outputType = \"parts\";\n    return this;\n  },\n  currencyDisplay: function(currencyDisplay) {\n    this.currencyDisplay = currencyDisplay;\n    return this;\n  }\n};\n\nObject.defineProperty(NumberHandler.prototype, \"NUMBER_FORMAT\", {\n  get: function() {\n    return {\n      style: \"decimal\",\n      maximumFractionDigits: 9,\n      minimumFractionDigits: 0\n    };\n  },\n  enumerable: true\n});\nvar NUMBER_FORMAT = NumberHandler.prototype.NUMBER_FORMAT;\n\nObject.defineProperty(NumberHandler.prototype, \"NUMBER_FORMAT_PERCENT\", {\n  get: function() {\n    return {\n      style: \"percent\",\n      maximumFractionDigits: 2,\n      minimumFractionDigits: 0\n    };\n  },\n  enumerable: true\n});\n\n// define currency presets on handler\nvar CURRENCY_PRESETS = {\n  CURRENCY_FORMAT: \"symbol\",\n  CURRENCY_FORMAT_ISOCURRENCY: \"code\",\n  CURRENCY_FORMAT_SYMBOLISOCURRENCY: \"international\"\n};\nObject.keys(CURRENCY_PRESETS).forEach(function(presetName) {\n  Object.defineProperty(NumberHandler.prototype, presetName, {\n    get: function() {\n      var presetValue = CURRENCY_PRESETS[presetName];\n      return Object.create(optionsPrototype).currencyDisplay(presetValue);\n    },\n    enumerable: true\n  });\n});\n// get array of values for assertRange\nvar CURRENCY_PRESET_VALUES = Object.keys(CURRENCY_PRESETS).map(function(\n  presetName\n) {\n  return CURRENCY_PRESETS[presetName];\n});\n\n/**\n * formatNumber\n */\nObject.defineProperty(NumberHandler.prototype, \"formatNumber\", {\n  value: function formatNumber(number, options) {\n    options = getValueOrDefault(options, NUMBER_FORMAT);\n    number = assertCanonicalNumberType(number, \"number\");\n    assertType(options, \"options\", [\"plain object\"]);\n    assert(\n      options.currencyDisplay === undefined,\n      \"Invalid `options` property `currencyDisplay`. Use `.formatCurrency()` instead\"\n    );\n    options = objectAssign({}, options);\n    setFractionDigits(options);\n    return this.globalize.formatNumber(number, options);\n  },\n  enumerable: true\n});\n\n/**\n * normalizeNumber\n */\nObject.defineProperty(NumberHandler.prototype, \"normalizeNumber\", {\n  value: function normalizeNumber(number, options) {\n    options = getValueOrDefault(options, NUMBER_FORMAT);\n    assertLocalizedNumberType(number, \"number\");\n    assertType(options, \"options\", [\"plain object\"]);\n    if (typeof number === \"number\") {\n      return number;\n    }\n    return this.globalize.parseNumber(number, options);\n  },\n  enumerable: true\n});\n\nfunction numberStyles(handler) {\n  return handler.metadata.cldrNumbers[\"symbols-numberSystem-latn\"];\n}\n\nfunction symbolForCurrency(handler, currencyCode) {\n  var currencyMeta = handler.metadata.cldrCurrencies[currencyCode];\n  return currencyMeta && currencyMeta.symbol;\n}\n\nfunction currencyStyles(handler, currency) {\n  var newCurrencyStyles = {},\n    supportedStyles = [\n      \"international\",\n      \"code\",\n      \"plural\",\n      \"separator\",\n      \"symbol\"\n    ];\n  supportedStyles.forEach(function(style) {\n    newCurrencyStyles[style] = currencyPatternByStyle(\n      handler,\n      { currencyDisplay: style },\n      currency\n    );\n  });\n  return newCurrencyStyles;\n}\n\nfunction currencyPatternByStyle(handler, options, currency) {\n  var metadata = handler.metadata,\n    currencyStyles = metadata.currencyStyles,\n    didCurrencyLevelOverride = false; // set this to true if the style was overriden at the currency level\n\n  if (!options) {\n    options = { currencyDisplay: \"symbol\" };\n  }\n\n  var style = options.currencyDisplay;\n  var pattern = currencyStyles[style];\n\n  // Check if there's an override by currency (e.g. TRY) for this particular style and apply it\n  if (\n    currencyStyles.currency_override &&\n    currencyStyles.currency_override[currency] &&\n    currencyStyles.currency_override[currency][style]\n  ) {\n    pattern = currencyStyles.currency_override[currency][style];\n    didCurrencyLevelOverride = true; // set this flag so fuzzyMatch will be skipped\n  }\n\n  // if there was no override at the currency level\n  // and if this is the international style\n  // then apply fuzzyMatch\n  // basically: only apply fuzzyMatch to the vanilla international style\n  if (!didCurrencyLevelOverride && style === \"international\" && currency) {\n    var currencySymbol = symbolForCurrency(handler, currency);\n    if (!currencySymbol) {\n      return;\n    }\n    if (currencySymbol.length > 1) {\n      // call fuzzyMatch passing the currency Code MXN and currency Symbol $MX\n      var fuzzy = fuzzyMatch(currency, currencySymbol);\n      if (fuzzy >= 66) {\n        pattern = pattern.replace(/¤\\s*/g, \"\");\n      }\n    }\n  }\n\n  return pattern;\n}\n\n/***\n * @function\n * @name     fuzzyMatch\n * @input    it takes 2 strings valueA and valueB\n * @returns  {number} the percentage of how similar are both\n */\nfunction fuzzyMatch(svalueA, svalueB) {\n  if (svalueA === svalueB) {\n    return 100;\n  } else {\n    var valueA = svalueA.split(\"\"),\n      valueB = svalueB.split(\"\"),\n      equivalency = 0;\n    for (var i = 0; i < valueA.length; i++) {\n      if (valueB.indexOf(valueA[i]) !== -1) {\n        var position = valueB.indexOf(valueA[i]);\n        valueB.splice(position, 1);\n        equivalency++;\n      }\n    }\n    var weight = equivalency / valueA.length;\n    return weight * 100;\n  }\n}\n\nfunction digitsForCurrency(handler, currencyCode) {\n  return (\n    handler.metadata.currencyInfo[currencyCode] &&\n    handler.metadata.currencyInfo[currencyCode].digits\n  );\n}\n\nObject.defineProperty(NumberHandler.prototype, \"formatCurrency\", {\n  value: function formatCurrency(currency, options) {\n    var currencyCode, currencyValue;\n    options = getValueOrDefault(options, this.CURRENCY_FORMAT);\n\n    assertType(currency, \"currency\", [\"plain object\"]);\n    assertType(currency.currency, \"currency.currency\", [\"string\"]);\n    currencyValue = assertCanonicalNumberType(currency.value, \"currency.value\");\n    assertRangeCurrencyCode(this, currency.currency);\n\n    assertType(options, \"options\", [\"plain object\"]);\n    assertType(options.currencyDisplay, \"options.currencyDisplay\", [\"string\"]);\n    assertRange(\n      options.currencyDisplay,\n      CURRENCY_PRESET_VALUES,\n      'Invalid `options.currencyDisplay`: `\"{parameterValue}\"`',\n      { parameterValue: options.currencyDisplay }\n    );\n\n    currencyCode = currency.currency;\n    options = objectAssign({}, options);\n    var currencyDigits = digitsForCurrency(this, currencyCode);\n    setFractionDigits(options, currencyDigits);\n\n    var localeNumberStyles = numberStyles(this),\n      localeCurrencyStyles = currencyStyles(this, currencyCode),\n      symbol = symbolForCurrency(this, currencyCode),\n      formattedCurrency = \"\",\n      pattern = localeCurrencyStyles[options.currencyDisplay].split(\";\")[0];\n    if (options.outputType === \"parts\") {\n      formattedCurrency = [];\n    }\n\n    var formatBinder = function(key, value) {\n      if (options.outputType === \"parts\") {\n        var parts = { type: key, value: value };\n        formattedCurrency.push(parts);\n      } else {\n        formattedCurrency += value;\n      }\n    };\n\n    if (currencyValue < 0) {\n      pattern = localeCurrencyStyles[options.currencyDisplay].split(\";\")[1];\n      currencyValue = currencyValue * -1;\n    }\n    var numberOptions = NumberHandler.prototype.NUMBER_FORMAT;\n    numberOptions.maximumFractionDigits = options.maximumFractionDigits;\n    numberOptions.minimumFractionDigits = options.minimumFractionDigits;\n    var patternElements = {\n      \"-\": { key: \"sign\", value: localeNumberStyles.minusSign },\n      \"¤\": { key: \"symbol\", value: symbol },\n      \"#\": {\n        key: \"value\",\n        value: this.formatNumber(currencyValue, numberOptions)\n      },\n      C: { key: \"code\", value: currencyCode },\n      \"\\u00A0\": { key: \"separator\", value: localeCurrencyStyles.separator }\n    };\n\n    for (var i = 0; i < pattern.length; i++) {\n      var part = patternElements[pattern.charAt(i)] || {\n        key: \"literal\",\n        value: pattern.charAt(i)\n      };\n      formatBinder(part.key, part.value);\n    }\n\n    return formattedCurrency;\n  },\n  enumerable: true\n});\n\nfunction assertNumberMeta(metadata) {\n  assertType(metadata, \"metadata\", [\"plain object\"]);\n  assertMetadata(metadata.cldr);\n  assertMetadata(metadata.cldr.main);\n  assertMetadata(metadata.cldr.supplemental);\n  assertMetadata(metadata.griffin);\n  assertMetadata(metadata.griffin.number);\n\n  var griffinNumberMeta = metadata.griffin.number;\n  assertMetadata(griffinNumberMeta.country, [\"string\"]);\n  assertMetadata(griffinNumberMeta.currencyInfo);\n  assertMetadata(griffinNumberMeta.currencyStyles);\n\n  // We assume the only key in 'main' is the locale.\n  var cldrLocale = Object.keys(metadata.cldr.main)[0];\n  assertMetadata(cldrLocale, [\"string\"]);\n  var cldrMain = metadata.cldr.main[cldrLocale];\n  assertMetadata(cldrMain);\n  var cldrNumbers = cldrMain.numbers;\n  assertMetadata(cldrNumbers);\n  assertMetadata(cldrNumbers[\"symbols-numberSystem-latn\"]);\n  var cldrCurrencies = cldrNumbers.currencies;\n  assertMetadata(cldrCurrencies);\n  // assertMetadata(cldrCurrencies.styles); // now in griffin section\n}\n\nmodule.exports = {\n  // common createHandler code can be factored out and put in core\n  createHandler: function createHandler(metadata) {\n    // TODO validate metadata based on schema.\n    assertNumberMeta(metadata);\n\n    var handler = new NumberHandler();\n\n    // We assume the only key in 'main' is the locale.\n    var cldrLocale = Object.keys(metadata.cldr.main)[0];\n    var cldrMain = metadata.cldr.main[cldrLocale];\n    var cldrNumbers = cldrMain.numbers;\n    var cldrCurrencies = cldrNumbers.currencies;\n\n    var griffinNumberMeta = metadata.griffin.number;\n\n    // store particular parts of client metadata for use in the module\n    handler.metadata = {\n      country: griffinNumberMeta.country,\n      currencyStyles: griffinNumberMeta.currencyStyles,\n      currencyInfo: griffinNumberMeta.currencyInfo, // includes digits information\n      cldrNumbers: cldrNumbers,\n      cldrCurrencies: cldrCurrencies\n    };\n\n    // pass the cldr portion to Globalize\n    Globalize.load(metadata.cldr);\n    handler.globalize = Globalize(cldrLocale);\n\n    return handler;\n  }\n};\n","/**\n * Assertion utilities module.\n * @module utils/assertion\n *\n * @example\n *\n * function myFunction(foo, bar) {\n *   assertType(foo, 'foo', ['string']);\n *   assertType(bar, 'bar', ['plain object']);\n * }\n *\n * myFunction(1);\n * // > TypeError: Parameter `foo` must be a string, not number `1`\n *\n * myFunction(\"1\", []);\n * // > TypeError: Parameter `bar` must be a plain object, not array `[]`\n */\n\"use strict\";\n\nvar basic = require(\"./basic\");\nvar objectAssign = require(\"object-assign\");\n\nvar formatMessage = basic.formatMessage;\nvar listFormat = basic.listFormat;\nvar smarterTypeof = basic.smarterTypeof;\nvar withinRange = basic.withinRange;\n\n/**\n * Asserts values that are assumed to be true.\n * @param {boolean} condition - Won't throw if true, will throw if false.\n * @param {string} errorMessage - The error message. Can contain placeholders for variable\n *        replacement, e.g., 'Hello {name}' where the value for name comes from `options.name`.\n * @param {Object} [options]\n * @param {Object} [options.errorClass=Error] The class of the error to throw.\n * @param {string} [options.*] Any other option will be used for variable replacement in\n *        errorMessage.\n * @returns Returns `true` if *condition* if `true`.\n * @throws Will throw *option.errorClass* if *condition* if `false`.\n *\n * @example\n *\n * // This will not throw and return true.\n * assert(truthyValue, 'error message');\n * // > true\n *\n * @example\n *\n * // This will throw an error with this error message.\n * assert(falseyValue, 'error message');\n * // > throw Error('error message')\n */\nfunction assert(condition, errorMessage, options) {\n  var error, errorClass;\n\n  if (condition) {\n    return true;\n  }\n\n  options = options || {};\n  // Assign errorClass and remove it from options.\n  errorClass = options.errorClass || Error;\n\n  errorMessage = formatMessage(errorMessage, options);\n  error = new errorClass(errorMessage);\n  error.attributes = options;\n\n  throw error;\n}\n\n/**\n * TODO description.\n */\nfunction assertMetadata(metadataNode, expectedTypes) {\n  expectedTypes = expectedTypes || [\"plain object\"];\n  assertType(metadataNode, \"\", expectedTypes, {\n    errorMessage: \"The metadata is invalid\"\n  });\n}\n\n/**\n * Throw a TypeError in case *parameterValue* isn't any of *expectedTypes*.\n *\n * @param {*} parameterValue - Used in the error message as *parameterValue* and the deduced *parameterType* variables.\n * @param {string} parameterName - Used in the error message as *parameterName* variable.\n * @param {Array} expectedTypes - A list of expected (smart) typeofs.\n * @param {Object} [options]\n * @param {boolean} [options.condition] An optional condition that overrides the default logic, in which case *expectedTypes* values are completely ignored.\n * @param {String} [options.errorMessage] An optional error message that overrides the default one. Note the error message can use the following automatically set variables: parameterName, parameterValue, parameterType.\n *\n * @example\n *\n * myParam = \"foo\";\n * assertType(\n *   myParam,\n *   'myParam',\n *   [\"number\"]\n * );\n * // > TypeError: Parameter `myParam` must be a number, not string `\"foo\"`\n *\n * myParam = [];\n * assertType(\n *   myParam,\n *   'myParam',\n *   [\"number\", \"string\"]\n * );\n * // > TypeError: Parameter `myParam` must be a number or string, not array `[]`\n */\nfunction assertType(parameterValue, parameterName, expectedTypes, options) {\n  var parameterType = smarterTypeof(parameterValue);\n\n  options = options || {};\n  var condition =\n    options.condition || expectedTypes.indexOf(parameterType) !== -1;\n  var errorMessage =\n    options.errorMessage ||\n    \"Parameter `{parameterName}` must be a {expectedTypesMessage}, not {parameterType} `{{parameterValue}}`\";\n\n  assert(condition, errorMessage, {\n    errorClass: TypeError,\n    expectedTypesMessage: listFormat(expectedTypes, \"or\"),\n    parameterName: parameterName,\n    parameterType: parameterType,\n    parameterValue: parameterValue\n  });\n}\n\n/**\n * Throw a RangeError in case *element* isn't included in the *collection*.\n *\n * @param {*} element - The key of an Object or the element of an Array.\n * @param {(Array|Object)} collection - Where to search for element at.\n * @param {string} errorMessage - See assert().\n * @param {Object} [options] - See assert().\n *\n * @example\n * assertRange(\"quax\", [\"foo\", \"bar\", \"baz\"], \"Invalid element\");\n * // > RangeError: Invalid element\n *\n * assertRange(\"quax\", {\"foo\": 1, \"bar\": 2, \"baz\": 3}, \"Invalid key\");\n * // > RangeError: Invalid key\n */\nfunction assertRange(element, collection, errorMessage, options) {\n  assert(\n    withinRange(element, collection),\n    errorMessage,\n    objectAssign({ errorClass: RangeError }, options)\n  );\n}\n\nmodule.exports = {\n  assert: assert,\n  assertMetadata: assertMetadata,\n  assertRange: assertRange,\n  assertType: assertType\n};\n","\"use strict\";\n\n/**\n * Basic utilities module.\n * @module utils/basic\n */\n\n/* Gets value in object path\n * @param {object} obj\n * @param {string|array} path\n * @examples\n * get({foo: 1, bar: {baz: 2}}, 'bar/baz');\n * > 2\n * get({foo: 1, bar: {baz: 2}}, 'foo/bar/baz/quax');\n * > undefined\n */\nfunction objectGet(obj, path) {\n  if (typeof path === \"string\") {\n    path = path.split(\"/\");\n  }\n  var prop = path.slice(-1);\n  var node = path.slice(0, -1).reduce(function(node, item) {\n    return node[item] || {};\n  }, obj);\n  return node[prop];\n}\n\n/**\n * Sets value in object path\n * @param {object} obj\n * @param {string|array} path\n * @param {*} value\n * @examples\n * set({foo: 1}, 'bar/baz', 2);\n * // > {foo: 1, bar: {baz: 2}}\n */\nfunction objectSet(obj, path, value) {\n  if (typeof path === \"string\") {\n    path = path.split(\"/\");\n  }\n  var prop = path.slice(-1);\n  var node = path.slice(0, -1).reduce(function(node, item) {\n    return (node[item] = node[item] || {});\n  }, obj);\n  node[prop] = value;\n  return obj;\n}\n\n/**\n * Given an object, return an array of its property values.\n * @param {Object} object\n */\nfunction objectValues(object) {\n  return Object.keys(object).map(function(key) {\n    return object[key];\n  });\n}\n\n/**\n * Slices an object given a path.\n */\nfunction objectSlice(obj, path) {\n  path = path || [];\n  return objectSet({}, path, objectGet(obj, path));\n}\n\nfunction cloneArray(array) {\n  return array.slice(0);\n}\n\nfunction cloneDate(date) {\n  return new Date(date.getTime());\n}\n\n/**\n * Returns new deeply merged JSON-parsed objects.\n * @param {...object} obj - Object to perform deep merge\n * @returns {object} Deeply merged object. This returned object can be safely modified without\n * causing any change on any passed source objects.\n *\n * @example\n * merge( { a: { b: 1, c: 2 } }, { a: { b: 3, d: 4 } }, ... )\n * // > { a: { b: 3, c: 2, d: 4 } }\n *\n * Code from https://github.com/rxaviers/cldrjs/blob/master/src/util/json/merge.js\n */\nfunction jsonDeepMerge(/* obj */) {\n  var destination = {};\n  var sources = [].slice.call(arguments, 0);\n  sources.forEach(function(source) {\n    var prop;\n    for (prop in source) {\n      if (Array.isArray(source[prop])) {\n        // Clone and set arrays.\n        destination[prop] = cloneArray(source[prop]);\n      } else if (source[prop] instanceof Date) {\n        // Clone and set dates.\n        destination[prop] = cloneDate(source[prop]);\n      } else if (typeof source[prop] === \"object\") {\n        // Merge objects.\n        destination[prop] = jsonDeepMerge({}, destination[prop], source[prop]);\n      } else {\n        // Set new values.\n        destination[prop] = source[prop];\n      }\n    }\n  });\n  return destination;\n}\n\n/**\n * Oneliner for Object.defineProperty() using simple `value` descriptor.\n * @param {Object} object The object on which to define the property.\n * @param {string} property The name of the property to be defined or modified.\n * @param {*} value The value associated with the property. Can be any valid JavaScript value (number, object, function, etc).\n */\nfunction definePrivateProperty(object, property, value) {\n  Object.defineProperty(object, property, {\n    value: value\n  });\n}\n\n/**\n * TODO description.\n */\nfunction defineProperties(handler, properties) {\n  var propertiesNames = Object.keys(properties);\n  propertiesNames.forEach(function(key) {\n    Object.defineProperty(handler.prototype, key, {\n      get: function() {\n        return properties[key];\n      },\n      enumerable: true\n    });\n  });\n\n  return objectValues(properties);\n}\n\n/**\n * Formats a message replacing placeholders with variables values.\n * @param {string} message - A message that can contain placeholders.\n * @param {Object} [variables] - Variables for replacing message placeholders.\n *\n * @example\n * formatMessage(\"Hello {name}\", {name: \"John\"});\n * // > \"Hello John\"\n *\n * formatMessage(\"Hello {{name}}\", {name: \"John\"});\n * // > \"Hello \\\"John\\\"\"\n */\nfunction formatMessage(message, variables) {\n  return (\n    message\n      // Replace {{variable}} with `JSON.stringify(variableValue)`.\n      .replace(/{{([0-9a-zA-Z-_. ]+)}}/g, function(_, variable) {\n        // JSON.stringify(NaN) yields 'null', so we need a special case for NaN\n        if (\n          typeof variables[variable] === \"number\" &&\n          isNaN(variables[variable])\n        ) {\n          return \"NaN\";\n        }\n        return JSON.stringify(variables[variable]);\n      })\n      // Replace {variable} with `variableValue`.\n      .replace(/{([0-9a-zA-Z-_. ]+)}/g, function(_, variable) {\n        return variables[variable];\n      })\n  );\n}\n\n/**\n * Checks if passed *object* is a plain object.\n * @param {*} object - Value subject to test.\n * @returns {boolean} Returns `true` if *object* is a plain object or `false`.\n *\n * @example\n *\n * isPlainObject(); // > false\n * isPlainObject(null); // > false\n * isPlainObject(new Date()); // > false\n * isPlainObject([]); // > false\n * isPlainObject(1); // > false\n * isPlainObject(true); // > false\n * isPlainObject(\"foo\"); // > false\n * isPlainObject(function() {}); // > false\n * isPlainObject({a: 1}); // > true\n */\nfunction isPlainObject(object) {\n  // Inspired by jQuery Core, but reduced to our use case.\n  return (\n    object !== null &&\n    \"\" + object === \"[object Object]\" &&\n    object.constructor === Object\n  );\n}\n\n/**\n * @param {Array} array - The list of strings to glue together as an English formatted list string.\n * @param {string} conjunction - Conjunction value, e.g., `'and'`, `'or'`.\n * @returns {string} Returns an English formatted list string using the passed *conjunction*.\n *\n * @example\n *\n * listFormat([], 'or'); // > ''\n * listFormat(['foo'], 'or'); // > 'foo'\n * listFormat(['foo', 'bar'], 'or'); // > 'foo or bar'\n * listFormat(['foo', 'bar', 'baz'], 'or'); // > 'foo, or bar, or baz'\n */\nfunction listFormat(array, conjunction) {\n  if (array.length === 0) {\n    return \"\";\n  }\n  if (array.length === 1) {\n    return array[0];\n  }\n  if (array.length === 2) {\n    return array.join(\" \" + conjunction + \" \");\n  }\n  if (array.length > 2) {\n    return array.join(\", \" + conjunction + \" \");\n  }\n}\n\n/**\n * Returns the type of a variable with additional types than native `typeof`.\n * @param {*} variable - A variable to deduce its type.\n *\n * @example\n * smarterTypeof(null); // > \"null\"\n * smarterTypeof({a: 1}); // > \"plain object\"\n * smarterTypeof([]); // > \"array\"\n * smarterTypeof(new Date()); // > \"date\"\n * smarterTypeof(<anything else>); // > result of regular typeof.\n */\nfunction smarterTypeof(variable) {\n  if (variable === null) {\n    return \"null\";\n  }\n  if (isPlainObject(variable)) {\n    return \"plain object\";\n  }\n  if (Array.isArray(variable)) {\n    return \"array\";\n  }\n  if (variable instanceof Date) {\n    return \"date\";\n  }\n  return typeof variable;\n}\n\n/**\n * Returns `true` is *element* belongs to *collection*.\n * @param {*} element - The key of an Object or the element of an Array.\n * @param {(Array| Object)} Where to search for element at.\n *\n * @example\n *\n * withinRange(\"bar\", [\"foo\", \"bar\", \"baz\"]);\n * // > true\n * withinRange(\"quax\", [\"foo\", \"bar\", \"baz\"]);\n * // > false\n *\n * @example\n *\n * withinRange(\"bar\", {foo: 1, bar: 2, baz: 3});\n * // > true\n * withinRange(\"quax\", {foo: 1, bar: 2, baz: 3});\n * // > false\n */\nfunction withinRange(element, collection) {\n  return Array.isArray(collection)\n    ? collection.indexOf(element) !== -1\n    : element in collection;\n}\n\n/**\n * Given a value and a default for that value,\n * if value is undefined, return the default.\n * Otherwise, return the value itself.\n * @param {*} value the value which may or may not be undefined\n * @param {*} defaultValue the default for value\n *\n * @example\n *\n * getValueOrDefault('my string', 'default string');\n * // > 'my string'\n * getValueOrDefault(undefined, 'default string');\n * // > 'default string'\n */\nfunction getValueOrDefault(value, defaultValue) {\n  return value === undefined ? defaultValue : value;\n}\n\n/**\n * Given an object with properties and an array of valid string property names,\n * Clone the object and:\n * 1) Remove invalid properties,\n * 2) Remove non-string properties,\n * 3) Remove properties with only whitespace,\n * 4) Trim remaining string properties\n *\n * @param {Object} object the object to trim\n * @param {array} properties array of properties to preserve\n *\n * @return {Object} the cloned & trimmed object\n */\nfunction trimObject(object, properties) {\n  var clonedObject = {};\n  properties.forEach(function(property) {\n    var value = object[property];\n    if (value === undefined) {\n      return;\n    }\n    if (typeof value === \"string\") {\n      value = value.trim();\n    }\n    clonedObject[property] = value;\n  });\n  return clonedObject;\n}\n\n/**\n * Given a string, return true if all the characters are Latin script (roughly < U+024F)\n * Note that empty strings are Latin by definition\n * @param {string} string to test\n * @return {boolean}\n */\nfunction isLatin(string) {\n  if (!string) {\n    return true;\n  }\n  for (var i = 0; i < string.length; i++) {\n    if (\n      string.charCodeAt(i) > 0x24f &&\n      (string.charCodeAt(i) < 0x2000 || string.charCodeAt(i) > 0x206f)\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n/**\n * This version might be used in for loops and the like when\n * it is unknown whether non-BMP characters exist before the specified index position.\n * Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charCodeAt\n * @param {string} string to get the character\n * @peram {number} the index position\n **/\nfunction fixedCharCodeAt(str, idx) {\n  // ex. fixedCharCodeAt('\\uD800\\uDC00', 0); // 65536\n  // ex. fixedCharCodeAt('\\uD800\\uDC00', 1); // false\n  idx = idx || 0;\n  var code = str.charCodeAt(idx);\n  var hi, low;\n\n  // High surrogate (could change last hex to 0xDB7F\n  // to treat high private surrogates\n  // as single characters)\n  if (0xd800 <= code && code <= 0xdbff) {\n    hi = code;\n    low = str.charCodeAt(idx + 1);\n    if (isNaN(low)) {\n      return hi;\n    }\n    return (hi - 0xd800) * 0x400 + (low - 0xdc00) + 0x10000;\n  }\n  if (0xdc00 <= code && code <= 0xdfff) {\n    // Low surrogate\n    // We return false to allow loops to skip\n    // this iteration since should have already handled\n    // high surrogate above in the previous iteration\n    return false;\n    // hi = str.charCodeAt(idx - 1);\n    // low = code;\n    // return ((hi - 0xD800) * 0x400) +\n    //   (low - 0xDC00) + 0x10000;\n  }\n  return code;\n}\n\nfunction invalidCodePointFromString(string, regex) {\n  var codePoint;\n  for (var i = 0, chr; i < string.length; i++) {\n    if (string[i].match(regex) === null) {\n      if ((chr = fixedCharCodeAt(string, i)) === false) {\n        continue;\n      }\n      codePoint = chr;\n      /* we care only on the first one */\n      break;\n    }\n  }\n\n  return codePoint;\n}\n\nmodule.exports = {\n  objectGet: objectGet,\n  objectSet: objectSet,\n  objectValues: objectValues,\n  objectSlice: objectSlice,\n  jsonDeepMerge: jsonDeepMerge,\n  isLatin: isLatin,\n  trimObject: trimObject,\n  definePrivateProperty: definePrivateProperty,\n  defineProperties: defineProperties,\n  formatMessage: formatMessage,\n  getValueOrDefault: getValueOrDefault,\n  isPlainObject: isPlainObject,\n  listFormat: listFormat,\n  smarterTypeof: smarterTypeof,\n  withinRange: withinRange,\n  fixedCharCodeAt: fixedCharCodeAt,\n  invalidCodePointFromString: invalidCodePointFromString\n};\n","\"use strict\";\n\nvar assertion = require(\"./assertion\");\nvar assertType = assertion.assertType;\n\n/**\n * Asserts parameter type of a canonical number and type casts it into a Number\n * Disallows empty string and NaN\n * Used by Node\n */\nfunction assertCanonicalNumberTypeStrict(parameterValue, parameterName) {\n  var number = parameterValue;\n  assertType(parameterValue, parameterName, [], {\n    // if number, should not be NaN\n    // if string, cast to Number and should not be NaN\n    condition:\n      (typeof parameterValue === \"number\" && !isNaN(parameterValue)) ||\n      (typeof parameterValue === \"string\" &&\n        parameterValue !== \"\" &&\n        !isNaN((number = Number(parameterValue)))),\n    errorMessage:\n      'Parameter `{parameterName}` must be a number or a string representing a canonical number (e.g, `\"9999.99\"`), not {parameterType} `{{parameterValue}}`'\n  });\n  return number;\n}\n\n/**\n * Asserts parameter type of a canonical number and type casts it into a Number\n * Disallows empty string but allows NaN\n * Used by client\n */\nfunction assertCanonicalNumberType(parameterValue, parameterName) {\n  var number = parameterValue;\n  assertType(parameterValue, parameterName, [], {\n    // if string, cast to Number and result should not be NaN\n    condition:\n      typeof parameterValue === \"number\" ||\n      (typeof parameterValue === \"string\" &&\n        parameterValue !== \"\" &&\n        !isNaN((number = Number(parameterValue)))),\n    errorMessage:\n      'Parameter `{parameterName}` must be a number or a string representing a canonical number (e.g, `\"9999.99\"`), not {parameterType} `{{parameterValue}}`'\n  });\n  return number;\n}\n\n/**\n * Asserts parameter type of a localized number.\n */\nfunction assertLocalizedNumberType(parameterValue, parameterName) {\n  assertType(parameterValue, parameterName, [\"number\", \"string\"], {\n    errorMessage:\n      'Parameter `{parameterName}` must be a number or a string representing a localized number (e.g., `\"9,999.99\"` in English or `\"9.999,99\"` in Spanish), not {parameterType} `{{parameterValue}}`'\n  });\n}\n\n/**\n * Sets minimumFractionDigits/maximumFractionDigits in options:\n *\n * If either is undefined, currencyDigits is used (if provided)\n * Otherwise, minimumFractionDigits defaults to 0, and maximumFractionDigits defaults to 9\n * And if minimumFractionDigits is greater than maximumFractionDigits,\n * then minimumFractionDigits is reduced to the same level as maximumFractionDigits\n */\nfunction setFractionDigits(options, currencyDigits) {\n  // TODO: Use Globalize formatCurrency, which handles currency defaultDigits itself\n  if (options.minimumFractionDigits === undefined) {\n    options.minimumFractionDigits =\n      currencyDigits === undefined ? 0 : currencyDigits;\n  }\n  if (\n    options.maximumFractionDigits === undefined ||\n    options.maximumFractionDigits > 9\n  ) {\n    options.maximumFractionDigits =\n      currencyDigits === undefined ? 9 : currencyDigits;\n  }\n  if (options.minimumFractionDigits > options.maximumFractionDigits) {\n    options.minimumFractionDigits = options.maximumFractionDigits;\n  }\n  return options;\n}\n\nmodule.exports = {\n  assertCanonicalNumberType: assertCanonicalNumberType,\n  assertCanonicalNumberTypeStrict: assertCanonicalNumberTypeStrict,\n  assertLocalizedNumberType: assertLocalizedNumberType,\n  setFractionDigits: setFractionDigits\n};\n","\"use strict\";\nmodule.exports = require(\"./lib/client/number\");\n","/**\n * The base implementation of `_.propertyOf` without support for deep paths.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Function} Returns the new accessor function.\n */\nfunction basePropertyOf(object) {\n  return function(key) {\n    return object == null ? undefined : object[key];\n  };\n}\n\nmodule.exports = basePropertyOf;\n","var basePropertyOf = require('./_basePropertyOf');\n\n/** Used to map HTML entities to characters. */\nvar htmlUnescapes = {\n  '&amp;': '&',\n  '&lt;': '<',\n  '&gt;': '>',\n  '&quot;': '\"',\n  '&#39;': \"'\"\n};\n\n/**\n * Used by `_.unescape` to convert HTML entities to characters.\n *\n * @private\n * @param {string} chr The matched character to unescape.\n * @returns {string} Returns the unescaped character.\n */\nvar unescapeHtmlChar = basePropertyOf(htmlUnescapes);\n\nmodule.exports = unescapeHtmlChar;\n","var toString = require('./toString'),\n    unescapeHtmlChar = require('./_unescapeHtmlChar');\n\n/** Used to match HTML entities and HTML characters. */\nvar reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,\n    reHasEscapedHtml = RegExp(reEscapedHtml.source);\n\n/**\n * The inverse of `_.escape`; this method converts the HTML entities\n * `&amp;`, `&lt;`, `&gt;`, `&quot;`, and `&#39;` in `string` to\n * their corresponding characters.\n *\n * **Note:** No other HTML entities are unescaped. To unescape additional\n * HTML entities use a third-party library like [_he_](https://mths.be/he).\n *\n * @static\n * @memberOf _\n * @since 0.6.0\n * @category String\n * @param {string} [string=''] The string to unescape.\n * @returns {string} Returns the unescaped string.\n * @example\n *\n * _.unescape('fred, barney, &amp; pebbles');\n * // => 'fred, barney, & pebbles'\n */\nfunction unescape(string) {\n  string = toString(string);\n  return (string && reHasEscapedHtml.test(string))\n    ? string.replace(reEscapedHtml, unescapeHtmlChar)\n    : string;\n}\n\nmodule.exports = unescape;\n","'use strict';\n\nexports.__esModule = true;\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = require('prop-types');\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _TransitionGroup = require('./TransitionGroup');\n\nvar _TransitionGroup2 = _interopRequireDefault(_TransitionGroup);\n\nvar _CSSTransitionGroupChild = require('./CSSTransitionGroupChild');\n\nvar _CSSTransitionGroupChild2 = _interopRequireDefault(_CSSTransitionGroupChild);\n\nvar _PropTypes = require('./utils/PropTypes');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar propTypes = {\n  transitionName: _PropTypes.nameShape.isRequired,\n\n  transitionAppear: _propTypes2.default.bool,\n  transitionEnter: _propTypes2.default.bool,\n  transitionLeave: _propTypes2.default.bool,\n  transitionAppearTimeout: (0, _PropTypes.transitionTimeout)('Appear'),\n  transitionEnterTimeout: (0, _PropTypes.transitionTimeout)('Enter'),\n  transitionLeaveTimeout: (0, _PropTypes.transitionTimeout)('Leave')\n};\n\nvar defaultProps = {\n  transitionAppear: false,\n  transitionEnter: true,\n  transitionLeave: true\n};\n\nvar CSSTransitionGroup = function (_React$Component) {\n  _inherits(CSSTransitionGroup, _React$Component);\n\n  function CSSTransitionGroup() {\n    var _temp, _this, _ret;\n\n    _classCallCheck(this, CSSTransitionGroup);\n\n    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this._wrapChild = function (child) {\n      return _react2.default.createElement(_CSSTransitionGroupChild2.default, {\n        name: _this.props.transitionName,\n        appear: _this.props.transitionAppear,\n        enter: _this.props.transitionEnter,\n        leave: _this.props.transitionLeave,\n        appearTimeout: _this.props.transitionAppearTimeout,\n        enterTimeout: _this.props.transitionEnterTimeout,\n        leaveTimeout: _this.props.transitionLeaveTimeout\n      }, child);\n    }, _temp), _possibleConstructorReturn(_this, _ret);\n  }\n\n  // We need to provide this childFactory so that\n  // ReactCSSTransitionGroupChild can receive updates to name, enter, and\n  // leave while it is leaving.\n\n\n  CSSTransitionGroup.prototype.render = function render() {\n    return _react2.default.createElement(_TransitionGroup2.default, _extends({}, this.props, { childFactory: this._wrapChild }));\n  };\n\n  return CSSTransitionGroup;\n}(_react2.default.Component);\n\nCSSTransitionGroup.displayName = 'CSSTransitionGroup';\n\n\nCSSTransitionGroup.propTypes = process.env.NODE_ENV !== \"production\" ? propTypes : {};\nCSSTransitionGroup.defaultProps = defaultProps;\n\nexports.default = CSSTransitionGroup;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _addClass = require('dom-helpers/class/addClass');\n\nvar _addClass2 = _interopRequireDefault(_addClass);\n\nvar _removeClass = require('dom-helpers/class/removeClass');\n\nvar _removeClass2 = _interopRequireDefault(_removeClass);\n\nvar _requestAnimationFrame = require('dom-helpers/util/requestAnimationFrame');\n\nvar _requestAnimationFrame2 = _interopRequireDefault(_requestAnimationFrame);\n\nvar _properties = require('dom-helpers/transition/properties');\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = require('prop-types');\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _reactDom = require('react-dom');\n\nvar _PropTypes = require('./utils/PropTypes');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar events = [];\nif (_properties.transitionEnd) events.push(_properties.transitionEnd);\nif (_properties.animationEnd) events.push(_properties.animationEnd);\n\nfunction addEndListener(node, listener) {\n  if (events.length) {\n    events.forEach(function (e) {\n      return node.addEventListener(e, listener, false);\n    });\n  } else {\n    setTimeout(listener, 0);\n  }\n\n  return function () {\n    if (!events.length) return;\n    events.forEach(function (e) {\n      return node.removeEventListener(e, listener, false);\n    });\n  };\n}\n\nvar propTypes = {\n  children: _propTypes2.default.node,\n  name: _PropTypes.nameShape.isRequired,\n\n  // Once we require timeouts to be specified, we can remove the\n  // boolean flags (appear etc.) and just accept a number\n  // or a bool for the timeout flags (appearTimeout etc.)\n  appear: _propTypes2.default.bool,\n  enter: _propTypes2.default.bool,\n  leave: _propTypes2.default.bool,\n  appearTimeout: _propTypes2.default.number,\n  enterTimeout: _propTypes2.default.number,\n  leaveTimeout: _propTypes2.default.number\n};\n\nvar CSSTransitionGroupChild = function (_React$Component) {\n  _inherits(CSSTransitionGroupChild, _React$Component);\n\n  function CSSTransitionGroupChild() {\n    var _temp, _this, _ret;\n\n    _classCallCheck(this, CSSTransitionGroupChild);\n\n    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.componentWillAppear = function (done) {\n      if (_this.props.appear) {\n        _this.transition('appear', done, _this.props.appearTimeout);\n      } else {\n        done();\n      }\n    }, _this.componentWillEnter = function (done) {\n      if (_this.props.enter) {\n        _this.transition('enter', done, _this.props.enterTimeout);\n      } else {\n        done();\n      }\n    }, _this.componentWillLeave = function (done) {\n      if (_this.props.leave) {\n        _this.transition('leave', done, _this.props.leaveTimeout);\n      } else {\n        done();\n      }\n    }, _temp), _possibleConstructorReturn(_this, _ret);\n  }\n\n  CSSTransitionGroupChild.prototype.componentWillMount = function componentWillMount() {\n    this.classNameAndNodeQueue = [];\n    this.transitionTimeouts = [];\n  };\n\n  CSSTransitionGroupChild.prototype.componentWillUnmount = function componentWillUnmount() {\n    this.unmounted = true;\n\n    if (this.timeout) {\n      clearTimeout(this.timeout);\n    }\n    this.transitionTimeouts.forEach(function (timeout) {\n      clearTimeout(timeout);\n    });\n\n    this.classNameAndNodeQueue.length = 0;\n  };\n\n  CSSTransitionGroupChild.prototype.transition = function transition(animationType, finishCallback, timeout) {\n    var node = (0, _reactDom.findDOMNode)(this);\n\n    if (!node) {\n      if (finishCallback) {\n        finishCallback();\n      }\n      return;\n    }\n\n    var className = this.props.name[animationType] || this.props.name + '-' + animationType;\n    var activeClassName = this.props.name[animationType + 'Active'] || className + '-active';\n    var timer = null;\n    var removeListeners = void 0;\n\n    (0, _addClass2.default)(node, className);\n\n    // Need to do this to actually trigger a transition.\n    this.queueClassAndNode(activeClassName, node);\n\n    // Clean-up the animation after the specified delay\n    var finish = function finish(e) {\n      if (e && e.target !== node) {\n        return;\n      }\n\n      clearTimeout(timer);\n      if (removeListeners) removeListeners();\n\n      (0, _removeClass2.default)(node, className);\n      (0, _removeClass2.default)(node, activeClassName);\n\n      if (removeListeners) removeListeners();\n\n      // Usually this optional callback is used for informing an owner of\n      // a leave animation and telling it to remove the child.\n      if (finishCallback) {\n        finishCallback();\n      }\n    };\n\n    if (timeout) {\n      timer = setTimeout(finish, timeout);\n      this.transitionTimeouts.push(timer);\n    } else if (_properties.transitionEnd) {\n      removeListeners = addEndListener(node, finish);\n    }\n  };\n\n  CSSTransitionGroupChild.prototype.queueClassAndNode = function queueClassAndNode(className, node) {\n    var _this2 = this;\n\n    this.classNameAndNodeQueue.push({\n      className: className,\n      node: node\n    });\n\n    if (!this.rafHandle) {\n      this.rafHandle = (0, _requestAnimationFrame2.default)(function () {\n        return _this2.flushClassNameAndNodeQueue();\n      });\n    }\n  };\n\n  CSSTransitionGroupChild.prototype.flushClassNameAndNodeQueue = function flushClassNameAndNodeQueue() {\n    if (!this.unmounted) {\n      this.classNameAndNodeQueue.forEach(function (obj) {\n        // This is for to force a repaint,\n        // which is necessary in order to transition styles when adding a class name.\n        /* eslint-disable no-unused-expressions */\n        obj.node.scrollTop;\n        /* eslint-enable no-unused-expressions */\n        (0, _addClass2.default)(obj.node, obj.className);\n      });\n    }\n    this.classNameAndNodeQueue.length = 0;\n    this.rafHandle = null;\n  };\n\n  CSSTransitionGroupChild.prototype.render = function render() {\n    var props = _extends({}, this.props);\n    delete props.name;\n    delete props.appear;\n    delete props.enter;\n    delete props.leave;\n    delete props.appearTimeout;\n    delete props.enterTimeout;\n    delete props.leaveTimeout;\n    delete props.children;\n    return _react2.default.cloneElement(_react2.default.Children.only(this.props.children), props);\n  };\n\n  return CSSTransitionGroupChild;\n}(_react2.default.Component);\n\nCSSTransitionGroupChild.displayName = 'CSSTransitionGroupChild';\n\n\nCSSTransitionGroupChild.propTypes = process.env.NODE_ENV !== \"production\" ? propTypes : {};\n\nexports.default = CSSTransitionGroupChild;\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _chainFunction = require('chain-function');\n\nvar _chainFunction2 = _interopRequireDefault(_chainFunction);\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = require('prop-types');\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar _warning = require('warning');\n\nvar _warning2 = _interopRequireDefault(_warning);\n\nvar _ChildMapping = require('./utils/ChildMapping');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar propTypes = {\n  component: _propTypes2.default.any,\n  childFactory: _propTypes2.default.func,\n  children: _propTypes2.default.node\n};\n\nvar defaultProps = {\n  component: 'span',\n  childFactory: function childFactory(child) {\n    return child;\n  }\n};\n\nvar TransitionGroup = function (_React$Component) {\n  _inherits(TransitionGroup, _React$Component);\n\n  function TransitionGroup(props, context) {\n    _classCallCheck(this, TransitionGroup);\n\n    var _this = _possibleConstructorReturn(this, _React$Component.call(this, props, context));\n\n    _this.performAppear = function (key, component) {\n      _this.currentlyTransitioningKeys[key] = true;\n\n      if (component.componentWillAppear) {\n        component.componentWillAppear(_this._handleDoneAppearing.bind(_this, key, component));\n      } else {\n        _this._handleDoneAppearing(key, component);\n      }\n    };\n\n    _this._handleDoneAppearing = function (key, component) {\n      if (component.componentDidAppear) {\n        component.componentDidAppear();\n      }\n\n      delete _this.currentlyTransitioningKeys[key];\n\n      var currentChildMapping = (0, _ChildMapping.getChildMapping)(_this.props.children);\n\n      if (!currentChildMapping || !currentChildMapping.hasOwnProperty(key)) {\n        // This was removed before it had fully appeared. Remove it.\n        _this.performLeave(key, component);\n      }\n    };\n\n    _this.performEnter = function (key, component) {\n      _this.currentlyTransitioningKeys[key] = true;\n\n      if (component.componentWillEnter) {\n        component.componentWillEnter(_this._handleDoneEntering.bind(_this, key, component));\n      } else {\n        _this._handleDoneEntering(key, component);\n      }\n    };\n\n    _this._handleDoneEntering = function (key, component) {\n      if (component.componentDidEnter) {\n        component.componentDidEnter();\n      }\n\n      delete _this.currentlyTransitioningKeys[key];\n\n      var currentChildMapping = (0, _ChildMapping.getChildMapping)(_this.props.children);\n\n      if (!currentChildMapping || !currentChildMapping.hasOwnProperty(key)) {\n        // This was removed before it had fully entered. Remove it.\n        _this.performLeave(key, component);\n      }\n    };\n\n    _this.performLeave = function (key, component) {\n      _this.currentlyTransitioningKeys[key] = true;\n\n      if (component.componentWillLeave) {\n        component.componentWillLeave(_this._handleDoneLeaving.bind(_this, key, component));\n      } else {\n        // Note that this is somewhat dangerous b/c it calls setState()\n        // again, effectively mutating the component before all the work\n        // is done.\n        _this._handleDoneLeaving(key, component);\n      }\n    };\n\n    _this._handleDoneLeaving = function (key, component) {\n      if (component.componentDidLeave) {\n        component.componentDidLeave();\n      }\n\n      delete _this.currentlyTransitioningKeys[key];\n\n      var currentChildMapping = (0, _ChildMapping.getChildMapping)(_this.props.children);\n\n      if (currentChildMapping && currentChildMapping.hasOwnProperty(key)) {\n        // This entered again before it fully left. Add it again.\n        _this.keysToEnter.push(key);\n      } else {\n        _this.setState(function (state) {\n          var newChildren = _extends({}, state.children);\n          delete newChildren[key];\n          return { children: newChildren };\n        });\n      }\n    };\n\n    _this.childRefs = Object.create(null);\n\n    _this.state = {\n      children: (0, _ChildMapping.getChildMapping)(props.children)\n    };\n    return _this;\n  }\n\n  TransitionGroup.prototype.componentWillMount = function componentWillMount() {\n    this.currentlyTransitioningKeys = {};\n    this.keysToEnter = [];\n    this.keysToLeave = [];\n  };\n\n  TransitionGroup.prototype.componentDidMount = function componentDidMount() {\n    var initialChildMapping = this.state.children;\n    for (var key in initialChildMapping) {\n      if (initialChildMapping[key]) {\n        this.performAppear(key, this.childRefs[key]);\n      }\n    }\n  };\n\n  TransitionGroup.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {\n    var nextChildMapping = (0, _ChildMapping.getChildMapping)(nextProps.children);\n    var prevChildMapping = this.state.children;\n\n    this.setState({\n      children: (0, _ChildMapping.mergeChildMappings)(prevChildMapping, nextChildMapping)\n    });\n\n    for (var key in nextChildMapping) {\n      var hasPrev = prevChildMapping && prevChildMapping.hasOwnProperty(key);\n      if (nextChildMapping[key] && !hasPrev && !this.currentlyTransitioningKeys[key]) {\n        this.keysToEnter.push(key);\n      }\n    }\n\n    for (var _key in prevChildMapping) {\n      var hasNext = nextChildMapping && nextChildMapping.hasOwnProperty(_key);\n      if (prevChildMapping[_key] && !hasNext && !this.currentlyTransitioningKeys[_key]) {\n        this.keysToLeave.push(_key);\n      }\n    }\n\n    // If we want to someday check for reordering, we could do it here.\n  };\n\n  TransitionGroup.prototype.componentDidUpdate = function componentDidUpdate() {\n    var _this2 = this;\n\n    var keysToEnter = this.keysToEnter;\n    this.keysToEnter = [];\n    keysToEnter.forEach(function (key) {\n      return _this2.performEnter(key, _this2.childRefs[key]);\n    });\n\n    var keysToLeave = this.keysToLeave;\n    this.keysToLeave = [];\n    keysToLeave.forEach(function (key) {\n      return _this2.performLeave(key, _this2.childRefs[key]);\n    });\n  };\n\n  TransitionGroup.prototype.render = function render() {\n    var _this3 = this;\n\n    // TODO: we could get rid of the need for the wrapper node\n    // by cloning a single child\n    var childrenToRender = [];\n\n    var _loop = function _loop(key) {\n      var child = _this3.state.children[key];\n      if (child) {\n        var isCallbackRef = typeof child.ref !== 'string';\n        var factoryChild = _this3.props.childFactory(child);\n        var ref = function ref(r) {\n          _this3.childRefs[key] = r;\n        };\n\n        process.env.NODE_ENV !== 'production' ? (0, _warning2.default)(isCallbackRef, 'string refs are not supported on children of TransitionGroup and will be ignored. ' + 'Please use a callback ref instead: https://facebook.github.io/react/docs/refs-and-the-dom.html#the-ref-callback-attribute') : void 0;\n\n        // Always chaining the refs leads to problems when the childFactory\n        // wraps the child. The child ref callback gets called twice with the\n        // wrapper and the child. So we only need to chain the ref if the\n        // factoryChild is not different from child.\n        if (factoryChild === child && isCallbackRef) {\n          ref = (0, _chainFunction2.default)(child.ref, ref);\n        }\n\n        // You may need to apply reactive updates to a child as it is leaving.\n        // The normal React way to do it won't work since the child will have\n        // already been removed. In case you need this behavior you can provide\n        // a childFactory function to wrap every child, even the ones that are\n        // leaving.\n        childrenToRender.push(_react2.default.cloneElement(factoryChild, {\n          key: key,\n          ref: ref\n        }));\n      }\n    };\n\n    for (var key in this.state.children) {\n      _loop(key);\n    }\n\n    // Do not forward TransitionGroup props to primitive DOM nodes\n    var props = _extends({}, this.props);\n    delete props.transitionLeave;\n    delete props.transitionName;\n    delete props.transitionAppear;\n    delete props.transitionEnter;\n    delete props.childFactory;\n    delete props.transitionLeaveTimeout;\n    delete props.transitionEnterTimeout;\n    delete props.transitionAppearTimeout;\n    delete props.component;\n\n    return _react2.default.createElement(this.props.component, props, childrenToRender);\n  };\n\n  return TransitionGroup;\n}(_react2.default.Component);\n\nTransitionGroup.displayName = 'TransitionGroup';\n\n\nTransitionGroup.propTypes = process.env.NODE_ENV !== \"production\" ? propTypes : {};\nTransitionGroup.defaultProps = defaultProps;\n\nexports.default = TransitionGroup;\nmodule.exports = exports['default'];","'use strict';\n\nvar _CSSTransitionGroup = require('./CSSTransitionGroup');\n\nvar _CSSTransitionGroup2 = _interopRequireDefault(_CSSTransitionGroup);\n\nvar _TransitionGroup = require('./TransitionGroup');\n\nvar _TransitionGroup2 = _interopRequireDefault(_TransitionGroup);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nmodule.exports = {\n  TransitionGroup: _TransitionGroup2.default,\n  CSSTransitionGroup: _CSSTransitionGroup2.default\n};","/**\n * Copyright 2014-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n */\n\n'use strict';\n\n/**\n * Similar to invariant but only logs a warning if the condition is not met.\n * This can be used to log issues in development environments in critical\n * paths. Removing the logging code for production environments will keep the\n * same logic and follow the same code paths.\n */\n\nvar warning = function() {};\n\nif (process.env.NODE_ENV !== 'production') {\n  warning = function(condition, format, args) {\n    var len = arguments.length;\n    args = new Array(len > 2 ? len - 2 : 0);\n    for (var key = 2; key < len; key++) {\n      args[key - 2] = arguments[key];\n    }\n    if (format === undefined) {\n      throw new Error(\n        '`warning(condition, format, ...args)` requires a warning ' +\n        'message argument'\n      );\n    }\n\n    if (format.length < 10 || (/^[s\\W]*$/).test(format)) {\n      throw new Error(\n        'The warning format should be able to uniquely identify this ' +\n        'warning. Please, use a more descriptive format than: ' + format\n      );\n    }\n\n    if (!condition) {\n      var argIndex = 0;\n      var message = 'Warning: ' +\n        format.replace(/%s/g, function() {\n          return args[argIndex++];\n        });\n      if (typeof console !== 'undefined') {\n        console.error(message);\n      }\n      try {\n        // This error was thrown as a convenience so that you can use this stack\n        // to find the callsite that caused this warning to fire.\n        throw new Error(message);\n      } catch(x) {}\n    }\n  };\n}\n\nmodule.exports = warning;\n","'use strict';\n\nexports.__esModule = true;\nexports.getChildMapping = getChildMapping;\nexports.mergeChildMappings = mergeChildMappings;\n\nvar _react = require('react');\n\n/**\n * Given `this.props.children`, return an object mapping key to child.\n *\n * @param {*} children `this.props.children`\n * @return {object} Mapping of key to child\n */\nfunction getChildMapping(children) {\n  if (!children) {\n    return children;\n  }\n  var result = {};\n  _react.Children.map(children, function (child) {\n    return child;\n  }).forEach(function (child) {\n    result[child.key] = child;\n  });\n  return result;\n}\n\n/**\n * When you're adding or removing children some may be added or removed in the\n * same render pass. We want to show *both* since we want to simultaneously\n * animate elements in and out. This function takes a previous set of keys\n * and a new set of keys and merges them with its best guess of the correct\n * ordering. In the future we may expose some of the utilities in\n * ReactMultiChild to make this easy, but for now React itself does not\n * directly have this concept of the union of prevChildren and nextChildren\n * so we implement it here.\n *\n * @param {object} prev prev children as returned from\n * `ReactTransitionChildMapping.getChildMapping()`.\n * @param {object} next next children as returned from\n * `ReactTransitionChildMapping.getChildMapping()`.\n * @return {object} a key set that contains all keys in `prev` and all keys\n * in `next` in a reasonable order.\n */\nfunction mergeChildMappings(prev, next) {\n  prev = prev || {};\n  next = next || {};\n\n  function getValueForKey(key) {\n    if (next.hasOwnProperty(key)) {\n      return next[key];\n    }\n\n    return prev[key];\n  }\n\n  // For each key of `next`, the list of keys to insert before that key in\n  // the combined list\n  var nextKeysPending = {};\n\n  var pendingKeys = [];\n  for (var prevKey in prev) {\n    if (next.hasOwnProperty(prevKey)) {\n      if (pendingKeys.length) {\n        nextKeysPending[prevKey] = pendingKeys;\n        pendingKeys = [];\n      }\n    } else {\n      pendingKeys.push(prevKey);\n    }\n  }\n\n  var i = void 0;\n  var childMapping = {};\n  for (var nextKey in next) {\n    if (nextKeysPending.hasOwnProperty(nextKey)) {\n      for (i = 0; i < nextKeysPending[nextKey].length; i++) {\n        var pendingNextKey = nextKeysPending[nextKey][i];\n        childMapping[nextKeysPending[nextKey][i]] = getValueForKey(pendingNextKey);\n      }\n    }\n    childMapping[nextKey] = getValueForKey(nextKey);\n  }\n\n  // Finally, add the keys which didn't appear before any key in `next`\n  for (i = 0; i < pendingKeys.length; i++) {\n    childMapping[pendingKeys[i]] = getValueForKey(pendingKeys[i]);\n  }\n\n  return childMapping;\n}","'use strict';\n\nexports.__esModule = true;\nexports.nameShape = undefined;\nexports.transitionTimeout = transitionTimeout;\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = require('prop-types');\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction transitionTimeout(transitionType) {\n  var timeoutPropName = 'transition' + transitionType + 'Timeout';\n  var enabledPropName = 'transition' + transitionType;\n\n  return function (props) {\n    // If the transition is enabled\n    if (props[enabledPropName]) {\n      // If no timeout duration is provided\n      if (props[timeoutPropName] == null) {\n        return new Error(timeoutPropName + ' wasn\\'t supplied to CSSTransitionGroup: ' + 'this can cause unreliable animations and won\\'t be supported in ' + 'a future version of React. See ' + 'https://fb.me/react-animation-transition-group-timeout for more ' + 'information.');\n\n        // If the duration isn't a number\n      } else if (typeof props[timeoutPropName] !== 'number') {\n        return new Error(timeoutPropName + ' must be a number (in milliseconds)');\n      }\n    }\n\n    return null;\n  };\n}\n\nvar nameShape = exports.nameShape = _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.shape({\n  enter: _propTypes2.default.string,\n  leave: _propTypes2.default.string,\n  active: _propTypes2.default.string\n}), _propTypes2.default.shape({\n  enter: _propTypes2.default.string,\n  enterActive: _propTypes2.default.string,\n  leave: _propTypes2.default.string,\n  leaveActive: _propTypes2.default.string,\n  appear: _propTypes2.default.string,\n  appearActive: _propTypes2.default.string\n})]);"],"sourceRoot":""}