{"version":3,"sources":["../../node_modules/babel-preset-react-app/node_modules/@babel/runtime/regenerator/index.js","../../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/regeneratorRuntime.js","../../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/typeof.js","../../node_modules/@formatjs/intl/lib/src/dateTime.js","../../node_modules/@formatjs/icu-skeleton-parser/lib/index.js","../../node_modules/@formatjs/intl/lib/src/message.js","../../node_modules/@formatjs/icu-messageformat-parser/lib/regex.generated.js","../../node_modules/design-system/lib/styleConstants.js","../../node_modules/@formatjs/intl/lib/src/number.js","../../node_modules/@formatjs/intl/lib/src/list.js","../../node_modules/@formatjs/icu-skeleton-parser/lib/date-time.js","../../node_modules/@formatjs/icu-skeleton-parser/lib/number.js","../../node_modules/@formatjs/icu-messageformat-parser/lib/parser.js","../../node_modules/@formatjs/icu-skeleton-parser/lib/regex.generated.js","../../node_modules/@formatjs/intl/lib/src/relativeTime.js","../../node_modules/@formatjs/intl/lib/src/plural.js","../../node_modules/@formatjs/intl/lib/src/displayName.js","../../node_modules/@formatjs/intl/lib/src/error.js","../../node_modules/copy-to-clipboard/index.js","../../node_modules/@formatjs/icu-messageformat-parser/lib/error.js","../../node_modules/@formatjs/ecma402-abstract/lib/utils.js","../../node_modules/@formatjs/icu-messageformat-parser/lib/types.js","../../node_modules/classnames/index.js","../../node_modules/@formatjs/intl/lib/src/create-intl.js","../../node_modules/@formatjs/fast-memoize/lib/index.js","../../node_modules/@formatjs/intl/lib/src/utils.js","../../node_modules/@formatjs/icu-messageformat-parser/lib/index.js"],"names":["runtime","module","exports","regeneratorRuntime","accidentalStrictMode","globalThis","Function","_typeof","_regeneratorRuntime","e","__esModule","t","r","Object","prototype","n","hasOwnProperty","o","defineProperty","value","i","Symbol","a","iterator","c","asyncIterator","u","toStringTag","define","enumerable","configurable","writable","wrap","Generator","create","Context","makeInvokeMethod","tryCatch","type","arg","call","h","f","s","y","GeneratorFunction","GeneratorFunctionPrototype","p","this","d","getPrototypeOf","v","values","g","defineIteratorMethods","forEach","_invoke","AsyncIterator","invoke","resolve","__await","then","callInvokeWithMethodAndArg","Error","done","method","delegate","maybeInvokeDelegate","sent","_sent","dispatchException","abrupt","TypeError","resultName","next","nextLoc","pushTryEntry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","push","resetTryEntry","completion","reset","isNaN","length","displayName","isGeneratorFunction","constructor","name","mark","setPrototypeOf","__proto__","awrap","async","Promise","keys","reverse","pop","prev","charAt","slice","stop","rval","handle","complete","finish","delegateYield","DATE_TIME_FORMAT_OPTIONS","getFormatter","_a","getDateTimeFormat","options","locale","formats","onError","timeZone","format","defaults","__assign","getNamedFormat","filteredOptions","filterProps","hour","minute","second","timeStyle","dateStyle","formatDate","config","_i","arguments","_b","date","Date","IntlError","IntlErrorCode","FORMAT_ERROR","String","formatTime","formatDateTimeRange","from","to","formatRange","formatDateToParts","formatToParts","formatTimeToParts","setTimeZoneInOptions","opts","reduce","all","k","deepMergeOptions","opts1","opts2","deepMergeFormatsAndSetTimeZone","f1","mfFormats","IntlMessageFormat","time","formatMessage","state","messageDescriptor","messages","defaultLocale","defaultFormats","fallbackOnEmptyString","defaultRichTextElements","id","msgId","defaultMessage","invariant","message","Array","isArray","TYPE","literal","replace","toLowerCase","MissingTranslationError","getMessageFormat","MessageFormatError","concat","formatters","SPACE_SEPARATOR_REGEX","l","m","get","bind","default","x","b","w","red700","red800","red900","dark","white","neutral800","neutral700","neutral500","neutral400","neutral300","neutral200","neutral100","blue800","blue600","blue100","blue50","success900","success800","success600","success50","warning800","warning600","warning500","warning50","error900","error800","error700","error400","error100","error50","background","neutral700a20","neutral700a70","neutral300a80","normal","medium","bold","small","large","transparent","Math","round","toString","substr","toUpperCase","xs","up_xs","up_s","up_m","up_l","blue800SvgFilter","12","16","24","32","40","48","56","64","mobilePortrait","mobileLandscape","tablet","desktop","desktopWide","NUMBER_FORMAT_OPTIONS","getNumberFormat","formatNumber","formatNumberToParts","LIST_FORMAT_OPTIONS","now","formatList","getListFormat","results","formatListToParts","el","val","Intl","ListFormat","FormatError","ErrorCode","MISSING_INTL_API","richValues_1","serializedValues","map","generateToken","part","DATE_TIME_REGEX","parseDateTimeSkeleton","skeleton","result","match","len","era","year","RangeError","month","day","weekday","hour12","hourCycle","timeZoneName","parseNumberSkeletonFromString","tokens","stringTokens_1","split","WHITE_SPACE_REGEX","filter","stemAndOptions","stem","options_1","FRACTION_PRECISION_REGEX","SIGNIFICANT_PRECISION_REGEX","INTEGER_WIDTH_REGEX","CONCISE_INTEGER_WIDTH_REGEX","parseSignificantPrecision","str","roundingPriority","_","g1","g2","minimumSignificantDigits","maximumSignificantDigits","parseSign","signDisplay","currencySign","parseConciseScientificAndEngineeringStem","notation","test","minimumIntegerDigits","parseNotationOptions","opt","signOpts","parseNumberSkeleton","tokens_1","token","style","scale","currency","useGrouping","maximumFractionDigits","unit","compactDisplay","currencyDisplay","unitDisplay","parseFloat","g3","g4","g5","minimumFractionDigits","trailingZeroDisplay","conciseScientificAndEngineeringOpts","SPACE_SEPARATOR_START_REGEX","RegExp","source","SPACE_SEPARATOR_END_REGEX","createLocation","start","end","hasNativeStartsWith","startsWith","hasNativeFromCodePoint","fromCodePoint","hasNativeFromEntries","fromEntries","hasNativeCodePointAt","codePointAt","hasTrimStart","trimStart","hasTrimEnd","trimEnd","isSafeInteger","Number","isFinite","floor","abs","REGEX_SUPPORTS_U_AND_Y","RE","exec","matchIdentifierAtIndex","search","position","codePoints","code","elements","fromCharCode","entries","obj","entries_1","index","size","first","charCodeAt","flag","IDENTIFIER_PREFIX_RE_1","lastIndex","undefined","_isWhiteSpace","_isPatternSyntax","apply","Parser","offset","line","column","ignoreTag","requiresOtherClause","shouldParseSkeletons","parse","parseMessage","nestingLevel","parentArgType","expectingCloseTag","isEOF","char","parseArgument","err","peek","error","ErrorKind","UNMATCHED_CLOSING_TAG","clonePosition","_isAlpha","parseTag","parseLiteral","bump","pound","location","startPosition","tagName","parseTagName","bumpSpace","bumpIf","childrenResult","children","endTagStartPosition","INVALID_TAG","closingTagNameStartPosition","tag","UNCLOSED_TAG","startOffset","parseQuoteResult","tryParseQuote","parseUnquotedResult","tryParseUnquoted","parseLeftAngleResult","tryParseLeftAngleBracket","codepoint","ch","openingBracePosition","EXPECT_ARGUMENT_CLOSING_BRACE","EMPTY_ARGUMENT","parseIdentifierIfPossible","MALFORMED_ARGUMENT","argument","parseArgumentOptions","startingPosition","endOffset","bumpTo","typeStartPosition","argType","typeEndPosition","EXPECT_ARGUMENT_TYPE","styleAndLocation","styleStartPosition","parseSimpleArgStyleIfPossible","EXPECT_ARGUMENT_STYLE","styleLocation","argCloseResult","tryParseArgumentClose","location_1","number","EXPECT_DATE_TIME_SKELETON","SKELETON_TYPE","dateTime","pattern","parsedOptions","typeEndPosition_1","EXPECT_SELECT_ARGUMENT_OPTIONS","identifierAndLocation","pluralOffset","EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE","tryParseDecimalInteger","INVALID_PLURAL_ARGUMENT_OFFSET_VALUE","optionsResult","tryParsePluralOrSelectOptions","location_2","select","plural","pluralType","INVALID_ARGUMENT_TYPE","nestedBraces","apostrophePosition","bumpUntil","UNCLOSED_QUOTE_IN_ARGUMENT_STYLE","INVALID_NUMBER_SKELETON","expectCloseTag","parsedFirstIdentifier","hasOtherClause","parsedSelectors","Set","selector","selectorLocation","EXPECT_PLURAL_ARGUMENT_SELECTOR","INVALID_PLURAL_ARGUMENT_SELECTOR","has","DUPLICATE_SELECT_ARGUMENT_SELECTOR","DUPLICATE_PLURAL_ARGUMENT_SELECTOR","EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT","EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT","fragmentResult","add","EXPECT_SELECT_ARGUMENT_SELECTOR","MISSING_OTHER_CLAUSE","expectNumberError","invalidNumberError","sign","hasDigits","decimal","kind","prefix","currentOffset","indexOf","targetOffset","min","nextCode","RELATIVE_TIME_FORMAT_OPTIONS","formatRelativeTime","getRelativeTimeFormat","RelativeTimeFormat","IntlFormatError","PLURAL_FORMAT_OPTIONS","formatPlural","getPluralRules","PluralRules","DISPLAY_NAMES_OPTONS","formatDisplayName","getDisplayNames","DisplayNames","of","_super","exception","_this","stack","captureStackTrace","__extends","UnsupportedFormatterError","UNSUPPORTED_FORMATTER","InvalidConfigError","INVALID_CONFIG","MissingDataError","MISSING_DATA","descriptor","description","MISSING_TRANSLATION","deselectCurrent","require","clipboardToIE11Formatting","text","debug","reselectPrevious","range","selection","success","document","createRange","getSelection","createElement","textContent","top","clip","whiteSpace","webkitUserSelect","MozUserSelect","msUserSelect","userSelect","addEventListener","stopPropagation","preventDefault","clipboardData","console","warn","window","clearData","setData","onCopy","body","appendChild","selectNodeContents","addRange","execCommand","copyKey","navigator","userAgent","prompt","removeRange","removeAllRanges","removeChild","condition","Err","isLiteralElement","isArgumentElement","isNumberElement","isDateElement","isTimeElement","isSelectElement","isPluralElement","isPoundElement","isTagElement","isNumberSkeleton","isDateTimeSkeleton","hasOwn","classNames","classes","inner","key","join","verifyConfigMessages","createIntl","cache","createFormatters","resolvedConfig","DEFAULT_INTL_CONFIG","NumberFormat","supportedLocalesOf","DateTimeFormat","$t","memoize","fn","cacheDefault","serializer","serializerDefault","strategy","strategyDefault","monadic","cacheKey","computedValue","set","variadic","args","assemble","context","serialize","JSON","stringify","ObjectWithoutPrototypeCache","strategies","props","allowlist","filtered","process","createIntlCache","relativeTime","pluralRules","list","displayNames","createFastMemoizeCache","store","__spreadArray","locales","overrideFormats","formatType","SyntaxError","originalMessage","captureLocation","pruneLocation","els"],"mappings":"8GAEA,IAAIA,EAAU,EAAQ,KAAR,GACdC,EAAOC,QAAUF,EAGjB,IACEG,mBAAqBH,EACrB,MAAOI,GACmB,iBAAfC,WACTA,WAAWF,mBAAqBH,EAEhCM,SAAS,IAAK,yBAAdA,CAAwCN,K,qBCZ5C,IAAIO,EAAU,EAAQ,MAAwB,QAC9C,SAASC,IACP,iKACAP,EAAOC,QAAUM,EAAsB,WACrC,OAAOC,GACNR,EAAOC,QAAQQ,YAAa,EAAMT,EAAOC,QAAiB,QAAID,EAAOC,QACxE,IAAIS,EACFF,EAAI,GACJG,EAAIC,OAAOC,UACXC,EAAIH,EAAEI,eACNC,EAAIJ,OAAOK,gBAAkB,SAAUP,EAAGF,EAAGG,GAC3CD,EAAEF,GAAKG,EAAEO,OAEXC,EAAI,mBAAqBC,OAASA,OAAS,GAC3CC,EAAIF,EAAEG,UAAY,aAClBC,EAAIJ,EAAEK,eAAiB,kBACvBC,EAAIN,EAAEO,aAAe,gBACvB,SAASC,EAAOjB,EAAGF,EAAGG,GACpB,OAAOC,OAAOK,eAAeP,EAAGF,EAAG,CACjCU,MAAOP,EACPiB,YAAY,EACZC,cAAc,EACdC,UAAU,IACRpB,EAAEF,GAER,IACEmB,EAAO,GAAI,IACX,MAAOjB,GACPiB,EAAS,SAAgBjB,EAAGF,EAAGG,GAC7B,OAAOD,EAAEF,GAAKG,GAGlB,SAASoB,EAAKrB,EAAGF,EAAGG,EAAGG,GACrB,IAAIK,EAAIX,GAAKA,EAAEK,qBAAqBmB,EAAYxB,EAAIwB,EAClDX,EAAIT,OAAOqB,OAAOd,EAAEN,WACpBU,EAAI,IAAIW,EAAQpB,GAAK,IACvB,OAAOE,EAAEK,EAAG,UAAW,CACrBH,MAAOiB,EAAiBzB,EAAGC,EAAGY,KAC5BF,EAEN,SAASe,EAAS1B,EAAGF,EAAGG,GACtB,IACE,MAAO,CACL0B,KAAM,SACNC,IAAK5B,EAAE6B,KAAK/B,EAAGG,IAEjB,MAAOD,GACP,MAAO,CACL2B,KAAM,QACNC,IAAK5B,IAIXF,EAAEuB,KAAOA,EACT,IAAIS,EAAI,iBAENC,EAAI,YACJC,EAAI,YACJC,EAAI,GACN,SAASX,KACT,SAASY,KACT,SAASC,KACT,IAAIC,EAAI,GACRnB,EAAOmB,EAAGzB,GAAG,WACX,OAAO0B,QAET,IAAIC,EAAIpC,OAAOqC,eACbC,EAAIF,GAAKA,EAAEA,EAAEG,EAAO,MACtBD,GAAKA,IAAMvC,GAAKG,EAAEyB,KAAKW,EAAG7B,KAAOyB,EAAII,GACrC,IAAIE,EAAIP,EAA2BhC,UAAYmB,EAAUnB,UAAYD,OAAOqB,OAAOa,GACnF,SAASO,EAAsB3C,GAC7B,CAAC,OAAQ,QAAS,UAAU4C,SAAQ,SAAU9C,GAC5CmB,EAAOjB,EAAGF,GAAG,SAAUE,GACrB,OAAOqC,KAAKQ,QAAQ/C,EAAGE,SAI7B,SAAS8C,EAAc9C,EAAGF,GACxB,SAASiD,EAAO9C,EAAGK,EAAGG,EAAGE,GACvB,IAAIE,EAAIa,EAAS1B,EAAEC,GAAID,EAAGM,GAC1B,GAAI,UAAYO,EAAEc,KAAM,CACtB,IAAIZ,EAAIF,EAAEe,IACRE,EAAIf,EAAEP,MACR,OAAOsB,GAAK,UAAYlC,EAAQkC,IAAM1B,EAAEyB,KAAKC,EAAG,WAAahC,EAAEkD,QAAQlB,EAAEmB,SAASC,MAAK,SAAUlD,GAC/F+C,EAAO,OAAQ/C,EAAGS,EAAGE,MACpB,SAAUX,GACX+C,EAAO,QAAS/C,EAAGS,EAAGE,MACnBb,EAAEkD,QAAQlB,GAAGoB,MAAK,SAAUlD,GAC/Be,EAAEP,MAAQR,EAAGS,EAAEM,MACd,SAAUf,GACX,OAAO+C,EAAO,QAAS/C,EAAGS,EAAGE,MAGjCA,EAAEE,EAAEe,KAEN,IAAI3B,EACJK,EAAE+B,KAAM,UAAW,CACjB7B,MAAO,SAAeR,EAAGI,GACvB,SAAS+C,IACP,OAAO,IAAIrD,GAAE,SAAUA,EAAGG,GACxB8C,EAAO/C,EAAGI,EAAGN,EAAGG,MAGpB,OAAOA,EAAIA,EAAIA,EAAEiD,KAAKC,EAA4BA,GAA8BA,OAItF,SAAS1B,EAAiB3B,EAAGG,EAAGG,GAC9B,IAAIE,EAAIwB,EACR,OAAO,SAAUrB,EAAGE,GAClB,GAAIL,IAAMyB,EAAG,MAAMqB,MAAM,gCACzB,GAAI9C,IAAM0B,EAAG,CACX,GAAI,UAAYvB,EAAG,MAAME,EACzB,MAAO,CACLH,MAAOR,EACPqD,MAAM,GAGV,IAAKjD,EAAEkD,OAAS7C,EAAGL,EAAEwB,IAAMjB,IAAK,CAC9B,IAAIE,EAAIT,EAAEmD,SACV,GAAI1C,EAAG,CACL,IAAIE,EAAIyC,EAAoB3C,EAAGT,GAC/B,GAAIW,EAAG,CACL,GAAIA,IAAMkB,EAAG,SACb,OAAOlB,GAGX,GAAI,SAAWX,EAAEkD,OAAQlD,EAAEqD,KAAOrD,EAAEsD,MAAQtD,EAAEwB,SAAS,GAAI,UAAYxB,EAAEkD,OAAQ,CAC/E,GAAIhD,IAAMwB,EAAG,MAAMxB,EAAI0B,EAAG5B,EAAEwB,IAC5BxB,EAAEuD,kBAAkBvD,EAAEwB,SACjB,WAAaxB,EAAEkD,QAAUlD,EAAEwD,OAAO,SAAUxD,EAAEwB,KACrDtB,EAAIyB,EACJ,IAAIK,EAAIV,EAAS5B,EAAGG,EAAGG,GACvB,GAAI,WAAagC,EAAET,KAAM,CACvB,GAAIrB,EAAIF,EAAEiD,KAAOrB,EA/EnB,iBA+E0BI,EAAER,MAAQK,EAAG,SACrC,MAAO,CACLzB,MAAO4B,EAAER,IACTyB,KAAMjD,EAAEiD,MAGZ,UAAYjB,EAAET,OAASrB,EAAI0B,EAAG5B,EAAEkD,OAAS,QAASlD,EAAEwB,IAAMQ,EAAER,OAIlE,SAAS4B,EAAoB1D,EAAGG,GAC9B,IAAIG,EAAIH,EAAEqD,OACRhD,EAAIR,EAAEc,SAASR,GACjB,GAAIE,IAAMN,EAAG,OAAOC,EAAEsD,SAAW,KAAM,UAAYnD,GAAKN,EAAEc,SAAiB,SAAMX,EAAEqD,OAAS,SAAUrD,EAAE2B,IAAM5B,EAAGwD,EAAoB1D,EAAGG,GAAI,UAAYA,EAAEqD,SAAW,WAAalD,IAAMH,EAAEqD,OAAS,QAASrD,EAAE2B,IAAM,IAAIiC,UAAU,oCAAsCzD,EAAI,aAAc6B,EAC1R,IAAIxB,EAAIiB,EAASpB,EAAGR,EAAEc,SAAUX,EAAE2B,KAClC,GAAI,UAAYnB,EAAEkB,KAAM,OAAO1B,EAAEqD,OAAS,QAASrD,EAAE2B,IAAMnB,EAAEmB,IAAK3B,EAAEsD,SAAW,KAAMtB,EACrF,IAAItB,EAAIF,EAAEmB,IACV,OAAOjB,EAAIA,EAAE0C,MAAQpD,EAAEH,EAAEgE,YAAcnD,EAAEH,MAAOP,EAAE8D,KAAOjE,EAAEkE,QAAS,WAAa/D,EAAEqD,SAAWrD,EAAEqD,OAAS,OAAQrD,EAAE2B,IAAM5B,GAAIC,EAAEsD,SAAW,KAAMtB,GAAKtB,GAAKV,EAAEqD,OAAS,QAASrD,EAAE2B,IAAM,IAAIiC,UAAU,oCAAqC5D,EAAEsD,SAAW,KAAMtB,GAE9P,SAASgC,EAAajE,GACpB,IAAIF,EAAI,CACNoE,OAAQlE,EAAE,IAEZ,KAAKA,IAAMF,EAAEqE,SAAWnE,EAAE,IAAK,KAAKA,IAAMF,EAAEsE,WAAapE,EAAE,GAAIF,EAAEuE,SAAWrE,EAAE,IAAKqC,KAAKiC,WAAWC,KAAKzE,GAE1G,SAAS0E,EAAcxE,GACrB,IAAIF,EAAIE,EAAEyE,YAAc,GACxB3E,EAAE6B,KAAO,gBAAiB7B,EAAE8B,IAAK5B,EAAEyE,WAAa3E,EAElD,SAAS0B,EAAQxB,GACfqC,KAAKiC,WAAa,CAAC,CACjBJ,OAAQ,SACNlE,EAAE4C,QAAQqB,EAAc5B,MAAOA,KAAKqC,OAAM,GAEhD,SAASjC,EAAO3C,GACd,GAAIA,GAAK,KAAOA,EAAG,CACjB,IAAIG,EAAIH,EAAEa,GACV,GAAIV,EAAG,OAAOA,EAAE4B,KAAK/B,GACrB,GAAI,mBAAqBA,EAAEiE,KAAM,OAAOjE,EACxC,IAAK6E,MAAM7E,EAAE8E,QAAS,CACpB,IAAItE,GAAK,EACPG,EAAI,SAASsD,IACX,OAASzD,EAAIR,EAAE8E,QAAS,GAAIxE,EAAEyB,KAAK/B,EAAGQ,GAAI,OAAOyD,EAAKvD,MAAQV,EAAEQ,GAAIyD,EAAKV,MAAO,EAAIU,EACpF,OAAOA,EAAKvD,MAAQR,EAAG+D,EAAKV,MAAO,EAAIU,GAE3C,OAAOtD,EAAEsD,KAAOtD,GAGpB,MAAM,IAAIoD,UAAUjE,EAAQE,GAAK,oBAEnC,OAAOoC,EAAkB/B,UAAYgC,EAA4B7B,EAAEoC,EAAG,cAAe,CACnFlC,MAAO2B,EACPhB,cAAc,IACZb,EAAE6B,EAA4B,cAAe,CAC/C3B,MAAO0B,EACPf,cAAc,IACZe,EAAkB2C,YAAc5D,EAAOkB,EAA4BpB,EAAG,qBAAsBjB,EAAEgF,oBAAsB,SAAU9E,GAChI,IAAIF,EAAI,mBAAqBE,GAAKA,EAAE+E,YACpC,QAASjF,IAAMA,IAAMoC,GAAqB,uBAAyBpC,EAAE+E,aAAe/E,EAAEkF,QACrFlF,EAAEmF,KAAO,SAAUjF,GACpB,OAAOE,OAAOgF,eAAiBhF,OAAOgF,eAAelF,EAAGmC,IAA+BnC,EAAEmF,UAAYhD,EAA4BlB,EAAOjB,EAAGe,EAAG,sBAAuBf,EAAEG,UAAYD,OAAOqB,OAAOmB,GAAI1C,GACpMF,EAAEsF,MAAQ,SAAUpF,GACrB,MAAO,CACLiD,QAASjD,IAEV2C,EAAsBG,EAAc3C,WAAYc,EAAO6B,EAAc3C,UAAWU,GAAG,WACpF,OAAOwB,QACLvC,EAAEgD,cAAgBA,EAAehD,EAAEuF,MAAQ,SAAUrF,EAAGC,EAAGG,EAAGE,EAAGG,QACnE,IAAWA,IAAMA,EAAI6E,SACrB,IAAI3E,EAAI,IAAImC,EAAczB,EAAKrB,EAAGC,EAAGG,EAAGE,GAAIG,GAC5C,OAAOX,EAAEgF,oBAAoB7E,GAAKU,EAAIA,EAAEoD,OAAOb,MAAK,SAAUlD,GAC5D,OAAOA,EAAEqD,KAAOrD,EAAEQ,MAAQG,EAAEoD,WAE7BpB,EAAsBD,GAAIzB,EAAOyB,EAAG3B,EAAG,aAAcE,EAAOyB,EAAG/B,GAAG,WACnE,OAAO0B,QACLpB,EAAOyB,EAAG,YAAY,WACxB,MAAO,wBACL5C,EAAEyF,KAAO,SAAUvF,GACrB,IAAIF,EAAII,OAAOF,GACbC,EAAI,GACN,IAAK,IAAIG,KAAKN,EAAGG,EAAEsE,KAAKnE,GACxB,OAAOH,EAAEuF,UAAW,SAASzB,IAC3B,KAAO9D,EAAE2E,QAAS,CAChB,IAAI5E,EAAIC,EAAEwF,MACV,GAAIzF,KAAKF,EAAG,OAAOiE,EAAKvD,MAAQR,EAAG+D,EAAKV,MAAO,EAAIU,EAErD,OAAOA,EAAKV,MAAO,EAAIU,IAExBjE,EAAE2C,OAASA,EAAQjB,EAAQrB,UAAY,CACxC4E,YAAavD,EACbkD,MAAO,SAAe5E,GACpB,GAAIuC,KAAKqD,KAAO,EAAGrD,KAAK0B,KAAO,EAAG1B,KAAKoB,KAAOpB,KAAKqB,MAAQ1D,EAAGqC,KAAKgB,MAAO,EAAIhB,KAAKkB,SAAW,KAAMlB,KAAKiB,OAAS,OAAQjB,KAAKT,IAAM5B,EAAGqC,KAAKiC,WAAW1B,QAAQ4B,IAAiB1E,EAAG,IAAK,IAAIG,KAAKoC,KAAM,MAAQpC,EAAE0F,OAAO,IAAMvF,EAAEyB,KAAKQ,KAAMpC,KAAO0E,OAAO1E,EAAE2F,MAAM,MAAQvD,KAAKpC,GAAKD,IAEtR6F,KAAM,WACJxD,KAAKgB,MAAO,EACZ,IAAIrD,EAAIqC,KAAKiC,WAAW,GAAGG,WAC3B,GAAI,UAAYzE,EAAE2B,KAAM,MAAM3B,EAAE4B,IAChC,OAAOS,KAAKyD,MAEdnC,kBAAmB,SAA2B7D,GAC5C,GAAIuC,KAAKgB,KAAM,MAAMvD,EACrB,IAAIG,EAAIoC,KACR,SAAS0D,EAAO3F,EAAGE,GACjB,OAAOK,EAAEgB,KAAO,QAAShB,EAAEiB,IAAM9B,EAAGG,EAAE8D,KAAO3D,EAAGE,IAAML,EAAEqD,OAAS,OAAQrD,EAAE2B,IAAM5B,KAAMM,EAEzF,IAAK,IAAIA,EAAI+B,KAAKiC,WAAWM,OAAS,EAAGtE,GAAK,IAAKA,EAAG,CACpD,IAAIG,EAAI4B,KAAKiC,WAAWhE,GACtBK,EAAIF,EAAEgE,WACR,GAAI,SAAWhE,EAAEyD,OAAQ,OAAO6B,EAAO,OACvC,GAAItF,EAAEyD,QAAU7B,KAAKqD,KAAM,CACzB,IAAI7E,EAAIT,EAAEyB,KAAKpB,EAAG,YAChBM,EAAIX,EAAEyB,KAAKpB,EAAG,cAChB,GAAII,GAAKE,EAAG,CACV,GAAIsB,KAAKqD,KAAOjF,EAAE0D,SAAU,OAAO4B,EAAOtF,EAAE0D,UAAU,GACtD,GAAI9B,KAAKqD,KAAOjF,EAAE2D,WAAY,OAAO2B,EAAOtF,EAAE2D,iBACzC,GAAIvD,GACT,GAAIwB,KAAKqD,KAAOjF,EAAE0D,SAAU,OAAO4B,EAAOtF,EAAE0D,UAAU,OACjD,CACL,IAAKpD,EAAG,MAAMqC,MAAM,0CACpB,GAAIf,KAAKqD,KAAOjF,EAAE2D,WAAY,OAAO2B,EAAOtF,EAAE2D,gBAKtDR,OAAQ,SAAgB5D,EAAGF,GACzB,IAAK,IAAIG,EAAIoC,KAAKiC,WAAWM,OAAS,EAAG3E,GAAK,IAAKA,EAAG,CACpD,IAAIK,EAAI+B,KAAKiC,WAAWrE,GACxB,GAAIK,EAAE4D,QAAU7B,KAAKqD,MAAQtF,EAAEyB,KAAKvB,EAAG,eAAiB+B,KAAKqD,KAAOpF,EAAE8D,WAAY,CAChF,IAAI3D,EAAIH,EACR,OAGJG,IAAM,UAAYT,GAAK,aAAeA,IAAMS,EAAEyD,QAAUpE,GAAKA,GAAKW,EAAE2D,aAAe3D,EAAI,MACvF,IAAIE,EAAIF,EAAIA,EAAEgE,WAAa,GAC3B,OAAO9D,EAAEgB,KAAO3B,EAAGW,EAAEiB,IAAM9B,EAAGW,GAAK4B,KAAKiB,OAAS,OAAQjB,KAAK0B,KAAOtD,EAAE2D,WAAYnC,GAAKI,KAAK2D,SAASrF,IAExGqF,SAAU,SAAkBhG,EAAGF,GAC7B,GAAI,UAAYE,EAAE2B,KAAM,MAAM3B,EAAE4B,IAChC,MAAO,UAAY5B,EAAE2B,MAAQ,aAAe3B,EAAE2B,KAAOU,KAAK0B,KAAO/D,EAAE4B,IAAM,WAAa5B,EAAE2B,MAAQU,KAAKyD,KAAOzD,KAAKT,IAAM5B,EAAE4B,IAAKS,KAAKiB,OAAS,SAAUjB,KAAK0B,KAAO,OAAS,WAAa/D,EAAE2B,MAAQ7B,IAAMuC,KAAK0B,KAAOjE,GAAImC,GAE1NgE,OAAQ,SAAgBjG,GACtB,IAAK,IAAIF,EAAIuC,KAAKiC,WAAWM,OAAS,EAAG9E,GAAK,IAAKA,EAAG,CACpD,IAAIG,EAAIoC,KAAKiC,WAAWxE,GACxB,GAAIG,EAAEmE,aAAepE,EAAG,OAAOqC,KAAK2D,SAAS/F,EAAEwE,WAAYxE,EAAEoE,UAAWG,EAAcvE,GAAIgC,IAG9F,MAAS,SAAgBjC,GACvB,IAAK,IAAIF,EAAIuC,KAAKiC,WAAWM,OAAS,EAAG9E,GAAK,IAAKA,EAAG,CACpD,IAAIG,EAAIoC,KAAKiC,WAAWxE,GACxB,GAAIG,EAAEiE,SAAWlE,EAAG,CAClB,IAAII,EAAIH,EAAEwE,WACV,GAAI,UAAYrE,EAAEuB,KAAM,CACtB,IAAIrB,EAAIF,EAAEwB,IACV4C,EAAcvE,GAEhB,OAAOK,GAGX,MAAM8C,MAAM,0BAEd8C,cAAe,SAAuBpG,EAAGG,EAAGG,GAC1C,OAAOiC,KAAKkB,SAAW,CACrB3C,SAAU6B,EAAO3C,GACjBgE,WAAY7D,EACZ+D,QAAS5D,GACR,SAAWiC,KAAKiB,SAAWjB,KAAKT,IAAM5B,GAAIiC,IAE9CnC,EAELR,EAAOC,QAAUM,EAAqBP,EAAOC,QAAQQ,YAAa,EAAMT,EAAOC,QAAiB,QAAID,EAAOC,S,mBC/S3G,SAASK,EAAQU,GAGf,OAAOhB,EAAOC,QAAUK,EAAU,mBAAqBc,QAAU,iBAAmBA,OAAOE,SAAW,SAAUN,GAC9G,cAAcA,GACZ,SAAUA,GACZ,OAAOA,GAAK,mBAAqBI,QAAUJ,EAAEyE,cAAgBrE,QAAUJ,IAAMI,OAAOP,UAAY,gBAAkBG,GACjHhB,EAAOC,QAAQQ,YAAa,EAAMT,EAAOC,QAAiB,QAAID,EAAOC,QAASK,EAAQU,GAE3FhB,EAAOC,QAAUK,EAASN,EAAOC,QAAQQ,YAAa,EAAMT,EAAOC,QAAiB,QAAID,EAAOC,S,iCCT/F,sMAGI4G,EAA2B,CAC3B,gBACA,gBACA,WACA,SACA,UACA,MACA,OACA,QACA,MACA,OACA,SACA,SACA,eACA,YACA,YACA,YACA,WAEA,mBAEG,SAASC,EAAaC,EAAI1E,EAAM2E,EAAmBC,GACtD,IAAIC,EAASH,EAAGG,OAAQC,EAAUJ,EAAGI,QAASC,EAAUL,EAAGK,QAASC,EAAWN,EAAGM,cAClE,IAAZJ,IAAsBA,EAAU,IACpC,IAAIK,EAASL,EAAQK,OACjBC,EAAWC,YAASA,YAAS,GAAKH,GAAY,CAAEA,SAAUA,IAAeC,GAAUG,YAAeN,EAAS9E,EAAMiF,EAAQF,IACzHM,EAAkBC,YAAYV,EAASJ,EAA0BU,GAUrE,MATa,SAATlF,GACCqF,EAAgBE,MAChBF,EAAgBG,QAChBH,EAAgBI,QAChBJ,EAAgBK,WAChBL,EAAgBM,YAEjBN,EAAkBF,YAASA,YAAS,GAAIE,GAAkB,CAAEE,KAAM,UAAWC,OAAQ,aAElFb,EAAkBE,EAAQQ,GAE9B,SAASO,EAAWC,EAAQlB,GAE/B,IADA,IAAID,EAAK,GACAoB,EAAK,EAAGA,EAAKC,UAAU9C,OAAQ6C,IACpCpB,EAAGoB,EAAK,GAAKC,UAAUD,GAE3B,IAAIjH,EAAQ6F,EAAG,GAAIsB,EAAKtB,EAAG,GAAIE,OAAiB,IAAPoB,EAAgB,GAAKA,EAC1DC,EAAwB,iBAAVpH,EAAqB,IAAIqH,KAAKrH,GAAS,GAAKA,EAC9D,IACI,OAAO4F,EAAaoB,EAAQ,OAAQlB,EAAmBC,GAASK,OAAOgB,GAE3E,MAAO9H,GACH0H,EAAOd,QAAQ,IAAIoB,IAAUC,IAAcC,aAAc,yBAA0BlI,IAEvF,OAAOmI,OAAOL,GAEX,SAASM,EAAWV,EAAQlB,GAE/B,IADA,IAAID,EAAK,GACAoB,EAAK,EAAGA,EAAKC,UAAU9C,OAAQ6C,IACpCpB,EAAGoB,EAAK,GAAKC,UAAUD,GAE3B,IAAIjH,EAAQ6F,EAAG,GAAIsB,EAAKtB,EAAG,GAAIE,OAAiB,IAAPoB,EAAgB,GAAKA,EAC1DC,EAAwB,iBAAVpH,EAAqB,IAAIqH,KAAKrH,GAAS,GAAKA,EAC9D,IACI,OAAO4F,EAAaoB,EAAQ,OAAQlB,EAAmBC,GAASK,OAAOgB,GAE3E,MAAO9H,GACH0H,EAAOd,QAAQ,IAAIoB,IAAUC,IAAcC,aAAc,yBAA0BlI,IAEvF,OAAOmI,OAAOL,GAEX,SAASO,EAAoBX,EAAQlB,GAExC,IADA,IAAID,EAAK,GACAoB,EAAK,EAAGA,EAAKC,UAAU9C,OAAQ6C,IACpCpB,EAAGoB,EAAK,GAAKC,UAAUD,GAE3B,IAAIW,EAAO/B,EAAG,GAAIgC,EAAKhC,EAAG,GAAIsB,EAAKtB,EAAG,GAAIE,OAAiB,IAAPoB,EAAgB,GAAKA,EACrEhB,EAAWa,EAAOb,SAAUH,EAASgB,EAAOhB,OAAQE,EAAUc,EAAOd,QACrEM,EAAkBC,YAAYV,EAASJ,EAA0BQ,EAAW,CAAEA,SAAUA,GAAa,IACzG,IACI,OAAOL,EAAkBE,EAAQQ,GAAiBsB,YAAYF,EAAMC,GAExE,MAAOvI,GACH4G,EAAQ,IAAIoB,IAAUC,IAAcC,aAAc,oCAAqClI,IAE3F,OAAOmI,OAAOG,GAEX,SAASG,EAAkBf,EAAQlB,GAEtC,IADA,IAAID,EAAK,GACAoB,EAAK,EAAGA,EAAKC,UAAU9C,OAAQ6C,IACpCpB,EAAGoB,EAAK,GAAKC,UAAUD,GAE3B,IAAIjH,EAAQ6F,EAAG,GAAIsB,EAAKtB,EAAG,GAAIE,OAAiB,IAAPoB,EAAgB,GAAKA,EAC1DC,EAAwB,iBAAVpH,EAAqB,IAAIqH,KAAKrH,GAAS,GAAKA,EAC9D,IACI,OAAO4F,EAAaoB,EAAQ,OAAQlB,EAAmBC,GAASiC,cAAcZ,GAElF,MAAO9H,GACH0H,EAAOd,QAAQ,IAAIoB,IAAUC,IAAcC,aAAc,yBAA0BlI,IAEvF,MAAO,GAEJ,SAAS2I,EAAkBjB,EAAQlB,GAEtC,IADA,IAAID,EAAK,GACAoB,EAAK,EAAGA,EAAKC,UAAU9C,OAAQ6C,IACpCpB,EAAGoB,EAAK,GAAKC,UAAUD,GAE3B,IAAIjH,EAAQ6F,EAAG,GAAIsB,EAAKtB,EAAG,GAAIE,OAAiB,IAAPoB,EAAgB,GAAKA,EAC1DC,EAAwB,iBAAVpH,EAAqB,IAAIqH,KAAKrH,GAAS,GAAKA,EAC9D,IACI,OAAO4F,EAAaoB,EAAQ,OAAQlB,EAAmBC,GAASiC,cAAcZ,GAElF,MAAO9H,GACH0H,EAAOd,QAAQ,IAAIoB,IAAUC,IAAcC,aAAc,yBAA0BlI,IAEvF,MAAO,K,iCCnHX,uI,iCCAA,gFAKA,SAAS4I,EAAqBC,EAAMhC,GAChC,OAAOzG,OAAOqF,KAAKoD,GAAMC,QAAO,SAAUC,EAAKC,GAE3C,OADAD,EAAIC,GAAKhC,YAAS,CAAEH,SAAUA,GAAYgC,EAAKG,IACxCD,IACR,IAEP,SAASE,EAAiBC,EAAOC,GAE7B,OADW/I,OAAOqF,KAAKuB,YAASA,YAAS,GAAIkC,GAAQC,IACzCL,QAAO,SAAUC,EAAKC,GAE9B,OADAD,EAAIC,GAAKhC,YAASA,YAAS,GAAKkC,EAAMF,IAAM,IAAOG,EAAMH,IAAM,IACxDD,IACR,IAEP,SAASK,EAA+BC,EAAIxC,GACxC,IAAKA,EACD,OAAOwC,EAEX,IAAIC,EAAYC,IAAkB5C,QAClC,OAAOK,YAASA,YAASA,YAAS,GAAIsC,GAAYD,GAAK,CAAEvB,KAAMmB,EAAiBL,EAAqBU,EAAUxB,KAAMjB,GAAW+B,EAAqBS,EAAGvB,MAAQ,GAAIjB,IAAY2C,KAAMP,EAAiBL,EAAqBU,EAAUE,KAAM3C,GAAW+B,EAAqBS,EAAGG,MAAQ,GAAI3C,MAExR,SAAS4C,EAAclD,EAAImD,EAAOC,EAAmBhH,EAAQkG,GAChE,IAAInC,EAASH,EAAGG,OAAQC,EAAUJ,EAAGI,QAASiD,EAAWrD,EAAGqD,SAAUC,EAAgBtD,EAAGsD,cAAeC,EAAiBvD,EAAGuD,eAAgBC,EAAwBxD,EAAGwD,sBAAuBnD,EAAUL,EAAGK,QAASC,EAAWN,EAAGM,SAAUmD,EAA0BzD,EAAGyD,6BAC/O,IAAtBL,IAAgCA,EAAoB,CAAEM,GAAI,KAC9D,IAAIC,EAAQP,EAAkBM,GAAIE,EAAiBR,EAAkBQ,eAErEC,cAAYF,EAAO,saACnB,IAAID,EAAK9B,OAAO+B,GACZG,EAIJT,GACIxJ,OAAOC,UAAUE,eAAewB,KAAK6H,EAAUK,IAC/CL,EAASK,GAEb,GAAIK,MAAMC,QAAQF,IACK,IAAnBA,EAAQvF,QACRuF,EAAQ,GAAGxI,OAAS2I,IAAKC,QACzB,OAAOJ,EAAQ,GAAG3J,MAGtB,IAAKiC,GACD0H,GACmB,iBAAZA,IACNL,EACD,OAAOK,EAAQK,QAAQ,gBAAiB,QAK5C,GAHA/H,EAASqE,YAASA,YAAS,GAAIgD,GAA2BrH,GAAU,IACpEgE,EAAUyC,EAA+BzC,EAASE,GAClDiD,EAAiBV,EAA+BU,EAAgBjD,IAC3DwD,EAAS,CACV,IAA8B,IAA1BN,GAA+C,KAAZM,EACnC,OAAOA,EASX,KAPKF,GACAzD,GAAUA,EAAOiE,gBAAkBd,EAAcc,gBAIlD/D,EAAQ,IAAIgE,IAAwBjB,EAAmBjD,IAEvDyD,EACA,IAEI,OADgBT,EAAMmB,iBAAiBV,EAAgBN,EAAeC,EAAgBjB,GACrE/B,OAAOnE,GAE5B,MAAO3C,GAEH,OADA4G,EAAQ,IAAIkE,IAAmB,0CAA2CC,OAAOd,EAAI,yCAA2CvD,EAAQiD,EAAmB3J,IAC1H,iBAAnBmK,EAA8BA,EAAiBF,EAGrE,OAAOA,EAGX,IAEI,OADgBP,EAAMmB,iBAAiBR,EAAS3D,EAAQC,EAASK,YAAS,CAAEgE,WAAYtB,GAAUb,GAAQ,KACzF/B,OAAOnE,GAE5B,MAAO3C,GACH4G,EAAQ,IAAIkE,IAAmB,8BAA+BC,OAAOd,EAAI,aAAcc,OAAOZ,EAAiB,kBAAoB,KAAM,iBAAkBzD,EAAQiD,EAAmB3J,IAE1L,GAAImK,EACA,IAEI,OADgBT,EAAMmB,iBAAiBV,EAAgBN,EAAeC,EAAgBjB,GACrE/B,OAAOnE,GAE5B,MAAO3C,GACH4G,EAAQ,IAAIkE,IAAmB,8CAA+CC,OAAOd,EAAI,iCAAmCvD,EAAQiD,EAAmB3J,IAG/J,MAAuB,iBAAZqK,EACAA,EAEmB,iBAAnBF,EACAA,EAEJF,I,iCCrGX,kCACO,IAAIgB,EAAwB,gD,mBCD8BzL,EAAOC,QAA6L,SAASO,GAAG,IAAIG,EAAE,GAAG,SAASG,EAAEJ,GAAG,GAAGC,EAAED,GAAG,OAAOC,EAAED,GAAGT,QAAQ,IAAIwB,EAAEd,EAAED,GAAG,CAACS,EAAET,EAAEgL,GAAE,EAAGzL,QAAQ,IAAI,OAAOO,EAAEE,GAAG6B,KAAKd,EAAExB,QAAQwB,EAAEA,EAAExB,QAAQa,GAAGW,EAAEiK,GAAE,EAAGjK,EAAExB,QAAQ,OAAOa,EAAE6K,EAAEnL,EAAEM,EAAES,EAAEZ,EAAEG,EAAEkC,EAAE,SAASxC,EAAEG,EAAED,GAAGI,EAAEE,EAAER,EAAEG,IAAIC,OAAOK,eAAeT,EAAEG,EAAE,CAACiB,YAAW,EAAGgK,IAAIlL,KAAKI,EAAEH,EAAE,SAASH,GAAG,oBAAoBY,QAAQA,OAAOM,aAAad,OAAOK,eAAeT,EAAEY,OAAOM,YAAY,CAACR,MAAM,WAAWN,OAAOK,eAAeT,EAAE,aAAa,CAACU,OAAM,KAAMJ,EAAEJ,EAAE,SAASF,EAAEG,GAAG,GAAG,EAAEA,IAAIH,EAAEM,EAAEN,IAAI,EAAEG,EAAE,OAAOH,EAAE,GAAG,EAAEG,GAAG,iBAAiBH,GAAGA,GAAGA,EAAEC,WAAW,OAAOD,EAAE,IAAIE,EAAEE,OAAOqB,OAAO,MAAM,GAAGnB,EAAEH,EAAED,GAAGE,OAAOK,eAAeP,EAAE,UAAU,CAACkB,YAAW,EAAGV,MAAMV,IAAI,EAAEG,GAAG,iBAAiBH,EAAE,IAAI,IAAIiB,KAAKjB,EAAEM,EAAEkC,EAAEtC,EAAEe,EAAE,SAASd,GAAG,OAAOH,EAAEG,IAAIkL,KAAK,KAAKpK,IAAI,OAAOf,GAAGI,EAAEA,EAAE,SAASN,GAAG,IAAIG,EAAEH,GAAGA,EAAEC,WAAW,WAAW,OAAOD,EAAEsL,SAAS,WAAW,OAAOtL,GAAG,OAAOM,EAAEkC,EAAErC,EAAE,IAAIA,GAAGA,GAAGG,EAAEE,EAAE,SAASR,EAAEG,GAAG,OAAOC,OAAOC,UAAUE,eAAewB,KAAK/B,EAAEG,IAAIG,EAAEgC,EAAE,GAAGhC,EAAEA,EAAE4B,EAAE,GAAj5B,CAAq5B,CAAC,CAAC,SAASlC,EAAEG,EAAEG,GAAG,aAAaA,EAAEH,EAAEA,GAAGG,EAAEkC,EAAErC,EAAE,WAAW,WAAW,OAAOD,KAAKI,EAAEkC,EAAErC,EAAE,aAAa,WAAW,OAAOc,KAAKX,EAAEkC,EAAErC,EAAE,wBAAwB,WAAW,OAAOmC,KAAKhC,EAAEkC,EAAErC,EAAE,mBAAmB,WAAW,OAAOK,KAAKF,EAAEkC,EAAErC,EAAE,cAAc,WAAW,OAAOU,KAAKP,EAAEkC,EAAErC,EAAE,cAAc,WAAW,OAAOQ,KAAKL,EAAEkC,EAAErC,EAAE,gBAAgB,WAAW,OAAOoL,KAAKjL,EAAEkC,EAAErC,EAAE,UAAU,WAAW,OAAOY,KAAKT,EAAEkC,EAAErC,EAAE,aAAa,WAAW,OAAO+B,KAAK5B,EAAEkC,EAAErC,EAAE,SAAS,WAAW,OAAOqL,KAAKlL,EAAEkC,EAAErC,EAAE,WAAW,WAAW,OAAOgL,KAAK7K,EAAEkC,EAAErC,EAAE,2BAA2B,WAAW,OAAOyC,KAAKtC,EAAEkC,EAAErC,EAAE,oBAAoB,WAAW,OAAOsL,KAAKnL,EAAEkC,EAAErC,EAAE,mBAAmB,WAAW,OAAO6B,KAAK,MAAM9B,EAAE,CAACwL,OAAO,UAAUC,OAAO,UAAUC,OAAO,UAAUC,KAAK,UAAUC,MAAM,OAAOC,WAAW,UAAUC,WAAW,UAAUC,WAAW,UAAUC,WAAW,UAAUC,WAAW,UAAUC,WAAW,UAAUC,WAAW,UAAUC,QAAQ,UAAUC,QAAQ,UAAUC,QAAQ,UAAUC,OAAO,UAAUC,WAAW,UAAUC,WAAW,UAAUC,WAAW,UAAUC,UAAU,UAAUC,WAAW,UAAUC,WAAW,UAAUC,WAAW,UAAUC,UAAU,UAAUC,SAAS,UAAUC,SAAS,UAAUC,SAAS,UAAUC,SAAS,UAAUC,SAAS,UAAUC,QAAQ,UAAUC,WAAW,UAAUC,cAAc,2BAA2BC,cAAc,2BAA2BC,cAAc,4BAA4B1M,EAAE,EAAEqB,EAAE,KAAK9B,EAAE,GAAGK,EAAE,YAAYF,EAAE,CAACiN,OAAO,IAAIC,OAAO,IAAIC,KAAK,KAAKvC,EAAE,CAAC,UAAU,MAAMwC,MAAM,MAAMF,OAAO,MAAMG,MAAM,OAAO,UAAU,QAAQ,SAAS9C,EAAElL,GAAG,MAAO,aAAYE,EAAEF,GAAK,MAAMe,EAAE,CAACkN,YAAY,wBAAwBnC,MAAMZ,EAAE,SAASW,KAAKX,EAAE,QAAQa,WAAWb,EAAE,cAAcc,WAAWd,EAAE,cAAce,WAAWf,EAAE,cAAcgB,WAAWhB,EAAE,cAAciB,WAAWjB,EAAE,cAAckB,WAAWlB,EAAE,cAAcoB,QAAQpB,EAAE,WAAWqB,QAAQrB,EAAE,WAAWsB,QAAQtB,EAAE,WAAWkC,SAASlC,EAAE,YAAYiC,SAASjC,EAAE,YAAYgC,SAAShC,EAAE,YAAY6B,WAAW7B,EAAE,cAAc4B,WAAW5B,EAAE,cAAcyB,WAAWzB,EAAE,eAAe,SAAS1I,EAAExC,EAAEG,GAAG,MAAO,GAAEH,KAAKkO,KAAKC,MAAMhO,EAAE,IAAI,KAAK,OAAOiO,SAAS,IAAIC,QAAQ,GAAGC,gBAAgB,SAASrM,EAAEjC,EAAEG,EAAEG,EAAEJ,GAAG,OAAOe,QAAG,IAASX,QAAG,IAASJ,EAAG,GAAEF,KAAKwC,EAAEvB,EAAEd,OAAOG,KAAKkC,EAAEvB,EAAEf,KAAM,GAAEF,KAAKwC,EAAEvB,EAAEd,KAAK,MAAM+B,EAAE,CAACqM,GAAGtM,EAAE,kBAAkB,GAAGC,EAAED,EAAE,mBAAmB,EAAE,kBAAkB,GAAGkJ,EAAElJ,EAAE,oBAAoB,EAAE,mBAAmB,GAAGiJ,EAAEjJ,EAAE,qBAAqB,GAAG,mBAAmB,GAAGuM,MAAMvM,EAAE,mBAAmB,GAAGwM,KAAKxM,EAAE,oBAAoB,EAAE,mBAAmB,GAAGyM,KAAKzM,EAAE,qBAAqB,EAAE,oBAAoB,GAAG0M,KAAK1M,EAAE,sBAAsB,GAAG,oBAAoB,IAAIuJ,EAAE,CAACQ,WAAW9J,EAAEgJ,EAAEhL,EAAE8L,YAAYM,QAAQpK,EAAEgJ,EAAEhL,EAAEoM,SAASY,SAAShL,EAAEgJ,EAAEhL,EAAEgN,UAAUJ,WAAW5K,EAAEgJ,EAAEhL,EAAE4M,YAAY8B,iBAAkB,6BAA4BpM,EAAEtC,EAAEoM,QAAQ,gCAAgC9J,EAAEtC,EAAEoM,QAAQ,MAAMG,OAAOvK,EAAEiJ,EAAEjL,EAAEoM,SAASO,UAAU3K,EAAEiJ,EAAEjL,EAAEwM,YAAYa,QAAQrL,EAAEiJ,EAAEjL,EAAEiN,UAAUF,UAAU/K,EAAEiJ,EAAEjL,EAAE4M,aAAa3B,EAAE,CAAC,KAAK,MAAM,KAAK,MAAM0D,GAAG,OAAOC,GAAG,OAAOC,GAAG,OAAOC,GAAG,OAAOC,GAAG,OAAOC,GAAG,OAAOC,GAAG,OAAOC,GAAG,QAAQxM,EAAE,CAACyM,eAAe,qBAAqBC,gBAAgB,4CAA4CC,OAAO,6CAA6CC,QAAQ,8CAA8CC,YAAY,uBAAuBhE,EAAE,KAAKzJ,EAAE,IAAIyJ,EAAE,Q,iCCAz2I,wFAEIiE,EAAwB,CACxB,gBACA,QACA,WACA,kBACA,OACA,cACA,cACA,uBACA,wBACA,wBACA,2BACA,2BAEA,iBACA,kBACA,eACA,WACA,cACA,OACA,cACA,mBAEG,SAASpJ,EAAaC,EAAIoJ,EAAiBlJ,GAC9C,IAAIC,EAASH,EAAGG,OAAQC,EAAUJ,EAAGI,QAASC,EAAUL,EAAGK,aAC3C,IAAZH,IAAsBA,EAAU,IACpC,IAAIK,EAASL,EAAQK,OACjBC,EAAaD,GACbG,YAAeN,EAAS,SAAUG,EAAQF,IAC1C,GAEJ,OAAO+I,EAAgBjJ,EADDS,YAAYV,EAASiJ,EAAuB3I,IAG/D,SAAS6I,EAAalI,EAAQiI,EAAiBjP,EAAO+F,QACzC,IAAZA,IAAsBA,EAAU,IACpC,IACI,OAAOH,EAAaoB,EAAQiI,EAAiBlJ,GAASK,OAAOpG,GAEjE,MAAOV,GACH0H,EAAOd,QAAQ,IAAIoB,IAAUC,IAAcC,aAAc,2BAA4BlI,IAEzF,OAAOmI,OAAOzH,GAEX,SAASmP,EAAoBnI,EAAQiI,EAAiBjP,EAAO+F,QAChD,IAAZA,IAAsBA,EAAU,IACpC,IACI,OAAOH,EAAaoB,EAAQiI,EAAiBlJ,GAASiC,cAAchI,GAExE,MAAOV,GACH0H,EAAOd,QAAQ,IAAIoB,IAAUC,IAAcC,aAAc,2BAA4BlI,IAEzF,MAAO,K,iCCrDX,wGAII8P,EAAsB,CACtB,gBACA,OACA,SAEAC,EAAMhI,KAAKgI,MAIR,SAASC,EAAWnH,EAAMoH,EAAetN,EAAQ8D,QACpC,IAAZA,IAAsBA,EAAU,IACpC,IAAIyJ,EAAUC,EAAkBtH,EAAMoH,EAAetN,EAAQ8D,GAASqC,QAAO,SAAUC,EAAKqH,GACxF,IAAIC,EAAMD,EAAG1P,MAUb,MATmB,iBAAR2P,EACPtH,EAAItE,KAAK4L,GAE2B,iBAAxBtH,EAAIA,EAAIjE,OAAS,GAC7BiE,EAAIA,EAAIjE,OAAS,IAAMuL,EAGvBtH,EAAItE,KAAK4L,GAENtH,IACR,IACH,OAA0B,IAAnBmH,EAAQpL,OAAeoL,EAAQ,GAAKA,EAExC,SAASC,EAAkB5J,EAAI0J,EAAetN,EAAQ8D,GACzD,IAAIC,EAASH,EAAGG,OAAQE,EAAUL,EAAGK,aACrB,IAAZH,IAAsBA,EAAU,IACnB6J,KAAKC,YAElB3J,EAAQ,IAAI4J,IAAY,gHAAmHC,IAAUC,mBAEzJ,IAAIxJ,EAAkBC,YAAYV,EAASqJ,GAC3C,IACI,IAAIa,EAAe,GACfC,EAAmBjO,EAAOkO,KAAI,SAAUnO,EAAG/B,GAC3C,GAAiB,iBAAN+B,EAAgB,CACvB,IAAIuH,EAhCpB,SAAuBtJ,GACnB,MAAO,GAAGoK,OAAOgF,EAAK,KAAKhF,OAAOpK,EAAG,KAAKoK,OAAOgF,GA+B5Be,CAAcnQ,GAEvB,OADAgQ,EAAa1G,GAAMvH,EACZuH,EAEX,OAAO9B,OAAOzF,MAElB,OAAOuN,EAAcvJ,EAAQQ,GACxBwB,cAAckI,GACdC,KAAI,SAAUE,GACf,MAAqB,YAAdA,EAAKlP,KACNkP,EACA/J,YAASA,YAAS,GAAI+J,GAAO,CAAErQ,MAAOiQ,EAAaI,EAAKrQ,QAAUqQ,EAAKrQ,WAGrF,MAAOV,GACH4G,EAAQ,IAAIoB,IAAUC,IAAcC,aAAc,yBAA0BlI,IAGhF,OAAO2C,I,iCC5DX,kCAKA,IAAIqO,EAAkB,4KAOf,SAASC,EAAsBC,GAClC,IAAIC,EAAS,GA0Gb,OAzGAD,EAASxG,QAAQsG,GAAiB,SAAUI,GACxC,IAAIC,EAAMD,EAAMtM,OAChB,OAAQsM,EAAM,IAEV,IAAK,IACDD,EAAOG,IAAc,IAARD,EAAY,OAAiB,IAARA,EAAY,SAAW,QACzD,MAEJ,IAAK,IACDF,EAAOI,KAAe,IAARF,EAAY,UAAY,UACtC,MACJ,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACD,MAAM,IAAIG,WAAW,gEAEzB,IAAK,IACL,IAAK,IACD,MAAM,IAAIA,WAAW,8CAEzB,IAAK,IACL,IAAK,IACDL,EAAOM,MAAQ,CAAC,UAAW,UAAW,QAAS,OAAQ,UAAUJ,EAAM,GACvE,MAEJ,IAAK,IACL,IAAK,IACD,MAAM,IAAIG,WAAW,2CACzB,IAAK,IACDL,EAAOO,IAAM,CAAC,UAAW,WAAWL,EAAM,GAC1C,MACJ,IAAK,IACL,IAAK,IACL,IAAK,IACD,MAAM,IAAIG,WAAW,6DAEzB,IAAK,IACDL,EAAOQ,QAAkB,IAARN,EAAY,QAAkB,IAARA,EAAY,SAAW,QAC9D,MACJ,IAAK,IACD,GAAIA,EAAM,EACN,MAAM,IAAIG,WAAW,iDAEzBL,EAAOQ,QAAU,CAAC,QAAS,OAAQ,SAAU,SAASN,EAAM,GAC5D,MACJ,IAAK,IACD,GAAIA,EAAM,EACN,MAAM,IAAIG,WAAW,iDAEzBL,EAAOQ,QAAU,CAAC,QAAS,OAAQ,SAAU,SAASN,EAAM,GAC5D,MAEJ,IAAK,IACDF,EAAOS,QAAS,EAChB,MACJ,IAAK,IACL,IAAK,IACD,MAAM,IAAIJ,WAAW,8DAEzB,IAAK,IACDL,EAAOU,UAAY,MACnBV,EAAO/J,KAAO,CAAC,UAAW,WAAWiK,EAAM,GAC3C,MACJ,IAAK,IACDF,EAAOU,UAAY,MACnBV,EAAO/J,KAAO,CAAC,UAAW,WAAWiK,EAAM,GAC3C,MACJ,IAAK,IACDF,EAAOU,UAAY,MACnBV,EAAO/J,KAAO,CAAC,UAAW,WAAWiK,EAAM,GAC3C,MACJ,IAAK,IACDF,EAAOU,UAAY,MACnBV,EAAO/J,KAAO,CAAC,UAAW,WAAWiK,EAAM,GAC3C,MACJ,IAAK,IACL,IAAK,IACL,IAAK,IACD,MAAM,IAAIG,WAAW,oEAEzB,IAAK,IACDL,EAAO9J,OAAS,CAAC,UAAW,WAAWgK,EAAM,GAC7C,MAEJ,IAAK,IACDF,EAAO7J,OAAS,CAAC,UAAW,WAAW+J,EAAM,GAC7C,MACJ,IAAK,IACL,IAAK,IACD,MAAM,IAAIG,WAAW,8DAEzB,IAAK,IACDL,EAAOW,aAAeT,EAAM,EAAI,QAAU,OAC1C,MACJ,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACD,MAAM,IAAIG,WAAW,wEAE7B,MAAO,MAEJL,I,iCCvHX,yFAEO,SAASY,EAA8Bb,GAC1C,GAAwB,IAApBA,EAASpM,OACT,MAAM,IAAIxB,MAAM,mCAOpB,IAJA,IAGI0O,EAAS,GACJrK,EAAK,EAAGsK,EAJEf,EACdgB,MAAMC,KACNC,QAAO,SAAU7G,GAAK,OAAOA,EAAEzG,OAAS,KAEG6C,EAAKsK,EAAenN,OAAQ6C,IAAM,CAC9E,IACI0K,EADcJ,EAAetK,GACAuK,MAAM,KACvC,GAA8B,IAA1BG,EAAevN,OACf,MAAM,IAAIxB,MAAM,2BAGpB,IADA,IAAIgP,EAAOD,EAAe,GAAI5L,EAAU4L,EAAevM,MAAM,GACpDS,EAAK,EAAGgM,EAAY9L,EAASF,EAAKgM,EAAUzN,OAAQyB,IAAM,CAE/D,GAAsB,IADTgM,EAAUhM,GACZzB,OACP,MAAM,IAAIxB,MAAM,2BAGxB0O,EAAOvN,KAAK,CAAE6N,KAAMA,EAAM7L,QAASA,IAEvC,OAAOuL,EAKX,IAAIQ,EAA2B,mCAC3BC,EAA8B,wBAC9BC,EAAsB,0BACtBC,EAA8B,SAClC,SAASC,EAA0BC,GAC/B,IAAI1B,EAAS,GA6Bb,MA5B4B,MAAxB0B,EAAIA,EAAI/N,OAAS,GACjBqM,EAAO2B,iBAAmB,gBAEG,MAAxBD,EAAIA,EAAI/N,OAAS,KACtBqM,EAAO2B,iBAAmB,iBAE9BD,EAAInI,QAAQ+H,GAA6B,SAAUM,EAAGC,EAAIC,GAoBtD,MAlBkB,iBAAPA,GACP9B,EAAO+B,yBAA2BF,EAAGlO,OACrCqM,EAAOgC,yBAA2BH,EAAGlO,QAGzB,MAAPmO,EACL9B,EAAO+B,yBAA2BF,EAAGlO,OAGtB,MAAVkO,EAAG,GACR7B,EAAOgC,yBAA2BH,EAAGlO,QAIrCqM,EAAO+B,yBAA2BF,EAAGlO,OACrCqM,EAAOgC,yBACHH,EAAGlO,QAAwB,iBAAPmO,EAAkBA,EAAGnO,OAAS,IAEnD,MAEJqM,EAEX,SAASiC,EAAUP,GACf,OAAQA,GACJ,IAAK,YACD,MAAO,CACHQ,YAAa,QAErB,IAAK,kBACL,IAAK,KACD,MAAO,CACHC,aAAc,cAEtB,IAAK,cACL,IAAK,KACD,MAAO,CACHD,YAAa,UAErB,IAAK,yBACL,IAAK,MACD,MAAO,CACHA,YAAa,SACbC,aAAc,cAEtB,IAAK,mBACL,IAAK,KACD,MAAO,CACHD,YAAa,cAErB,IAAK,8BACL,IAAK,MACD,MAAO,CACHA,YAAa,aACbC,aAAc,cAEtB,IAAK,aACL,IAAK,KACD,MAAO,CACHD,YAAa,UAI7B,SAASE,EAAyCjB,GAE9C,IAAInB,EAaJ,GAZgB,MAAZmB,EAAK,IAA0B,MAAZA,EAAK,IACxBnB,EAAS,CACLqC,SAAU,eAEdlB,EAAOA,EAAKxM,MAAM,IAED,MAAZwM,EAAK,KACVnB,EAAS,CACLqC,SAAU,cAEdlB,EAAOA,EAAKxM,MAAM,IAElBqL,EAAQ,CACR,IAAIkC,EAAcf,EAAKxM,MAAM,EAAG,GAShC,GARoB,OAAhBuN,GACAlC,EAAOkC,YAAc,SACrBf,EAAOA,EAAKxM,MAAM,IAEG,OAAhBuN,IACLlC,EAAOkC,YAAc,aACrBf,EAAOA,EAAKxM,MAAM,KAEjB6M,EAA4Bc,KAAKnB,GAClC,MAAM,IAAIhP,MAAM,6CAEpB6N,EAAOuC,qBAAuBpB,EAAKxN,OAEvC,OAAOqM,EAEX,SAASwC,EAAqBC,GAC1B,IACIC,EAAWT,EAAUQ,GACzB,OAAIC,GAFS,GAUV,SAASC,EAAoB9B,GAEhC,IADA,IAAIb,EAAS,GACJxJ,EAAK,EAAGoM,EAAW/B,EAAQrK,EAAKoM,EAASjP,OAAQ6C,IAAM,CAC5D,IAAIqM,EAAQD,EAASpM,GACrB,OAAQqM,EAAM1B,MACV,IAAK,UACL,IAAK,IACDnB,EAAO8C,MAAQ,UACf,SACJ,IAAK,QACD9C,EAAO8C,MAAQ,UACf9C,EAAO+C,MAAQ,IACf,SACJ,IAAK,WACD/C,EAAO8C,MAAQ,WACf9C,EAAOgD,SAAWH,EAAMvN,QAAQ,GAChC,SACJ,IAAK,YACL,IAAK,KACD0K,EAAOiD,aAAc,EACrB,SACJ,IAAK,oBACL,IAAK,IACDjD,EAAOkD,sBAAwB,EAC/B,SACJ,IAAK,eACL,IAAK,OACDlD,EAAO8C,MAAQ,OACf9C,EAAOmD,KAAqBN,EAAMvN,QAAQ,GArJ1CiE,QAAQ,UAAW,IAsJnB,SACJ,IAAK,gBACL,IAAK,IACDyG,EAAOqC,SAAW,UAClBrC,EAAOoD,eAAiB,QACxB,SACJ,IAAK,eACL,IAAK,KACDpD,EAAOqC,SAAW,UAClBrC,EAAOoD,eAAiB,OACxB,SACJ,IAAK,aACDpD,EAASnK,YAASA,YAASA,YAAS,GAAImK,GAAS,CAAEqC,SAAU,eAAiBQ,EAAMvN,QAAQqC,QAAO,SAAUC,EAAK6K,GAAO,OAAQ5M,YAASA,YAAS,GAAI+B,GAAM4K,EAAqBC,MAAW,KAC7L,SACJ,IAAK,cACDzC,EAASnK,YAASA,YAASA,YAAS,GAAImK,GAAS,CAAEqC,SAAU,gBAAkBQ,EAAMvN,QAAQqC,QAAO,SAAUC,EAAK6K,GAAO,OAAQ5M,YAASA,YAAS,GAAI+B,GAAM4K,EAAqBC,MAAW,KAC9L,SACJ,IAAK,kBACDzC,EAAOqC,SAAW,WAClB,SAEJ,IAAK,oBACDrC,EAAOqD,gBAAkB,eACzBrD,EAAOsD,YAAc,SACrB,SACJ,IAAK,mBACDtD,EAAOqD,gBAAkB,OACzBrD,EAAOsD,YAAc,QACrB,SACJ,IAAK,uBACDtD,EAAOqD,gBAAkB,OACzBrD,EAAOsD,YAAc,OACrB,SACJ,IAAK,sBACDtD,EAAOqD,gBAAkB,SACzB,SACJ,IAAK,QACDrD,EAAO+C,MAAQQ,WAAWV,EAAMvN,QAAQ,IACxC,SAEJ,IAAK,gBACD,GAAIuN,EAAMvN,QAAQ3B,OAAS,EACvB,MAAM,IAAI0M,WAAW,4DAEzBwC,EAAMvN,QAAQ,GAAGiE,QAAQgI,GAAqB,SAAUK,EAAGC,EAAIC,EAAI0B,EAAIC,EAAIC,GACvE,GAAI7B,EACA7B,EAAOuC,qBAAuBT,EAAGnO,WAEhC,IAAI6P,GAAMC,EACX,MAAM,IAAItR,MAAM,sDAEf,GAAIuR,EACL,MAAM,IAAIvR,MAAM,oDAEpB,MAAO,MAEX,SAGR,GAAIqP,EAA4Bc,KAAKO,EAAM1B,MACvCnB,EAAOuC,qBAAuBM,EAAM1B,KAAKxN,YAG7C,GAAI0N,EAAyBiB,KAAKO,EAAM1B,MAAxC,CAII,GAAI0B,EAAMvN,QAAQ3B,OAAS,EACvB,MAAM,IAAI0M,WAAW,iEAEzBwC,EAAM1B,KAAK5H,QAAQ8H,GAA0B,SAAUO,EAAGC,EAAIC,EAAI0B,EAAIC,EAAIC,GAkBtE,MAhBW,MAAP5B,EACA9B,EAAO2D,sBAAwB9B,EAAGlO,OAG7B6P,GAAgB,MAAVA,EAAG,GACdxD,EAAOkD,sBAAwBM,EAAG7P,OAG7B8P,GAAMC,GACX1D,EAAO2D,sBAAwBF,EAAG9P,OAClCqM,EAAOkD,sBAAwBO,EAAG9P,OAAS+P,EAAG/P,SAG9CqM,EAAO2D,sBAAwB9B,EAAGlO,OAClCqM,EAAOkD,sBAAwBrB,EAAGlO,QAE/B,MAEX,IAAI8O,EAAMI,EAAMvN,QAAQ,GAEZ,MAARmN,EACAzC,EAASnK,YAASA,YAAS,GAAImK,GAAS,CAAE4D,oBAAqB,mBAE1DnB,IACLzC,EAASnK,YAASA,YAAS,GAAImK,GAASyB,EAA0BgB,UAK1E,GAAInB,EAA4BgB,KAAKO,EAAM1B,MACvCnB,EAASnK,YAASA,YAAS,GAAImK,GAASyB,EAA0BoB,EAAM1B,WAD5E,CAIA,IAAIuB,EAAWT,EAAUY,EAAM1B,MAC3BuB,IACA1C,EAASnK,YAASA,YAAS,GAAImK,GAAS0C,IAE5C,IAAImB,EAAsCzB,EAAyCS,EAAM1B,MACrF0C,IACA7D,EAASnK,YAASA,YAAS,GAAImK,GAAS6D,KAGhD,OAAO7D,I,iCCrSX,sCAAI5K,EAAJ,0CAMI0O,EAA8B,IAAIC,OAAO,IAAInK,OAAOE,IAAsBkK,OAAQ,MAClFC,EAA4B,IAAIF,OAAO,GAAGnK,OAAOE,IAAsBkK,OAAQ,OACnF,SAASE,EAAeC,EAAOC,GAC3B,MAAO,CAAED,MAAOA,EAAOC,IAAKA,GAIhC,IAAIC,IAAwBrN,OAAO9H,UAAUoV,WACzCC,IAA2BvN,OAAOwN,cAClCC,IAAyBxV,OAAOyV,YAChCC,IAAyB3N,OAAO9H,UAAU0V,YAC1CC,IAAiB7N,OAAO9H,UAAU4V,UAClCC,IAAe/N,OAAO9H,UAAU8V,QAEhCC,IAD2BC,OAAOD,cAEhCC,OAAOD,cACP,SAAU9V,GACR,MAAqB,iBAANA,GACXgW,SAAShW,IACT4N,KAAKqI,MAAMjW,KAAOA,GAClB4N,KAAKsI,IAAIlW,IAAM,kBAGvBmW,GAAyB,EAC7B,IAQIA,EAA8F,OAA5C,QAAvBlQ,EAPlBmQ,EAAG,4CAA6C,MAOtBC,KAAK,YAAyB,IAAPpQ,OAAgB,EAASA,EAAG,IAE1F,MAAOwM,GACH0D,GAAyB,EAE7B,IAyFIG,EAzFAnB,EAAaD,EAET,SAAoBtT,EAAG2U,EAAQC,GAC3B,OAAO5U,EAAEuT,WAAWoB,EAAQC,IAGhC,SAAoB5U,EAAG2U,EAAQC,GAC3B,OAAO5U,EAAE4D,MAAMgR,EAAUA,EAAWD,EAAO/R,UAAY+R,GAE/DlB,EAAgBD,EACdvN,OAAOwN,cAEL,WAEI,IADA,IAAIoB,EAAa,GACRpP,EAAK,EAAGA,EAAKC,UAAU9C,OAAQ6C,IACpCoP,EAAWpP,GAAMC,UAAUD,GAM/B,IAJA,IAGIqP,EAHAC,EAAW,GACXnS,EAASiS,EAAWjS,OACpBnE,EAAI,EAEDmE,EAASnE,GAAG,CAEf,IADAqW,EAAOD,EAAWpW,MACP,QACP,MAAM6Q,WAAWwF,EAAO,8BAC5BC,GACID,EAAO,MACD7O,OAAO+O,aAAaF,GACpB7O,OAAO+O,aAAyC,QAA1BF,GAAQ,QAAY,IAAeA,EAAO,KAAS,OAEvF,OAAOC,GAEfpB,EAEJD,EACMxV,OAAOyV,YAEL,SAAqBsB,GAEjB,IADA,IAAIC,EAAM,GACDzP,EAAK,EAAG0P,EAAYF,EAASxP,EAAK0P,EAAUvS,OAAQ6C,IAAM,CAC/D,IAAIpB,EAAK8Q,EAAU1P,GAAKqB,EAAIzC,EAAG,GAAI7D,EAAI6D,EAAG,GAC1C6Q,EAAIpO,GAAKtG,EAEb,OAAO0U,GAEfrB,EAAcD,EAEV,SAAqB5T,EAAGoV,GACpB,OAAOpV,EAAE6T,YAAYuB,IAGzB,SAAqBpV,EAAGoV,GACpB,IAAIC,EAAOrV,EAAE4C,OACb,KAAIwS,EAAQ,GAAKA,GAASC,GAA1B,CAGA,IACIjQ,EADAkQ,EAAQtV,EAAEuV,WAAWH,GAEzB,OAAOE,EAAQ,OACXA,EAAQ,OACRF,EAAQ,IAAMC,IACbjQ,EAASpF,EAAEuV,WAAWH,EAAQ,IAAM,OACrChQ,EAAS,MACPkQ,EAC4BlQ,EAAS,OAAnCkQ,EAAQ,OAAW,IAA0B,QAE7DvB,EAAYD,EAER,SAAmB9T,GACf,OAAOA,EAAE+T,aAGb,SAAmB/T,GACf,OAAOA,EAAEwI,QAAQuK,EAA6B,KAEtDkB,EAAUD,EAEN,SAAiBhU,GACb,OAAOA,EAAEiU,WAGb,SAAiBjU,GACb,OAAOA,EAAEwI,QAAQ0K,EAA2B,KAGxD,SAASsB,EAAGxU,EAAGwV,GACX,OAAO,IAAIxC,OAAOhT,EAAGwV,GAIzB,GAAIjB,EAAwB,CAExB,IAAIkB,EAAyBjB,EAAG,4CAA6C,MAC7EE,EAAyB,SAAgC1U,EAAGoV,GACxD,IAAI/Q,EAGJ,OAFAoR,EAAuBC,UAAYN,EAER,QAAnB/Q,EADIoR,EAAuBhB,KAAKzU,GACrB,UAAuB,IAAPqE,EAAgBA,EAAK,SAK5DqQ,EAAyB,SAAgC1U,EAAGoV,GAExD,IADA,IAAIlG,EAAQ,KACC,CACT,IAAIrQ,EAAIgV,EAAY7T,EAAGoV,GACvB,QAAUO,IAAN9W,GAAmB+W,EAAc/W,IAAMgX,EAAiBhX,GACxD,MAEJqQ,EAAM3M,KAAK1D,GACXuW,GAASvW,GAAK,MAAU,EAAI,EAEhC,OAAO4U,EAAcqC,WAAM,EAAQ5G,IAG3C,IAAI6G,EAAwB,WACxB,SAASA,EAAO5N,EAAS5D,QACL,IAAZA,IAAsBA,EAAU,IACpClE,KAAK8H,QAAUA,EACf9H,KAAKuU,SAAW,CAAEoB,OAAQ,EAAGC,KAAM,EAAGC,OAAQ,GAC9C7V,KAAK8V,YAAc5R,EAAQ4R,UAC3B9V,KAAK+V,sBAAwB7R,EAAQ6R,oBACrC/V,KAAKgW,uBAAyB9R,EAAQ8R,qBA+xB1C,OA7xBAN,EAAO5X,UAAUmY,MAAQ,WACrB,GAAsB,IAAlBjW,KAAK2V,SACL,MAAM5U,MAAM,gCAEhB,OAAOf,KAAKkW,aAAa,EAAG,IAAI,IAEpCR,EAAO5X,UAAUoY,aAAe,SAAUC,EAAcC,EAAeC,GAEnE,IADA,IAAI3B,EAAW,IACP1U,KAAKsW,SAAS,CAClB,IAAIC,EAAOvW,KAAKuW,OAChB,GAAa,MAATA,EAAwB,CAExB,IADI3H,EAAS5O,KAAKwW,cAAcL,EAAcE,IACnCI,IACP,OAAO7H,EAEX8F,EAASxS,KAAK0M,EAAOd,SAEpB,IAAa,MAATyI,GAA0BJ,EAAe,EAC9C,MAEC,GAAa,KAATI,GACc,WAAlBH,GAAgD,kBAAlBA,EAQ9B,IAAa,KAATG,IACJvW,KAAK8V,WACU,KAAhB9V,KAAK0W,OACP,CACE,GAAIL,EACA,MAGA,OAAOrW,KAAK2W,MAAMC,IAAUC,sBAAuB/D,EAAe9S,KAAK8W,gBAAiB9W,KAAK8W,kBAGhG,GAAa,KAATP,IACJvW,KAAK8V,WACNiB,EAAS/W,KAAK0W,QAAU,GAAI,CAE5B,IADI9H,EAAS5O,KAAKgX,SAASb,EAAcC,IAC9BK,IACP,OAAO7H,EAEX8F,EAASxS,KAAK0M,EAAOd,SAEpB,CACD,IAAIc,EACJ,IADIA,EAAS5O,KAAKiX,aAAad,EAAcC,IAClCK,IACP,OAAO7H,EAEX8F,EAASxS,KAAK0M,EAAOd,UAjC8C,CACnE,IAAIyG,EAAWvU,KAAK8W,gBACpB9W,KAAKkX,OACLxC,EAASxS,KAAK,CACV5C,KAAM2I,IAAKkP,MACXC,SAAUtE,EAAeyB,EAAUvU,KAAK8W,qBA+BpD,MAAO,CAAEhJ,IAAK4G,EAAU+B,IAAK,OAoBjCf,EAAO5X,UAAUkZ,SAAW,SAAUb,EAAcC,GAChD,IAAIiB,EAAgBrX,KAAK8W,gBACzB9W,KAAKkX,OACL,IAAII,EAAUtX,KAAKuX,eAEnB,GADAvX,KAAKwX,YACDxX,KAAKyX,OAAO,MAEZ,MAAO,CACH3J,IAAK,CACDxO,KAAM2I,IAAKC,QACX/J,MAAO,IAAIqK,OAAO8O,EAAS,MAC3BF,SAAUtE,EAAeuE,EAAerX,KAAK8W,kBAEjDL,IAAK,MAGR,GAAIzW,KAAKyX,OAAO,KAAM,CACvB,IAAIC,EAAiB1X,KAAKkW,aAAaC,EAAe,EAAGC,GAAe,GACxE,GAAIsB,EAAejB,IACf,OAAOiB,EAEX,IAAIC,EAAWD,EAAe5J,IAE1B8J,EAAsB5X,KAAK8W,gBAC/B,GAAI9W,KAAKyX,OAAO,MAAO,CACnB,GAAIzX,KAAKsW,UAAYS,EAAS/W,KAAKuW,QAC/B,OAAOvW,KAAK2W,MAAMC,IAAUiB,YAAa/E,EAAe8E,EAAqB5X,KAAK8W,kBAEtF,IAAIgB,EAA8B9X,KAAK8W,gBAEvC,OAAIQ,IADiBtX,KAAKuX,eAEfvX,KAAK2W,MAAMC,IAAUC,sBAAuB/D,EAAegF,EAA6B9X,KAAK8W,mBAExG9W,KAAKwX,YACAxX,KAAKyX,OAAO,KAGV,CACH3J,IAAK,CACDxO,KAAM2I,IAAK8P,IACX5Z,MAAOmZ,EACPK,SAAUA,EACVP,SAAUtE,EAAeuE,EAAerX,KAAK8W,kBAEjDL,IAAK,MATEzW,KAAK2W,MAAMC,IAAUiB,YAAa/E,EAAe8E,EAAqB5X,KAAK8W,mBAatF,OAAO9W,KAAK2W,MAAMC,IAAUoB,aAAclF,EAAeuE,EAAerX,KAAK8W,kBAIjF,OAAO9W,KAAK2W,MAAMC,IAAUiB,YAAa/E,EAAeuE,EAAerX,KAAK8W,mBAMpFpB,EAAO5X,UAAUyZ,aAAe,WAC5B,IAqqB6B/Y,EArqBzByZ,EAAcjY,KAAK2V,SAEvB,IADA3V,KAAKkX,QACGlX,KAAKsW,UAoqBH,MADmB9X,EAnqBuBwB,KAAKuW,SAqqBnD,KAAN/X,GACCA,GAAK,IAAMA,GAAK,IACX,KAANA,GACCA,GAAK,IAAMA,GAAK,KAChBA,GAAK,IAAMA,GAAK,IACZ,KAALA,GACCA,GAAK,KAAQA,GAAK,KAClBA,GAAK,KAAQA,GAAK,KAClBA,GAAK,KAAQA,GAAK,KAClBA,GAAK,KAASA,GAAK,MACnBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAWA,GAAK,SArrBlBwB,KAAKkX,OAET,OAAOlX,KAAK8H,QAAQvE,MAAM0U,EAAajY,KAAK2V,WAEhDD,EAAO5X,UAAUmZ,aAAe,SAAUd,EAAcC,GAGpD,IAFA,IAAIrD,EAAQ/S,KAAK8W,gBACb3Y,EAAQ,KACC,CACT,IAAI+Z,EAAmBlY,KAAKmY,cAAc/B,GAC1C,GAAI8B,EACA/Z,GAAS+Z,MADb,CAIA,IAAIE,EAAsBpY,KAAKqY,iBAAiBlC,EAAcC,GAC9D,GAAIgC,EACAja,GAASia,MADb,CAIA,IAAIE,EAAuBtY,KAAKuY,2BAChC,IAAID,EAIJ,MAHIna,GAASma,IAKjB,IAAIlB,EAAWtE,EAAeC,EAAO/S,KAAK8W,iBAC1C,MAAO,CACHhJ,IAAK,CAAExO,KAAM2I,IAAKC,QAAS/J,MAAOA,EAAOiZ,SAAUA,GACnDX,IAAK,OAGbf,EAAO5X,UAAUya,yBAA2B,WACxC,OAAKvY,KAAKsW,SACU,KAAhBtW,KAAKuW,SACJvW,KAAK8V,YA6nBPiB,EADcyB,EA1nBQxY,KAAK0W,QAAU,IA2nBA,KAAd8B,GAvnBnB,MAHHxY,KAAKkX,OACE,KAwnBnB,IAAyBsB,GA/mBrB9C,EAAO5X,UAAUqa,cAAgB,SAAU/B,GACvC,GAAIpW,KAAKsW,SAA2B,KAAhBtW,KAAKuW,OACrB,OAAO,KAIX,OAAQvW,KAAK0W,QACT,KAAK,GAID,OAFA1W,KAAKkX,OACLlX,KAAKkX,OACE,IAEX,KAAK,IACL,KAAK,GACL,KAAK,GACL,KAAK,IACD,MACJ,KAAK,GACD,GAAsB,WAAlBd,GAAgD,kBAAlBA,EAC9B,MAEJ,OAAO,KACX,QACI,OAAO,KAEfpW,KAAKkX,OACL,IAAI1C,EAAa,CAACxU,KAAKuW,QAGvB,IAFAvW,KAAKkX,QAEGlX,KAAKsW,SAAS,CAClB,IAAImC,EAAKzY,KAAKuW,OACd,GAAW,KAAPkC,EAAqB,CACrB,GAAoB,KAAhBzY,KAAK0W,OAKJ,CAED1W,KAAKkX,OACL,MAPA1C,EAAWtS,KAAK,IAEhBlC,KAAKkX,YAST1C,EAAWtS,KAAKuW,GAEpBzY,KAAKkX,OAET,OAAO9D,EAAcqC,WAAM,EAAQjB,IAEvCkB,EAAO5X,UAAUua,iBAAmB,SAAUlC,EAAcC,GACxD,GAAIpW,KAAKsW,QACL,OAAO,KAEX,IAAImC,EAAKzY,KAAKuW,OACd,OAAW,KAAPkC,GACO,MAAPA,GACQ,KAAPA,IACsB,WAAlBrC,GAAgD,kBAAlBA,IAC3B,MAAPqC,GAAwBtC,EAAe,EACjC,MAGPnW,KAAKkX,OACE9D,EAAcqF,KAG7B/C,EAAO5X,UAAU0Y,cAAgB,SAAUL,EAAcE,GACrD,IAAIqC,EAAuB1Y,KAAK8W,gBAGhC,GAFA9W,KAAKkX,OACLlX,KAAKwX,YACDxX,KAAKsW,QACL,OAAOtW,KAAK2W,MAAMC,IAAU+B,8BAA+B7F,EAAe4F,EAAsB1Y,KAAK8W,kBAEzG,GAAoB,MAAhB9W,KAAKuW,OAEL,OADAvW,KAAKkX,OACElX,KAAK2W,MAAMC,IAAUgC,eAAgB9F,EAAe4F,EAAsB1Y,KAAK8W,kBAG1F,IAAI3Y,EAAQ6B,KAAK6Y,4BAA4B1a,MAC7C,IAAKA,EACD,OAAO6B,KAAK2W,MAAMC,IAAUkC,mBAAoBhG,EAAe4F,EAAsB1Y,KAAK8W,kBAG9F,GADA9W,KAAKwX,YACDxX,KAAKsW,QACL,OAAOtW,KAAK2W,MAAMC,IAAU+B,8BAA+B7F,EAAe4F,EAAsB1Y,KAAK8W,kBAEzG,OAAQ9W,KAAKuW,QAET,KAAK,IAED,OADAvW,KAAKkX,OACE,CACHpJ,IAAK,CACDxO,KAAM2I,IAAK8Q,SAEX5a,MAAOA,EACPiZ,SAAUtE,EAAe4F,EAAsB1Y,KAAK8W,kBAExDL,IAAK,MAIb,KAAK,GAGD,OAFAzW,KAAKkX,OACLlX,KAAKwX,YACDxX,KAAKsW,QACEtW,KAAK2W,MAAMC,IAAU+B,8BAA+B7F,EAAe4F,EAAsB1Y,KAAK8W,kBAElG9W,KAAKgZ,qBAAqB7C,EAAcE,EAAmBlY,EAAOua,GAE7E,QACI,OAAO1Y,KAAK2W,MAAMC,IAAUkC,mBAAoBhG,EAAe4F,EAAsB1Y,KAAK8W,oBAOtGpB,EAAO5X,UAAU+a,0BAA4B,WACzC,IAAII,EAAmBjZ,KAAK8W,gBACxBmB,EAAcjY,KAAK2V,SACnBxX,EAAQkW,EAAuBrU,KAAK8H,QAASmQ,GAC7CiB,EAAYjB,EAAc9Z,EAAMoE,OAIpC,OAHAvC,KAAKmZ,OAAOD,GAGL,CAAE/a,MAAOA,EAAOiZ,SADRtE,EAAemG,EADZjZ,KAAK8W,mBAI3BpB,EAAO5X,UAAUkb,qBAAuB,SAAU7C,EAAcE,EAAmBlY,EAAOua,GACtF,IAAI1U,EAIAoV,EAAoBpZ,KAAK8W,gBACzBuC,EAAUrZ,KAAK6Y,4BAA4B1a,MAC3Cmb,EAAkBtZ,KAAK8W,gBAC3B,OAAQuC,GACJ,IAAK,GAED,OAAOrZ,KAAK2W,MAAMC,IAAU2C,qBAAsBzG,EAAesG,EAAmBE,IACxF,IAAK,SACL,IAAK,OACL,IAAK,OAIDtZ,KAAKwX,YACL,IAAIgC,EAAmB,KACvB,GAAIxZ,KAAKyX,OAAO,KAAM,CAClBzX,KAAKwX,YACL,IAAIiC,EAAqBzZ,KAAK8W,gBAE9B,IADIlI,EAAS5O,KAAK0Z,iCACPjD,IACP,OAAO7H,EAGX,GAAqB,KADjB8C,EAAQkC,EAAQhF,EAAOd,MACjBvL,OACN,OAAOvC,KAAK2W,MAAMC,IAAU+C,sBAAuB7G,EAAe9S,KAAK8W,gBAAiB9W,KAAK8W,kBAGjG0C,EAAmB,CAAE9H,MAAOA,EAAOkI,cADf9G,EAAe2G,EAAoBzZ,KAAK8W,kBAIhE,IADI+C,EAAiB7Z,KAAK8Z,sBAAsBpB,IAC7BjC,IACf,OAAOoD,EAEX,IAAIE,EAAajH,EAAe4F,EAAsB1Y,KAAK8W,iBAE3D,GAAI0C,GAAoBtG,EAAWsG,aAA2D,EAASA,EAAiB9H,MAAO,KAAM,GAAI,CAErI,IAAI/C,EAAW+E,EAAU8F,EAAiB9H,MAAMnO,MAAM,IACtD,GAAgB,WAAZ8V,EAEA,OADIzK,EAAS5O,KAAKwP,8BAA8Bb,EAAU6K,EAAiBI,gBAChEnD,IACA7H,EAEJ,CACHd,IAAK,CAAExO,KAAM2I,IAAK+R,OAAQ7b,MAAOA,EAAOiZ,SAAU2C,EAAYrI,MAAO9C,EAAOd,KAC5E2I,IAAK,MAIT,GAAwB,IAApB9H,EAASpM,OACT,OAAOvC,KAAK2W,MAAMC,IAAUqD,0BAA2BF,GAE3D,IAAIrI,EAAQ,CACRpS,KAAM4a,IAAcC,SACpBC,QAASzL,EACTyI,SAAUoC,EAAiBI,cAC3BS,cAAera,KAAKgW,qBACdtH,YAAsBC,GACtB,IAGV,MAAO,CACHb,IAAK,CAAExO,KAFY,SAAZ+Z,EAAqBpR,IAAK1C,KAAO0C,IAAKhB,KAE1B9I,MAAOA,EAAOiZ,SAAU2C,EAAYrI,MAAOA,GAC9D+E,IAAK,MAKjB,MAAO,CACH3I,IAAK,CACDxO,KAAkB,WAAZ+Z,EACApR,IAAK+R,OACO,SAAZX,EACIpR,IAAK1C,KACL0C,IAAKhB,KACf9I,MAAOA,EACPiZ,SAAU2C,EACVrI,MAA6G,QAArG1N,EAAKwV,aAA2D,EAASA,EAAiB9H,aAA0B,IAAP1N,EAAgBA,EAAK,MAE9IyS,IAAK,MAGb,IAAK,SACL,IAAK,gBACL,IAAK,SAID,IAAI6D,EAAoBta,KAAK8W,gBAE7B,GADA9W,KAAKwX,aACAxX,KAAKyX,OAAO,KACb,OAAOzX,KAAK2W,MAAMC,IAAU2D,+BAAgCzH,EAAewH,EAAmB7V,YAAS,GAAI6V,KAE/Gta,KAAKwX,YASL,IAAIgD,EAAwBxa,KAAK6Y,4BAC7B4B,EAAe,EACnB,GAAgB,WAAZpB,GAAwD,WAAhCmB,EAAsBrc,MAAoB,CAClE,IAAK6B,KAAKyX,OAAO,KACb,OAAOzX,KAAK2W,MAAMC,IAAU8D,oCAAqC5H,EAAe9S,KAAK8W,gBAAiB9W,KAAK8W,kBAG/G,IAAIlI,EACJ,GAFA5O,KAAKwX,aACD5I,EAAS5O,KAAK2a,uBAAuB/D,IAAU8D,oCAAqC9D,IAAUgE,uCACvFnE,IACP,OAAO7H,EAGX5O,KAAKwX,YACLgD,EAAwBxa,KAAK6Y,4BAC7B4B,EAAe7L,EAAOd,IAE1B,IAII+L,EAJAgB,EAAgB7a,KAAK8a,8BAA8B3E,EAAckD,EAAShD,EAAmBmE,GACjG,GAAIK,EAAcpE,IACd,OAAOoE,EAGX,IADIhB,EAAiB7Z,KAAK8Z,sBAAsBpB,IAC7BjC,IACf,OAAOoD,EAEX,IAAIkB,EAAajI,EAAe4F,EAAsB1Y,KAAK8W,iBAC3D,MAAgB,WAAZuC,EACO,CACHvL,IAAK,CACDxO,KAAM2I,IAAK+S,OACX7c,MAAOA,EACP+F,QAASoP,EAAYuH,EAAc/M,KACnCsJ,SAAU2D,GAEdtE,IAAK,MAIF,CACH3I,IAAK,CACDxO,KAAM2I,IAAKgT,OACX9c,MAAOA,EACP+F,QAASoP,EAAYuH,EAAc/M,KACnC6H,OAAQ8E,EACRS,WAAwB,WAAZ7B,EAAuB,WAAa,UAChDjC,SAAU2D,GAEdtE,IAAK,MAIjB,QACI,OAAOzW,KAAK2W,MAAMC,IAAUuE,sBAAuBrI,EAAesG,EAAmBE,MAGjG5D,EAAO5X,UAAUgc,sBAAwB,SAAUpB,GAG/C,OAAI1Y,KAAKsW,SAA2B,MAAhBtW,KAAKuW,OACdvW,KAAK2W,MAAMC,IAAU+B,8BAA+B7F,EAAe4F,EAAsB1Y,KAAK8W,mBAEzG9W,KAAKkX,OACE,CAAEpJ,KAAK,EAAM2I,IAAK,QAK7Bf,EAAO5X,UAAU4b,8BAAgC,WAG7C,IAFA,IAAI0B,EAAe,EACf/D,EAAgBrX,KAAK8W,iBACjB9W,KAAKsW,SAAS,CAElB,OADStW,KAAKuW,QAEV,KAAK,GAGDvW,KAAKkX,OACL,IAAImE,EAAqBrb,KAAK8W,gBAC9B,IAAK9W,KAAKsb,UAAU,KAChB,OAAOtb,KAAK2W,MAAMC,IAAU2E,iCAAkCzI,EAAeuI,EAAoBrb,KAAK8W,kBAE1G9W,KAAKkX,OACL,MAEJ,KAAK,IACDkE,GAAgB,EAChBpb,KAAKkX,OACL,MAEJ,KAAK,IACD,KAAIkE,EAAe,GAIf,MAAO,CACHtN,IAAK9N,KAAK8H,QAAQvE,MAAM8T,EAAc1B,OAAQ3V,KAAK2V,UACnDc,IAAK,MALT2E,GAAgB,EAQpB,MAEJ,QACIpb,KAAKkX,QAIjB,MAAO,CACHpJ,IAAK9N,KAAK8H,QAAQvE,MAAM8T,EAAc1B,OAAQ3V,KAAK2V,UACnDc,IAAK,OAGbf,EAAO5X,UAAU0R,8BAAgC,SAAUb,EAAUyI,GACjE,IAAI3H,EAAS,GACb,IACIA,EAASD,YAA8Bb,GAE3C,MAAOlR,GACH,OAAOuC,KAAK2W,MAAMC,IAAU4E,wBAAyBpE,GAEzD,MAAO,CACHtJ,IAAK,CACDxO,KAAM4a,IAAcF,OACpBvK,OAAQA,EACR2H,SAAUA,EACViD,cAAera,KAAKgW,qBACdzE,YAAoB9B,GACpB,IAEVgH,IAAK,OAabf,EAAO5X,UAAUgd,8BAAgC,SAAU3E,EAAcC,EAAeqF,EAAgBC,GASpG,IARA,IAAI1X,EACA2X,GAAiB,EACjBzX,EAAU,GACV0X,EAAkB,IAAIC,IACtBC,EAAWJ,EAAsBvd,MAAO4d,EAAmBL,EAAsBtE,WAIxE,CACT,GAAwB,IAApB0E,EAASvZ,OAAc,CACvB,IAAI8U,EAAgBrX,KAAK8W,gBACzB,GAAsB,WAAlBV,IAA8BpW,KAAKyX,OAAO,KAU1C,MARA,IAAI7I,EAAS5O,KAAK2a,uBAAuB/D,IAAUoF,gCAAiCpF,IAAUqF,kCAC9F,GAAIrN,EAAO6H,IACP,OAAO7H,EAEXmN,EAAmBjJ,EAAeuE,EAAerX,KAAK8W,iBACtDgF,EAAW9b,KAAK8H,QAAQvE,MAAM8T,EAAc1B,OAAQ3V,KAAK2V,UAOjE,GAAIiG,EAAgBM,IAAIJ,GACpB,OAAO9b,KAAK2W,MAAwB,WAAlBP,EACZQ,IAAUuF,mCACVvF,IAAUwF,mCAAoCL,GAEvC,UAAbD,IACAH,GAAiB,GAKrB3b,KAAKwX,YACL,IAAIkB,EAAuB1Y,KAAK8W,gBAChC,IAAK9W,KAAKyX,OAAO,KACb,OAAOzX,KAAK2W,MAAwB,WAAlBP,EACZQ,IAAUyF,yCACVzF,IAAU0F,yCAA0CxJ,EAAe9S,KAAK8W,gBAAiB9W,KAAK8W,kBAExG,IAAIyF,EAAiBvc,KAAKkW,aAAaC,EAAe,EAAGC,EAAeqF,GACxE,GAAIc,EAAe9F,IACf,OAAO8F,EAEX,IAAI1C,EAAiB7Z,KAAK8Z,sBAAsBpB,GAChD,GAAImB,EAAepD,IACf,OAAOoD,EAEX3V,EAAQhC,KAAK,CACT4Z,EACA,CACI3d,MAAOoe,EAAezO,IACtBsJ,SAAUtE,EAAe4F,EAAsB1Y,KAAK8W,oBAI5D8E,EAAgBY,IAAIV,GAEpB9b,KAAKwX,YACmCsE,GAAvC9X,EAAKhE,KAAK6Y,6BAA2C1a,MAAO4d,EAAmB/X,EAAGoT,SAEvF,OAAuB,IAAnBlT,EAAQ3B,OACDvC,KAAK2W,MAAwB,WAAlBP,EACZQ,IAAU6F,gCACV7F,IAAUoF,gCAAiClJ,EAAe9S,KAAK8W,gBAAiB9W,KAAK8W,kBAE3F9W,KAAK+V,sBAAwB4F,EACtB3b,KAAK2W,MAAMC,IAAU8F,qBAAsB5J,EAAe9S,KAAK8W,gBAAiB9W,KAAK8W,kBAEzF,CAAEhJ,IAAK5J,EAASuS,IAAK,OAEhCf,EAAO5X,UAAU6c,uBAAyB,SAAUgC,EAAmBC,GACnE,IAAIC,EAAO,EACP5D,EAAmBjZ,KAAK8W,gBACxB9W,KAAKyX,OAAO,MAEPzX,KAAKyX,OAAO,OACjBoF,GAAQ,GAIZ,IAFA,IAAIC,GAAY,EACZC,EAAU,GACN/c,KAAKsW,SAAS,CAClB,IAAImC,EAAKzY,KAAKuW,OACd,KAAIkC,GAAM,IAAgBA,GAAM,IAM5B,MALAqE,GAAY,EACZC,EAAoB,GAAVA,GAAgBtE,EAAK,IAC/BzY,KAAKkX,OAMb,IAAIE,EAAWtE,EAAemG,EAAkBjZ,KAAK8W,iBACrD,OAAKgG,EAIAjJ,EADLkJ,GAAWF,GAIJ,CAAE/O,IAAKiP,EAAStG,IAAK,MAFjBzW,KAAK2W,MAAMiG,EAAoBxF,GAJ/BpX,KAAK2W,MAAMgG,EAAmBvF,IAQ7C1B,EAAO5X,UAAU6X,OAAS,WACtB,OAAO3V,KAAKuU,SAASoB,QAEzBD,EAAO5X,UAAUwY,MAAQ,WACrB,OAAOtW,KAAK2V,WAAa3V,KAAK8H,QAAQvF,QAE1CmT,EAAO5X,UAAUgZ,cAAgB,WAE7B,MAAO,CACHnB,OAAQ3V,KAAKuU,SAASoB,OACtBC,KAAM5V,KAAKuU,SAASqB,KACpBC,OAAQ7V,KAAKuU,SAASsB,SAO9BH,EAAO5X,UAAUyY,KAAO,WACpB,IAAIZ,EAAS3V,KAAKuU,SAASoB,OAC3B,GAAIA,GAAU3V,KAAK8H,QAAQvF,OACvB,MAAMxB,MAAM,gBAEhB,IAAI0T,EAAOjB,EAAYxT,KAAK8H,QAAS6N,GACrC,QAAaL,IAATb,EACA,MAAM1T,MAAM,UAAUyH,OAAOmN,EAAQ,6CAEzC,OAAOlB,GAEXiB,EAAO5X,UAAU6Y,MAAQ,SAAUqG,EAAM5F,GACrC,MAAO,CACHtJ,IAAK,KACL2I,IAAK,CACDuG,KAAMA,EACNlV,QAAS9H,KAAK8H,QACdsP,SAAUA,KAKtB1B,EAAO5X,UAAUoZ,KAAO,WACpB,IAAIlX,KAAKsW,QAAT,CAGA,IAAI7B,EAAOzU,KAAKuW,OACH,KAAT9B,GACAzU,KAAKuU,SAASqB,MAAQ,EACtB5V,KAAKuU,SAASsB,OAAS,EACvB7V,KAAKuU,SAASoB,QAAU,IAGxB3V,KAAKuU,SAASsB,QAAU,EAExB7V,KAAKuU,SAASoB,QAAUlB,EAAO,MAAU,EAAI,KASrDiB,EAAO5X,UAAU2Z,OAAS,SAAUwF,GAChC,GAAI/J,EAAWlT,KAAK8H,QAASmV,EAAQjd,KAAK2V,UAAW,CACjD,IAAK,IAAIvX,EAAI,EAAGA,EAAI6e,EAAO1a,OAAQnE,IAC/B4B,KAAKkX,OAET,OAAO,EAEX,OAAO,GAMXxB,EAAO5X,UAAUwd,UAAY,SAAUlB,GACnC,IAAI8C,EAAgBld,KAAK2V,SACrBZ,EAAQ/U,KAAK8H,QAAQqV,QAAQ/C,EAAS8C,GAC1C,OAAInI,GAAS,GACT/U,KAAKmZ,OAAOpE,IACL,IAGP/U,KAAKmZ,OAAOnZ,KAAK8H,QAAQvF,SAClB,IAOfmT,EAAO5X,UAAUqb,OAAS,SAAUiE,GAChC,GAAIpd,KAAK2V,SAAWyH,EAChB,MAAMrc,MAAM,gBAAgByH,OAAO4U,EAAc,yDAAyD5U,OAAOxI,KAAK2V,WAG1H,IADAyH,EAAezR,KAAK0R,IAAID,EAAcpd,KAAK8H,QAAQvF,UACtC,CACT,IAAIoT,EAAS3V,KAAK2V,SAClB,GAAIA,IAAWyH,EACX,MAEJ,GAAIzH,EAASyH,EACT,MAAMrc,MAAM,gBAAgByH,OAAO4U,EAAc,6CAGrD,GADApd,KAAKkX,OACDlX,KAAKsW,QACL,QAKZZ,EAAO5X,UAAU0Z,UAAY,WACzB,MAAQxX,KAAKsW,SAAWf,EAAcvV,KAAKuW,SACvCvW,KAAKkX,QAObxB,EAAO5X,UAAU4Y,KAAO,WACpB,GAAI1W,KAAKsW,QACL,OAAO,KAEX,IAAI7B,EAAOzU,KAAKuW,OACZZ,EAAS3V,KAAK2V,SACd2H,EAAWtd,KAAK8H,QAAQoN,WAAWS,GAAUlB,GAAQ,MAAU,EAAI,IACvE,OAAO6I,QAA2CA,EAAW,MAE1D5H,EAtyBiB,GA8yB5B,SAASqB,EAASyB,GACd,OAASA,GAAa,IAAMA,GAAa,KACpCA,GAAa,IAAMA,GAAa,GA+BzC,SAASjD,EAAc/W,GACnB,OAASA,GAAK,GAAUA,GAAK,IACnB,KAANA,GACM,MAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,EAMR,SAASgX,EAAiBhX,GACtB,OAASA,GAAK,IAAUA,GAAK,IACnB,KAANA,GACCA,GAAK,IAAUA,GAAK,IACf,KAANA,GACM,KAANA,GACM,KAANA,GACM,KAANA,GACM,KAANA,GACM,KAANA,GACCA,GAAK,IAAUA,GAAK,IACpBA,GAAK,IAAUA,GAAK,IACpBA,GAAK,IAAUA,GAAK,IACpBA,GAAK,IAAUA,GAAK,IACf,KAANA,GACM,KAANA,GACM,KAANA,GACM,KAANA,GACM,KAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACCA,GAAK,KAAUA,GAAK,KACf,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACM,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,KACf,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACf,QAANA,GACCA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAA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","file":"static/js/index~9b1fde68.95059db5.chunk.js","sourcesContent":["// TODO(Babel 8): Remove this file.\n\nvar runtime = require(\"../helpers/regeneratorRuntime\")();\nmodule.exports = runtime;\n\n// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  if (typeof globalThis === \"object\") {\n    globalThis.regeneratorRuntime = runtime;\n  } else {\n    Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n  }\n}\n","var _typeof = require(\"./typeof.js\")[\"default\"];\nfunction _regeneratorRuntime() {\n  \"use strict\"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */\n  module.exports = _regeneratorRuntime = function _regeneratorRuntime() {\n    return e;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  var t,\n    e = {},\n    r = Object.prototype,\n    n = r.hasOwnProperty,\n    o = Object.defineProperty || function (t, e, r) {\n      t[e] = r.value;\n    },\n    i = \"function\" == typeof Symbol ? Symbol : {},\n    a = i.iterator || \"@@iterator\",\n    c = i.asyncIterator || \"@@asyncIterator\",\n    u = i.toStringTag || \"@@toStringTag\";\n  function define(t, e, r) {\n    return Object.defineProperty(t, e, {\n      value: r,\n      enumerable: !0,\n      configurable: !0,\n      writable: !0\n    }), t[e];\n  }\n  try {\n    define({}, \"\");\n  } catch (t) {\n    define = function define(t, e, r) {\n      return t[e] = r;\n    };\n  }\n  function wrap(t, e, r, n) {\n    var i = e && e.prototype instanceof Generator ? e : Generator,\n      a = Object.create(i.prototype),\n      c = new Context(n || []);\n    return o(a, \"_invoke\", {\n      value: makeInvokeMethod(t, r, c)\n    }), a;\n  }\n  function tryCatch(t, e, r) {\n    try {\n      return {\n        type: \"normal\",\n        arg: t.call(e, r)\n      };\n    } catch (t) {\n      return {\n        type: \"throw\",\n        arg: t\n      };\n    }\n  }\n  e.wrap = wrap;\n  var h = \"suspendedStart\",\n    l = \"suspendedYield\",\n    f = \"executing\",\n    s = \"completed\",\n    y = {};\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n  var p = {};\n  define(p, a, function () {\n    return this;\n  });\n  var d = Object.getPrototypeOf,\n    v = d && d(d(values([])));\n  v && v !== r && n.call(v, a) && (p = v);\n  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);\n  function defineIteratorMethods(t) {\n    [\"next\", \"throw\", \"return\"].forEach(function (e) {\n      define(t, e, function (t) {\n        return this._invoke(e, t);\n      });\n    });\n  }\n  function AsyncIterator(t, e) {\n    function invoke(r, o, i, a) {\n      var c = tryCatch(t[r], t, o);\n      if (\"throw\" !== c.type) {\n        var u = c.arg,\n          h = u.value;\n        return h && \"object\" == _typeof(h) && n.call(h, \"__await\") ? e.resolve(h.__await).then(function (t) {\n          invoke(\"next\", t, i, a);\n        }, function (t) {\n          invoke(\"throw\", t, i, a);\n        }) : e.resolve(h).then(function (t) {\n          u.value = t, i(u);\n        }, function (t) {\n          return invoke(\"throw\", t, i, a);\n        });\n      }\n      a(c.arg);\n    }\n    var r;\n    o(this, \"_invoke\", {\n      value: function value(t, n) {\n        function callInvokeWithMethodAndArg() {\n          return new e(function (e, r) {\n            invoke(t, n, e, r);\n          });\n        }\n        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();\n      }\n    });\n  }\n  function makeInvokeMethod(e, r, n) {\n    var o = h;\n    return function (i, a) {\n      if (o === f) throw Error(\"Generator is already running\");\n      if (o === s) {\n        if (\"throw\" === i) throw a;\n        return {\n          value: t,\n          done: !0\n        };\n      }\n      for (n.method = i, n.arg = a;;) {\n        var c = n.delegate;\n        if (c) {\n          var u = maybeInvokeDelegate(c, n);\n          if (u) {\n            if (u === y) continue;\n            return u;\n          }\n        }\n        if (\"next\" === n.method) n.sent = n._sent = n.arg;else if (\"throw\" === n.method) {\n          if (o === h) throw o = s, n.arg;\n          n.dispatchException(n.arg);\n        } else \"return\" === n.method && n.abrupt(\"return\", n.arg);\n        o = f;\n        var p = tryCatch(e, r, n);\n        if (\"normal\" === p.type) {\n          if (o = n.done ? s : l, p.arg === y) continue;\n          return {\n            value: p.arg,\n            done: n.done\n          };\n        }\n        \"throw\" === p.type && (o = s, n.method = \"throw\", n.arg = p.arg);\n      }\n    };\n  }\n  function maybeInvokeDelegate(e, r) {\n    var n = r.method,\n      o = e.iterator[n];\n    if (o === t) return r.delegate = null, \"throw\" === n && e.iterator[\"return\"] && (r.method = \"return\", r.arg = t, maybeInvokeDelegate(e, r), \"throw\" === r.method) || \"return\" !== n && (r.method = \"throw\", r.arg = new TypeError(\"The iterator does not provide a '\" + n + \"' method\")), y;\n    var i = tryCatch(o, e.iterator, r.arg);\n    if (\"throw\" === i.type) return r.method = \"throw\", r.arg = i.arg, r.delegate = null, y;\n    var a = i.arg;\n    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, \"return\" !== r.method && (r.method = \"next\", r.arg = t), r.delegate = null, y) : a : (r.method = \"throw\", r.arg = new TypeError(\"iterator result is not an object\"), r.delegate = null, y);\n  }\n  function pushTryEntry(t) {\n    var e = {\n      tryLoc: t[0]\n    };\n    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);\n  }\n  function resetTryEntry(t) {\n    var e = t.completion || {};\n    e.type = \"normal\", delete e.arg, t.completion = e;\n  }\n  function Context(t) {\n    this.tryEntries = [{\n      tryLoc: \"root\"\n    }], t.forEach(pushTryEntry, this), this.reset(!0);\n  }\n  function values(e) {\n    if (e || \"\" === e) {\n      var r = e[a];\n      if (r) return r.call(e);\n      if (\"function\" == typeof e.next) return e;\n      if (!isNaN(e.length)) {\n        var o = -1,\n          i = function next() {\n            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;\n            return next.value = t, next.done = !0, next;\n          };\n        return i.next = i;\n      }\n    }\n    throw new TypeError(_typeof(e) + \" is not iterable\");\n  }\n  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, \"constructor\", {\n    value: GeneratorFunctionPrototype,\n    configurable: !0\n  }), o(GeneratorFunctionPrototype, \"constructor\", {\n    value: GeneratorFunction,\n    configurable: !0\n  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, \"GeneratorFunction\"), e.isGeneratorFunction = function (t) {\n    var e = \"function\" == typeof t && t.constructor;\n    return !!e && (e === GeneratorFunction || \"GeneratorFunction\" === (e.displayName || e.name));\n  }, e.mark = function (t) {\n    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, \"GeneratorFunction\")), t.prototype = Object.create(g), t;\n  }, e.awrap = function (t) {\n    return {\n      __await: t\n    };\n  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {\n    return this;\n  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {\n    void 0 === i && (i = Promise);\n    var a = new AsyncIterator(wrap(t, r, n, o), i);\n    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {\n      return t.done ? t.value : a.next();\n    });\n  }, defineIteratorMethods(g), define(g, u, \"Generator\"), define(g, a, function () {\n    return this;\n  }), define(g, \"toString\", function () {\n    return \"[object Generator]\";\n  }), e.keys = function (t) {\n    var e = Object(t),\n      r = [];\n    for (var n in e) r.push(n);\n    return r.reverse(), function next() {\n      for (; r.length;) {\n        var t = r.pop();\n        if (t in e) return next.value = t, next.done = !1, next;\n      }\n      return next.done = !0, next;\n    };\n  }, e.values = values, Context.prototype = {\n    constructor: Context,\n    reset: function reset(e) {\n      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = \"next\", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) \"t\" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);\n    },\n    stop: function stop() {\n      this.done = !0;\n      var t = this.tryEntries[0].completion;\n      if (\"throw\" === t.type) throw t.arg;\n      return this.rval;\n    },\n    dispatchException: function dispatchException(e) {\n      if (this.done) throw e;\n      var r = this;\n      function handle(n, o) {\n        return a.type = \"throw\", a.arg = e, r.next = n, o && (r.method = \"next\", r.arg = t), !!o;\n      }\n      for (var o = this.tryEntries.length - 1; o >= 0; --o) {\n        var i = this.tryEntries[o],\n          a = i.completion;\n        if (\"root\" === i.tryLoc) return handle(\"end\");\n        if (i.tryLoc <= this.prev) {\n          var c = n.call(i, \"catchLoc\"),\n            u = n.call(i, \"finallyLoc\");\n          if (c && u) {\n            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);\n            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);\n          } else if (c) {\n            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);\n          } else {\n            if (!u) throw Error(\"try statement without catch or finally\");\n            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);\n          }\n        }\n      }\n    },\n    abrupt: function abrupt(t, e) {\n      for (var r = this.tryEntries.length - 1; r >= 0; --r) {\n        var o = this.tryEntries[r];\n        if (o.tryLoc <= this.prev && n.call(o, \"finallyLoc\") && this.prev < o.finallyLoc) {\n          var i = o;\n          break;\n        }\n      }\n      i && (\"break\" === t || \"continue\" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);\n      var a = i ? i.completion : {};\n      return a.type = t, a.arg = e, i ? (this.method = \"next\", this.next = i.finallyLoc, y) : this.complete(a);\n    },\n    complete: function complete(t, e) {\n      if (\"throw\" === t.type) throw t.arg;\n      return \"break\" === t.type || \"continue\" === t.type ? this.next = t.arg : \"return\" === t.type ? (this.rval = this.arg = t.arg, this.method = \"return\", this.next = \"end\") : \"normal\" === t.type && e && (this.next = e), y;\n    },\n    finish: function finish(t) {\n      for (var e = this.tryEntries.length - 1; e >= 0; --e) {\n        var r = this.tryEntries[e];\n        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;\n      }\n    },\n    \"catch\": function _catch(t) {\n      for (var e = this.tryEntries.length - 1; e >= 0; --e) {\n        var r = this.tryEntries[e];\n        if (r.tryLoc === t) {\n          var n = r.completion;\n          if (\"throw\" === n.type) {\n            var o = n.arg;\n            resetTryEntry(r);\n          }\n          return o;\n        }\n      }\n      throw Error(\"illegal catch attempt\");\n    },\n    delegateYield: function delegateYield(e, r, n) {\n      return this.delegate = {\n        iterator: values(e),\n        resultName: r,\n        nextLoc: n\n      }, \"next\" === this.method && (this.arg = t), y;\n    }\n  }, e;\n}\nmodule.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports, _typeof(o);\n}\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","import { __assign } from \"tslib\";\nimport { filterProps, getNamedFormat } from './utils';\nimport { IntlError, IntlErrorCode } from './error';\nvar DATE_TIME_FORMAT_OPTIONS = [\n    'localeMatcher',\n    'formatMatcher',\n    'timeZone',\n    'hour12',\n    'weekday',\n    'era',\n    'year',\n    'month',\n    'day',\n    'hour',\n    'minute',\n    'second',\n    'timeZoneName',\n    'hourCycle',\n    'dateStyle',\n    'timeStyle',\n    'calendar',\n    // 'dayPeriod',\n    'numberingSystem',\n];\nexport function getFormatter(_a, type, getDateTimeFormat, options) {\n    var locale = _a.locale, formats = _a.formats, onError = _a.onError, timeZone = _a.timeZone;\n    if (options === void 0) { options = {}; }\n    var format = options.format;\n    var defaults = __assign(__assign({}, (timeZone && { timeZone: timeZone })), (format && getNamedFormat(formats, type, format, onError)));\n    var filteredOptions = filterProps(options, DATE_TIME_FORMAT_OPTIONS, defaults);\n    if (type === 'time' &&\n        !filteredOptions.hour &&\n        !filteredOptions.minute &&\n        !filteredOptions.second &&\n        !filteredOptions.timeStyle &&\n        !filteredOptions.dateStyle) {\n        // Add default formatting options if hour, minute, or second isn't defined.\n        filteredOptions = __assign(__assign({}, filteredOptions), { hour: 'numeric', minute: 'numeric' });\n    }\n    return getDateTimeFormat(locale, filteredOptions);\n}\nexport function formatDate(config, getDateTimeFormat) {\n    var _a = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        _a[_i - 2] = arguments[_i];\n    }\n    var value = _a[0], _b = _a[1], options = _b === void 0 ? {} : _b;\n    var date = typeof value === 'string' ? new Date(value || 0) : value;\n    try {\n        return getFormatter(config, 'date', getDateTimeFormat, options).format(date);\n    }\n    catch (e) {\n        config.onError(new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting date.', e));\n    }\n    return String(date);\n}\nexport function formatTime(config, getDateTimeFormat) {\n    var _a = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        _a[_i - 2] = arguments[_i];\n    }\n    var value = _a[0], _b = _a[1], options = _b === void 0 ? {} : _b;\n    var date = typeof value === 'string' ? new Date(value || 0) : value;\n    try {\n        return getFormatter(config, 'time', getDateTimeFormat, options).format(date);\n    }\n    catch (e) {\n        config.onError(new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting time.', e));\n    }\n    return String(date);\n}\nexport function formatDateTimeRange(config, getDateTimeFormat) {\n    var _a = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        _a[_i - 2] = arguments[_i];\n    }\n    var from = _a[0], to = _a[1], _b = _a[2], options = _b === void 0 ? {} : _b;\n    var timeZone = config.timeZone, locale = config.locale, onError = config.onError;\n    var filteredOptions = filterProps(options, DATE_TIME_FORMAT_OPTIONS, timeZone ? { timeZone: timeZone } : {});\n    try {\n        return getDateTimeFormat(locale, filteredOptions).formatRange(from, to);\n    }\n    catch (e) {\n        onError(new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting date time range.', e));\n    }\n    return String(from);\n}\nexport function formatDateToParts(config, getDateTimeFormat) {\n    var _a = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        _a[_i - 2] = arguments[_i];\n    }\n    var value = _a[0], _b = _a[1], options = _b === void 0 ? {} : _b;\n    var date = typeof value === 'string' ? new Date(value || 0) : value;\n    try {\n        return getFormatter(config, 'date', getDateTimeFormat, options).formatToParts(date);\n    }\n    catch (e) {\n        config.onError(new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting date.', e));\n    }\n    return [];\n}\nexport function formatTimeToParts(config, getDateTimeFormat) {\n    var _a = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        _a[_i - 2] = arguments[_i];\n    }\n    var value = _a[0], _b = _a[1], options = _b === void 0 ? {} : _b;\n    var date = typeof value === 'string' ? new Date(value || 0) : value;\n    try {\n        return getFormatter(config, 'time', getDateTimeFormat, options).formatToParts(date);\n    }\n    catch (e) {\n        config.onError(new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting time.', e));\n    }\n    return [];\n}\n","export * from './date-time';\nexport * from './number';\n","import { __assign } from \"tslib\";\nimport { invariant } from '@formatjs/ecma402-abstract';\nimport { IntlMessageFormat, } from 'intl-messageformat';\nimport { MissingTranslationError, MessageFormatError } from './error';\nimport { TYPE } from '@formatjs/icu-messageformat-parser';\nfunction setTimeZoneInOptions(opts, timeZone) {\n    return Object.keys(opts).reduce(function (all, k) {\n        all[k] = __assign({ timeZone: timeZone }, opts[k]);\n        return all;\n    }, {});\n}\nfunction deepMergeOptions(opts1, opts2) {\n    var keys = Object.keys(__assign(__assign({}, opts1), opts2));\n    return keys.reduce(function (all, k) {\n        all[k] = __assign(__assign({}, (opts1[k] || {})), (opts2[k] || {}));\n        return all;\n    }, {});\n}\nfunction deepMergeFormatsAndSetTimeZone(f1, timeZone) {\n    if (!timeZone) {\n        return f1;\n    }\n    var mfFormats = IntlMessageFormat.formats;\n    return __assign(__assign(__assign({}, mfFormats), f1), { date: deepMergeOptions(setTimeZoneInOptions(mfFormats.date, timeZone), setTimeZoneInOptions(f1.date || {}, timeZone)), time: deepMergeOptions(setTimeZoneInOptions(mfFormats.time, timeZone), setTimeZoneInOptions(f1.time || {}, timeZone)) });\n}\nexport function formatMessage(_a, state, messageDescriptor, values, opts) {\n    var locale = _a.locale, formats = _a.formats, messages = _a.messages, defaultLocale = _a.defaultLocale, defaultFormats = _a.defaultFormats, fallbackOnEmptyString = _a.fallbackOnEmptyString, onError = _a.onError, timeZone = _a.timeZone, defaultRichTextElements = _a.defaultRichTextElements;\n    if (messageDescriptor === void 0) { messageDescriptor = { id: '' }; }\n    var msgId = messageDescriptor.id, defaultMessage = messageDescriptor.defaultMessage;\n    // `id` is a required field of a Message Descriptor.\n    invariant(!!msgId, \"[@formatjs/intl] An `id` must be provided to format a message. You can either:\\n1. Configure your build toolchain with [babel-plugin-formatjs](https://formatjs.io/docs/tooling/babel-plugin)\\nor [@formatjs/ts-transformer](https://formatjs.io/docs/tooling/ts-transformer) OR\\n2. Configure your `eslint` config to include [eslint-plugin-formatjs](https://formatjs.io/docs/tooling/linter#enforce-id)\\nto autofix this issue\");\n    var id = String(msgId);\n    var message = \n    // In case messages is Object.create(null)\n    // e.g import('foo.json') from webpack)\n    // See https://github.com/formatjs/formatjs/issues/1914\n    messages &&\n        Object.prototype.hasOwnProperty.call(messages, id) &&\n        messages[id];\n    // IMPORTANT: Hot path if `message` is AST with a single literal node\n    if (Array.isArray(message) &&\n        message.length === 1 &&\n        message[0].type === TYPE.literal) {\n        return message[0].value;\n    }\n    // IMPORTANT: Hot path straight lookup for performance\n    if (!values &&\n        message &&\n        typeof message === 'string' &&\n        !defaultRichTextElements) {\n        return message.replace(/'\\{(.*?)\\}'/gi, \"{$1}\");\n    }\n    values = __assign(__assign({}, defaultRichTextElements), (values || {}));\n    formats = deepMergeFormatsAndSetTimeZone(formats, timeZone);\n    defaultFormats = deepMergeFormatsAndSetTimeZone(defaultFormats, timeZone);\n    if (!message) {\n        if (fallbackOnEmptyString === false && message === '') {\n            return message;\n        }\n        if (!defaultMessage ||\n            (locale && locale.toLowerCase() !== defaultLocale.toLowerCase())) {\n            // This prevents warnings from littering the console in development\n            // when no `messages` are passed into the <IntlProvider> for the\n            // default locale.\n            onError(new MissingTranslationError(messageDescriptor, locale));\n        }\n        if (defaultMessage) {\n            try {\n                var formatter = state.getMessageFormat(defaultMessage, defaultLocale, defaultFormats, opts);\n                return formatter.format(values);\n            }\n            catch (e) {\n                onError(new MessageFormatError(\"Error formatting default message for: \\\"\".concat(id, \"\\\", rendering default message verbatim\"), locale, messageDescriptor, e));\n                return typeof defaultMessage === 'string' ? defaultMessage : id;\n            }\n        }\n        return id;\n    }\n    // We have the translated message\n    try {\n        var formatter = state.getMessageFormat(message, locale, formats, __assign({ formatters: state }, (opts || {})));\n        return formatter.format(values);\n    }\n    catch (e) {\n        onError(new MessageFormatError(\"Error formatting message: \\\"\".concat(id, \"\\\", using \").concat(defaultMessage ? 'default message' : 'id', \" as fallback.\"), locale, messageDescriptor, e));\n    }\n    if (defaultMessage) {\n        try {\n            var formatter = state.getMessageFormat(defaultMessage, defaultLocale, defaultFormats, opts);\n            return formatter.format(values);\n        }\n        catch (e) {\n            onError(new MessageFormatError(\"Error formatting the default message for: \\\"\".concat(id, \"\\\", rendering message verbatim\"), locale, messageDescriptor, e));\n        }\n    }\n    if (typeof message === 'string') {\n        return message;\n    }\n    if (typeof defaultMessage === 'string') {\n        return defaultMessage;\n    }\n    return id;\n}\n","// @generated from regex-gen.ts\nexport var SPACE_SEPARATOR_REGEX = /[ \\xA0\\u1680\\u2000-\\u200A\\u202F\\u205F\\u3000]/;\nexport var WHITE_SPACE_REGEX = /[\\t-\\r \\x85\\u200E\\u200F\\u2028\\u2029]/;\n","!function(e,r){\"object\"==typeof exports&&\"object\"==typeof module?module.exports=r():\"function\"==typeof define&&define.amd?define([],r):\"object\"==typeof exports?exports[\"omnichannel-design-system\"]=r():e[\"omnichannel-design-system\"]=r()}(this,(function(){return function(e){var r={};function n(t){if(r[t])return r[t].exports;var u=r[t]={i:t,l:!1,exports:{}};return e[t].call(u.exports,u,u.exports,n),u.l=!0,u.exports}return n.m=e,n.c=r,n.d=function(e,r,t){n.o(e,r)||Object.defineProperty(e,r,{enumerable:!0,get:t})},n.r=function(e){\"undefined\"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:\"Module\"}),Object.defineProperty(e,\"__esModule\",{value:!0})},n.t=function(e,r){if(1&r&&(e=n(e)),8&r)return e;if(4&r&&\"object\"==typeof e&&e&&e.__esModule)return e;var t=Object.create(null);if(n.r(t),Object.defineProperty(t,\"default\",{enumerable:!0,value:e}),2&r&&\"string\"!=typeof e)for(var u in e)n.d(t,u,function(r){return e[r]}.bind(null,u));return t},n.n=function(e){var r=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(r,\"a\",r),r},n.o=function(e,r){return Object.prototype.hasOwnProperty.call(e,r)},n.p=\"\",n(n.s=1)}([,function(e,r,n){\"use strict\";n.r(r),n.d(r,\"palette\",(function(){return t})),n.d(r,\"spaceUnit\",(function(){return u})),n.d(r,\"containerRowMaxWidth\",(function(){return p})),n.d(r,\"minTappableArea\",(function(){return o})),n.d(r,\"fontFamily\",(function(){return a})),n.d(r,\"fontWeight\",(function(){return i})),n.d(r,\"borderRadius\",(function(){return x})),n.d(r,\"border\",(function(){return c})),n.d(r,\"elevation\",(function(){return s})),n.d(r,\"focus\",(function(){return b})),n.d(r,\"spacing\",(function(){return m})),n.d(r,\"breakpointsMediaQueries\",(function(){return g})),n.d(r,\"touchScreenScale\",(function(){return w})),n.d(r,\"touchScreenZoom\",(function(){return h}));const t={red700:\"#cc0b15\",red800:\"#e2001a\",red900:\"#b01200\",dark:\"#262626\",white:\"#fff\",neutral800:\"#333333\",neutral700:\"#666666\",neutral500:\"#999999\",neutral400:\"#cccccc\",neutral300:\"#e5e5e5\",neutral200:\"#eeeeee\",neutral100:\"#f5f5f5\",blue800:\"#007a91\",blue600:\"#00afd0\",blue100:\"#bfebf3\",blue50:\"#f0fcfe\",success900:\"#006531\",success800:\"#148545\",success600:\"#2FA358\",success50:\"#e7f6ec\",warning800:\"#f26b08\",warning600:\"#fe8d08\",warning500:\"#fbb800\",warning50:\"#fff8e1\",error900:\"#c61811\",error800:\"#eb0000\",error700:\"#e2001a\",error400:\"#ea5c4d\",error100:\"#f6b6Bd\",error50:\"#ffe7e6\",background:\"#f6f9f9\",neutral700a20:\"rgba(102, 102, 102, 0.2)\",neutral700a70:\"rgba(102, 102, 102, 0.7)\",neutral300a80:\"rgba(229, 229, 229, 0.8)\"},u=4,p=1440,o=48,a=\"UniCredit\",i={normal:400,medium:500,bold:700},x={\"x-small\":\"2px\",small:\"4px\",medium:\"8px\",large:\"16px\",\"x-large\":\"30px\"};function l(e){return`1px solid ${t[e]}`}const c={transparent:\"1px solid transparent\",white:l(\"white\"),dark:l(\"dark\"),neutral800:l(\"neutral800\"),neutral700:l(\"neutral700\"),neutral500:l(\"neutral500\"),neutral400:l(\"neutral400\"),neutral300:l(\"neutral300\"),neutral200:l(\"neutral200\"),blue800:l(\"blue800\"),blue600:l(\"blue600\"),blue100:l(\"blue100\"),error700:l(\"error700\"),error800:l(\"error800\"),error900:l(\"error900\"),warning600:l(\"warning600\"),warning800:l(\"warning800\"),success800:l(\"success800\")};function d(e,r){return`${e}${(Math.round(r/100*255)+65536).toString(16).substr(-2).toUpperCase()}`}function f(e,r,n,t){return u=>void 0!==n&&void 0!==t?`${e} ${d(u,r)}, ${n} ${d(u,t)}`:`${e} ${d(u,r)}`}const s={xs:f(\"0px 1px 3px 0px\",5),s:f(\"0px 2px 10px 0px\",6,\"0px 1px 6px 0px\",4),m:f(\"0px 6px 10px -1px\",6,\"0px 2px 6px -1px\",6),l:f(\"0px 10px 15px -3px\",12,\"0px 4px 6px -2px\",5),up_xs:f(\"0px -1px 3px 0px\",5),up_s:f(\"0px -2px 10px 0px\",6,\"0px -1px 6px 0px\",4),up_m:f(\"0px -6px 10px -1px\",6,\"0px -2px 6px -1px\",6),up_l:f(\"0px -10px 15px -3px\",12,\"0px -4px 6px -2px\",5)},b={neutral700:s.l(t.neutral700),blue800:s.l(t.blue800),error900:s.l(t.error900),warning800:s.l(t.warning800),blue800SvgFilter:`drop-shadow(0px 10px 15px ${d(t.blue800,12)}) drop-shadow(0px 4px 6px ${d(t.blue800,5)})`,blue50:s.m(t.blue800),success50:s.m(t.success900),error50:s.m(t.error800),warning50:s.m(t.warning800)},m={\"04\":\"4px\",\"08\":\"8px\",12:\"12px\",16:\"16px\",24:\"24px\",32:\"32px\",40:\"40px\",48:\"48px\",56:\"56px\",64:\"64px\"},g={mobilePortrait:\"(max-width: 567px)\",mobileLandscape:\"(min-width: 568px) and (max-width: 767px)\",tablet:\"(min-width: 768px) and (max-width: 1023px)\",desktop:\"(min-width: 1024px) and (max-width: 1439px)\",desktopWide:\"(min-width: 1440px)\"},w=1.75,h=100*w+\"%\"}])}));","import { getNamedFormat, filterProps } from './utils';\nimport { IntlError, IntlErrorCode } from './error';\nvar NUMBER_FORMAT_OPTIONS = [\n    'localeMatcher',\n    'style',\n    'currency',\n    'currencyDisplay',\n    'unit',\n    'unitDisplay',\n    'useGrouping',\n    'minimumIntegerDigits',\n    'minimumFractionDigits',\n    'maximumFractionDigits',\n    'minimumSignificantDigits',\n    'maximumSignificantDigits',\n    // ES2020 NumberFormat\n    'compactDisplay',\n    'currencyDisplay',\n    'currencySign',\n    'notation',\n    'signDisplay',\n    'unit',\n    'unitDisplay',\n    'numberingSystem',\n];\nexport function getFormatter(_a, getNumberFormat, options) {\n    var locale = _a.locale, formats = _a.formats, onError = _a.onError;\n    if (options === void 0) { options = {}; }\n    var format = options.format;\n    var defaults = ((format &&\n        getNamedFormat(formats, 'number', format, onError)) ||\n        {});\n    var filteredOptions = filterProps(options, NUMBER_FORMAT_OPTIONS, defaults);\n    return getNumberFormat(locale, filteredOptions);\n}\nexport function formatNumber(config, getNumberFormat, value, options) {\n    if (options === void 0) { options = {}; }\n    try {\n        return getFormatter(config, getNumberFormat, options).format(value);\n    }\n    catch (e) {\n        config.onError(new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting number.', e));\n    }\n    return String(value);\n}\nexport function formatNumberToParts(config, getNumberFormat, value, options) {\n    if (options === void 0) { options = {}; }\n    try {\n        return getFormatter(config, getNumberFormat, options).formatToParts(value);\n    }\n    catch (e) {\n        config.onError(new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting number.', e));\n    }\n    return [];\n}\n","import { __assign } from \"tslib\";\nimport { filterProps } from './utils';\nimport { FormatError, ErrorCode } from 'intl-messageformat';\nimport { IntlError, IntlErrorCode } from './error';\nvar LIST_FORMAT_OPTIONS = [\n    'localeMatcher',\n    'type',\n    'style',\n];\nvar now = Date.now();\nfunction generateToken(i) {\n    return \"\".concat(now, \"_\").concat(i, \"_\").concat(now);\n}\nexport function formatList(opts, getListFormat, values, options) {\n    if (options === void 0) { options = {}; }\n    var results = formatListToParts(opts, getListFormat, values, options).reduce(function (all, el) {\n        var val = el.value;\n        if (typeof val !== 'string') {\n            all.push(val);\n        }\n        else if (typeof all[all.length - 1] === 'string') {\n            all[all.length - 1] += val;\n        }\n        else {\n            all.push(val);\n        }\n        return all;\n    }, []);\n    return results.length === 1 ? results[0] : results;\n}\nexport function formatListToParts(_a, getListFormat, values, options) {\n    var locale = _a.locale, onError = _a.onError;\n    if (options === void 0) { options = {}; }\n    var ListFormat = Intl.ListFormat;\n    if (!ListFormat) {\n        onError(new FormatError(\"Intl.ListFormat is not available in this environment.\\nTry polyfilling it using \\\"@formatjs/intl-listformat\\\"\\n\", ErrorCode.MISSING_INTL_API));\n    }\n    var filteredOptions = filterProps(options, LIST_FORMAT_OPTIONS);\n    try {\n        var richValues_1 = {};\n        var serializedValues = values.map(function (v, i) {\n            if (typeof v === 'object') {\n                var id = generateToken(i);\n                richValues_1[id] = v;\n                return id;\n            }\n            return String(v);\n        });\n        return getListFormat(locale, filteredOptions)\n            .formatToParts(serializedValues)\n            .map(function (part) {\n            return part.type === 'literal'\n                ? part\n                : __assign(__assign({}, part), { value: richValues_1[part.value] || part.value });\n        });\n    }\n    catch (e) {\n        onError(new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting list.', e));\n    }\n    // @ts-ignore\n    return values;\n}\n","/**\n * https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table\n * Credit: https://github.com/caridy/intl-datetimeformat-pattern/blob/master/index.js\n * with some tweaks\n */\nvar DATE_TIME_REGEX = /(?:[Eec]{1,6}|G{1,5}|[Qq]{1,5}|(?:[yYur]+|U{1,5})|[ML]{1,5}|d{1,2}|D{1,3}|F{1}|[abB]{1,5}|[hkHK]{1,2}|w{1,2}|W{1}|m{1,2}|s{1,2}|[zZOvVxX]{1,4})(?=([^']*'[^']*')*[^']*$)/g;\n/**\n * Parse Date time skeleton into Intl.DateTimeFormatOptions\n * Ref: https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table\n * @public\n * @param skeleton skeleton string\n */\nexport function parseDateTimeSkeleton(skeleton) {\n    var result = {};\n    skeleton.replace(DATE_TIME_REGEX, function (match) {\n        var len = match.length;\n        switch (match[0]) {\n            // Era\n            case 'G':\n                result.era = len === 4 ? 'long' : len === 5 ? 'narrow' : 'short';\n                break;\n            // Year\n            case 'y':\n                result.year = len === 2 ? '2-digit' : 'numeric';\n                break;\n            case 'Y':\n            case 'u':\n            case 'U':\n            case 'r':\n                throw new RangeError('`Y/u/U/r` (year) patterns are not supported, use `y` instead');\n            // Quarter\n            case 'q':\n            case 'Q':\n                throw new RangeError('`q/Q` (quarter) patterns are not supported');\n            // Month\n            case 'M':\n            case 'L':\n                result.month = ['numeric', '2-digit', 'short', 'long', 'narrow'][len - 1];\n                break;\n            // Week\n            case 'w':\n            case 'W':\n                throw new RangeError('`w/W` (week) patterns are not supported');\n            case 'd':\n                result.day = ['numeric', '2-digit'][len - 1];\n                break;\n            case 'D':\n            case 'F':\n            case 'g':\n                throw new RangeError('`D/F/g` (day) patterns are not supported, use `d` instead');\n            // Weekday\n            case 'E':\n                result.weekday = len === 4 ? 'short' : len === 5 ? 'narrow' : 'short';\n                break;\n            case 'e':\n                if (len < 4) {\n                    throw new RangeError('`e..eee` (weekday) patterns are not supported');\n                }\n                result.weekday = ['short', 'long', 'narrow', 'short'][len - 4];\n                break;\n            case 'c':\n                if (len < 4) {\n                    throw new RangeError('`c..ccc` (weekday) patterns are not supported');\n                }\n                result.weekday = ['short', 'long', 'narrow', 'short'][len - 4];\n                break;\n            // Period\n            case 'a': // AM, PM\n                result.hour12 = true;\n                break;\n            case 'b': // am, pm, noon, midnight\n            case 'B': // flexible day periods\n                throw new RangeError('`b/B` (period) patterns are not supported, use `a` instead');\n            // Hour\n            case 'h':\n                result.hourCycle = 'h12';\n                result.hour = ['numeric', '2-digit'][len - 1];\n                break;\n            case 'H':\n                result.hourCycle = 'h23';\n                result.hour = ['numeric', '2-digit'][len - 1];\n                break;\n            case 'K':\n                result.hourCycle = 'h11';\n                result.hour = ['numeric', '2-digit'][len - 1];\n                break;\n            case 'k':\n                result.hourCycle = 'h24';\n                result.hour = ['numeric', '2-digit'][len - 1];\n                break;\n            case 'j':\n            case 'J':\n            case 'C':\n                throw new RangeError('`j/J/C` (hour) patterns are not supported, use `h/H/K/k` instead');\n            // Minute\n            case 'm':\n                result.minute = ['numeric', '2-digit'][len - 1];\n                break;\n            // Second\n            case 's':\n                result.second = ['numeric', '2-digit'][len - 1];\n                break;\n            case 'S':\n            case 'A':\n                throw new RangeError('`S/A` (second) patterns are not supported, use `s` instead');\n            // Zone\n            case 'z': // 1..3, 4: specific non-location format\n                result.timeZoneName = len < 4 ? 'short' : 'long';\n                break;\n            case 'Z': // 1..3, 4, 5: The ISO8601 varios formats\n            case 'O': // 1, 4: miliseconds in day short, long\n            case 'v': // 1, 4: generic non-location format\n            case 'V': // 1, 2, 3, 4: time zone ID or city\n            case 'X': // 1, 2, 3, 4: The ISO8601 varios formats\n            case 'x': // 1, 2, 3, 4: The ISO8601 varios formats\n                throw new RangeError('`Z/O/v/V/X/x` (timeZone) patterns are not supported, use `z` instead');\n        }\n        return '';\n    });\n    return result;\n}\n","import { __assign } from \"tslib\";\nimport { WHITE_SPACE_REGEX } from './regex.generated';\nexport function parseNumberSkeletonFromString(skeleton) {\n    if (skeleton.length === 0) {\n        throw new Error('Number skeleton cannot be empty');\n    }\n    // Parse the skeleton\n    var stringTokens = skeleton\n        .split(WHITE_SPACE_REGEX)\n        .filter(function (x) { return x.length > 0; });\n    var tokens = [];\n    for (var _i = 0, stringTokens_1 = stringTokens; _i < stringTokens_1.length; _i++) {\n        var stringToken = stringTokens_1[_i];\n        var stemAndOptions = stringToken.split('/');\n        if (stemAndOptions.length === 0) {\n            throw new Error('Invalid number skeleton');\n        }\n        var stem = stemAndOptions[0], options = stemAndOptions.slice(1);\n        for (var _a = 0, options_1 = options; _a < options_1.length; _a++) {\n            var option = options_1[_a];\n            if (option.length === 0) {\n                throw new Error('Invalid number skeleton');\n            }\n        }\n        tokens.push({ stem: stem, options: options });\n    }\n    return tokens;\n}\nfunction icuUnitToEcma(unit) {\n    return unit.replace(/^(.*?)-/, '');\n}\nvar FRACTION_PRECISION_REGEX = /^\\.(?:(0+)(\\*)?|(#+)|(0+)(#+))$/g;\nvar SIGNIFICANT_PRECISION_REGEX = /^(@+)?(\\+|#+)?[rs]?$/g;\nvar INTEGER_WIDTH_REGEX = /(\\*)(0+)|(#+)(0+)|(0+)/g;\nvar CONCISE_INTEGER_WIDTH_REGEX = /^(0+)$/;\nfunction parseSignificantPrecision(str) {\n    var result = {};\n    if (str[str.length - 1] === 'r') {\n        result.roundingPriority = 'morePrecision';\n    }\n    else if (str[str.length - 1] === 's') {\n        result.roundingPriority = 'lessPrecision';\n    }\n    str.replace(SIGNIFICANT_PRECISION_REGEX, function (_, g1, g2) {\n        // @@@ case\n        if (typeof g2 !== 'string') {\n            result.minimumSignificantDigits = g1.length;\n            result.maximumSignificantDigits = g1.length;\n        }\n        // @@@+ case\n        else if (g2 === '+') {\n            result.minimumSignificantDigits = g1.length;\n        }\n        // .### case\n        else if (g1[0] === '#') {\n            result.maximumSignificantDigits = g1.length;\n        }\n        // .@@## or .@@@ case\n        else {\n            result.minimumSignificantDigits = g1.length;\n            result.maximumSignificantDigits =\n                g1.length + (typeof g2 === 'string' ? g2.length : 0);\n        }\n        return '';\n    });\n    return result;\n}\nfunction parseSign(str) {\n    switch (str) {\n        case 'sign-auto':\n            return {\n                signDisplay: 'auto',\n            };\n        case 'sign-accounting':\n        case '()':\n            return {\n                currencySign: 'accounting',\n            };\n        case 'sign-always':\n        case '+!':\n            return {\n                signDisplay: 'always',\n            };\n        case 'sign-accounting-always':\n        case '()!':\n            return {\n                signDisplay: 'always',\n                currencySign: 'accounting',\n            };\n        case 'sign-except-zero':\n        case '+?':\n            return {\n                signDisplay: 'exceptZero',\n            };\n        case 'sign-accounting-except-zero':\n        case '()?':\n            return {\n                signDisplay: 'exceptZero',\n                currencySign: 'accounting',\n            };\n        case 'sign-never':\n        case '+_':\n            return {\n                signDisplay: 'never',\n            };\n    }\n}\nfunction parseConciseScientificAndEngineeringStem(stem) {\n    // Engineering\n    var result;\n    if (stem[0] === 'E' && stem[1] === 'E') {\n        result = {\n            notation: 'engineering',\n        };\n        stem = stem.slice(2);\n    }\n    else if (stem[0] === 'E') {\n        result = {\n            notation: 'scientific',\n        };\n        stem = stem.slice(1);\n    }\n    if (result) {\n        var signDisplay = stem.slice(0, 2);\n        if (signDisplay === '+!') {\n            result.signDisplay = 'always';\n            stem = stem.slice(2);\n        }\n        else if (signDisplay === '+?') {\n            result.signDisplay = 'exceptZero';\n            stem = stem.slice(2);\n        }\n        if (!CONCISE_INTEGER_WIDTH_REGEX.test(stem)) {\n            throw new Error('Malformed concise eng/scientific notation');\n        }\n        result.minimumIntegerDigits = stem.length;\n    }\n    return result;\n}\nfunction parseNotationOptions(opt) {\n    var result = {};\n    var signOpts = parseSign(opt);\n    if (signOpts) {\n        return signOpts;\n    }\n    return result;\n}\n/**\n * https://github.com/unicode-org/icu/blob/master/docs/userguide/format_parse/numbers/skeletons.md#skeleton-stems-and-options\n */\nexport function parseNumberSkeleton(tokens) {\n    var result = {};\n    for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {\n        var token = tokens_1[_i];\n        switch (token.stem) {\n            case 'percent':\n            case '%':\n                result.style = 'percent';\n                continue;\n            case '%x100':\n                result.style = 'percent';\n                result.scale = 100;\n                continue;\n            case 'currency':\n                result.style = 'currency';\n                result.currency = token.options[0];\n                continue;\n            case 'group-off':\n            case ',_':\n                result.useGrouping = false;\n                continue;\n            case 'precision-integer':\n            case '.':\n                result.maximumFractionDigits = 0;\n                continue;\n            case 'measure-unit':\n            case 'unit':\n                result.style = 'unit';\n                result.unit = icuUnitToEcma(token.options[0]);\n                continue;\n            case 'compact-short':\n            case 'K':\n                result.notation = 'compact';\n                result.compactDisplay = 'short';\n                continue;\n            case 'compact-long':\n            case 'KK':\n                result.notation = 'compact';\n                result.compactDisplay = 'long';\n                continue;\n            case 'scientific':\n                result = __assign(__assign(__assign({}, result), { notation: 'scientific' }), token.options.reduce(function (all, opt) { return (__assign(__assign({}, all), parseNotationOptions(opt))); }, {}));\n                continue;\n            case 'engineering':\n                result = __assign(__assign(__assign({}, result), { notation: 'engineering' }), token.options.reduce(function (all, opt) { return (__assign(__assign({}, all), parseNotationOptions(opt))); }, {}));\n                continue;\n            case 'notation-simple':\n                result.notation = 'standard';\n                continue;\n            // https://github.com/unicode-org/icu/blob/master/icu4c/source/i18n/unicode/unumberformatter.h\n            case 'unit-width-narrow':\n                result.currencyDisplay = 'narrowSymbol';\n                result.unitDisplay = 'narrow';\n                continue;\n            case 'unit-width-short':\n                result.currencyDisplay = 'code';\n                result.unitDisplay = 'short';\n                continue;\n            case 'unit-width-full-name':\n                result.currencyDisplay = 'name';\n                result.unitDisplay = 'long';\n                continue;\n            case 'unit-width-iso-code':\n                result.currencyDisplay = 'symbol';\n                continue;\n            case 'scale':\n                result.scale = parseFloat(token.options[0]);\n                continue;\n            // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#integer-width\n            case 'integer-width':\n                if (token.options.length > 1) {\n                    throw new RangeError('integer-width stems only accept a single optional option');\n                }\n                token.options[0].replace(INTEGER_WIDTH_REGEX, function (_, g1, g2, g3, g4, g5) {\n                    if (g1) {\n                        result.minimumIntegerDigits = g2.length;\n                    }\n                    else if (g3 && g4) {\n                        throw new Error('We currently do not support maximum integer digits');\n                    }\n                    else if (g5) {\n                        throw new Error('We currently do not support exact integer digits');\n                    }\n                    return '';\n                });\n                continue;\n        }\n        // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#integer-width\n        if (CONCISE_INTEGER_WIDTH_REGEX.test(token.stem)) {\n            result.minimumIntegerDigits = token.stem.length;\n            continue;\n        }\n        if (FRACTION_PRECISION_REGEX.test(token.stem)) {\n            // Precision\n            // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#fraction-precision\n            // precision-integer case\n            if (token.options.length > 1) {\n                throw new RangeError('Fraction-precision stems only accept a single optional option');\n            }\n            token.stem.replace(FRACTION_PRECISION_REGEX, function (_, g1, g2, g3, g4, g5) {\n                // .000* case (before ICU67 it was .000+)\n                if (g2 === '*') {\n                    result.minimumFractionDigits = g1.length;\n                }\n                // .### case\n                else if (g3 && g3[0] === '#') {\n                    result.maximumFractionDigits = g3.length;\n                }\n                // .00## case\n                else if (g4 && g5) {\n                    result.minimumFractionDigits = g4.length;\n                    result.maximumFractionDigits = g4.length + g5.length;\n                }\n                else {\n                    result.minimumFractionDigits = g1.length;\n                    result.maximumFractionDigits = g1.length;\n                }\n                return '';\n            });\n            var opt = token.options[0];\n            // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#trailing-zero-display\n            if (opt === 'w') {\n                result = __assign(__assign({}, result), { trailingZeroDisplay: 'stripIfInteger' });\n            }\n            else if (opt) {\n                result = __assign(__assign({}, result), parseSignificantPrecision(opt));\n            }\n            continue;\n        }\n        // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#significant-digits-precision\n        if (SIGNIFICANT_PRECISION_REGEX.test(token.stem)) {\n            result = __assign(__assign({}, result), parseSignificantPrecision(token.stem));\n            continue;\n        }\n        var signOpts = parseSign(token.stem);\n        if (signOpts) {\n            result = __assign(__assign({}, result), signOpts);\n        }\n        var conciseScientificAndEngineeringOpts = parseConciseScientificAndEngineeringStem(token.stem);\n        if (conciseScientificAndEngineeringOpts) {\n            result = __assign(__assign({}, result), conciseScientificAndEngineeringOpts);\n        }\n    }\n    return result;\n}\n","var _a;\nimport { __assign } from \"tslib\";\nimport { ErrorKind } from './error';\nimport { SKELETON_TYPE, TYPE, } from './types';\nimport { SPACE_SEPARATOR_REGEX } from './regex.generated';\nimport { parseNumberSkeleton, parseNumberSkeletonFromString, parseDateTimeSkeleton, } from '@formatjs/icu-skeleton-parser';\nvar SPACE_SEPARATOR_START_REGEX = new RegExp(\"^\".concat(SPACE_SEPARATOR_REGEX.source, \"*\"));\nvar SPACE_SEPARATOR_END_REGEX = new RegExp(\"\".concat(SPACE_SEPARATOR_REGEX.source, \"*$\"));\nfunction createLocation(start, end) {\n    return { start: start, end: end };\n}\n// #region Ponyfills\n// Consolidate these variables up top for easier toggling during debugging\nvar hasNativeStartsWith = !!String.prototype.startsWith;\nvar hasNativeFromCodePoint = !!String.fromCodePoint;\nvar hasNativeFromEntries = !!Object.fromEntries;\nvar hasNativeCodePointAt = !!String.prototype.codePointAt;\nvar hasTrimStart = !!String.prototype.trimStart;\nvar hasTrimEnd = !!String.prototype.trimEnd;\nvar hasNativeIsSafeInteger = !!Number.isSafeInteger;\nvar isSafeInteger = hasNativeIsSafeInteger\n    ? Number.isSafeInteger\n    : function (n) {\n        return (typeof n === 'number' &&\n            isFinite(n) &&\n            Math.floor(n) === n &&\n            Math.abs(n) <= 0x1fffffffffffff);\n    };\n// IE11 does not support y and u.\nvar REGEX_SUPPORTS_U_AND_Y = true;\ntry {\n    var re = RE('([^\\\\p{White_Space}\\\\p{Pattern_Syntax}]*)', 'yu');\n    /**\n     * legacy Edge or Xbox One browser\n     * Unicode flag support: supported\n     * Pattern_Syntax support: not supported\n     * See https://github.com/formatjs/formatjs/issues/2822\n     */\n    REGEX_SUPPORTS_U_AND_Y = ((_a = re.exec('a')) === null || _a === void 0 ? void 0 : _a[0]) === 'a';\n}\ncatch (_) {\n    REGEX_SUPPORTS_U_AND_Y = false;\n}\nvar startsWith = hasNativeStartsWith\n    ? // Native\n        function startsWith(s, search, position) {\n            return s.startsWith(search, position);\n        }\n    : // For IE11\n        function startsWith(s, search, position) {\n            return s.slice(position, position + search.length) === search;\n        };\nvar fromCodePoint = hasNativeFromCodePoint\n    ? String.fromCodePoint\n    : // IE11\n        function fromCodePoint() {\n            var codePoints = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                codePoints[_i] = arguments[_i];\n            }\n            var elements = '';\n            var length = codePoints.length;\n            var i = 0;\n            var code;\n            while (length > i) {\n                code = codePoints[i++];\n                if (code > 0x10ffff)\n                    throw RangeError(code + ' is not a valid code point');\n                elements +=\n                    code < 0x10000\n                        ? String.fromCharCode(code)\n                        : String.fromCharCode(((code -= 0x10000) >> 10) + 0xd800, (code % 0x400) + 0xdc00);\n            }\n            return elements;\n        };\nvar fromEntries = \n// native\nhasNativeFromEntries\n    ? Object.fromEntries\n    : // Ponyfill\n        function fromEntries(entries) {\n            var obj = {};\n            for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n                var _a = entries_1[_i], k = _a[0], v = _a[1];\n                obj[k] = v;\n            }\n            return obj;\n        };\nvar codePointAt = hasNativeCodePointAt\n    ? // Native\n        function codePointAt(s, index) {\n            return s.codePointAt(index);\n        }\n    : // IE 11\n        function codePointAt(s, index) {\n            var size = s.length;\n            if (index < 0 || index >= size) {\n                return undefined;\n            }\n            var first = s.charCodeAt(index);\n            var second;\n            return first < 0xd800 ||\n                first > 0xdbff ||\n                index + 1 === size ||\n                (second = s.charCodeAt(index + 1)) < 0xdc00 ||\n                second > 0xdfff\n                ? first\n                : ((first - 0xd800) << 10) + (second - 0xdc00) + 0x10000;\n        };\nvar trimStart = hasTrimStart\n    ? // Native\n        function trimStart(s) {\n            return s.trimStart();\n        }\n    : // Ponyfill\n        function trimStart(s) {\n            return s.replace(SPACE_SEPARATOR_START_REGEX, '');\n        };\nvar trimEnd = hasTrimEnd\n    ? // Native\n        function trimEnd(s) {\n            return s.trimEnd();\n        }\n    : // Ponyfill\n        function trimEnd(s) {\n            return s.replace(SPACE_SEPARATOR_END_REGEX, '');\n        };\n// Prevent minifier to translate new RegExp to literal form that might cause syntax error on IE11.\nfunction RE(s, flag) {\n    return new RegExp(s, flag);\n}\n// #endregion\nvar matchIdentifierAtIndex;\nif (REGEX_SUPPORTS_U_AND_Y) {\n    // Native\n    var IDENTIFIER_PREFIX_RE_1 = RE('([^\\\\p{White_Space}\\\\p{Pattern_Syntax}]*)', 'yu');\n    matchIdentifierAtIndex = function matchIdentifierAtIndex(s, index) {\n        var _a;\n        IDENTIFIER_PREFIX_RE_1.lastIndex = index;\n        var match = IDENTIFIER_PREFIX_RE_1.exec(s);\n        return (_a = match[1]) !== null && _a !== void 0 ? _a : '';\n    };\n}\nelse {\n    // IE11\n    matchIdentifierAtIndex = function matchIdentifierAtIndex(s, index) {\n        var match = [];\n        while (true) {\n            var c = codePointAt(s, index);\n            if (c === undefined || _isWhiteSpace(c) || _isPatternSyntax(c)) {\n                break;\n            }\n            match.push(c);\n            index += c >= 0x10000 ? 2 : 1;\n        }\n        return fromCodePoint.apply(void 0, match);\n    };\n}\nvar Parser = /** @class */ (function () {\n    function Parser(message, options) {\n        if (options === void 0) { options = {}; }\n        this.message = message;\n        this.position = { offset: 0, line: 1, column: 1 };\n        this.ignoreTag = !!options.ignoreTag;\n        this.requiresOtherClause = !!options.requiresOtherClause;\n        this.shouldParseSkeletons = !!options.shouldParseSkeletons;\n    }\n    Parser.prototype.parse = function () {\n        if (this.offset() !== 0) {\n            throw Error('parser can only be used once');\n        }\n        return this.parseMessage(0, '', false);\n    };\n    Parser.prototype.parseMessage = function (nestingLevel, parentArgType, expectingCloseTag) {\n        var elements = [];\n        while (!this.isEOF()) {\n            var char = this.char();\n            if (char === 123 /* `{` */) {\n                var result = this.parseArgument(nestingLevel, expectingCloseTag);\n                if (result.err) {\n                    return result;\n                }\n                elements.push(result.val);\n            }\n            else if (char === 125 /* `}` */ && nestingLevel > 0) {\n                break;\n            }\n            else if (char === 35 /* `#` */ &&\n                (parentArgType === 'plural' || parentArgType === 'selectordinal')) {\n                var position = this.clonePosition();\n                this.bump();\n                elements.push({\n                    type: TYPE.pound,\n                    location: createLocation(position, this.clonePosition()),\n                });\n            }\n            else if (char === 60 /* `<` */ &&\n                !this.ignoreTag &&\n                this.peek() === 47 // char code for '/'\n            ) {\n                if (expectingCloseTag) {\n                    break;\n                }\n                else {\n                    return this.error(ErrorKind.UNMATCHED_CLOSING_TAG, createLocation(this.clonePosition(), this.clonePosition()));\n                }\n            }\n            else if (char === 60 /* `<` */ &&\n                !this.ignoreTag &&\n                _isAlpha(this.peek() || 0)) {\n                var result = this.parseTag(nestingLevel, parentArgType);\n                if (result.err) {\n                    return result;\n                }\n                elements.push(result.val);\n            }\n            else {\n                var result = this.parseLiteral(nestingLevel, parentArgType);\n                if (result.err) {\n                    return result;\n                }\n                elements.push(result.val);\n            }\n        }\n        return { val: elements, err: null };\n    };\n    /**\n     * A tag name must start with an ASCII lower/upper case letter. The grammar is based on the\n     * [custom element name][] except that a dash is NOT always mandatory and uppercase letters\n     * are accepted:\n     *\n     * ```\n     * tag ::= \"<\" tagName (whitespace)* \"/>\" | \"<\" tagName (whitespace)* \">\" message \"</\" tagName (whitespace)* \">\"\n     * tagName ::= [a-z] (PENChar)*\n     * PENChar ::=\n     *     \"-\" | \".\" | [0-9] | \"_\" | [a-z] | [A-Z] | #xB7 | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x37D] |\n     *     [#x37F-#x1FFF] | [#x200C-#x200D] | [#x203F-#x2040] | [#x2070-#x218F] | [#x2C00-#x2FEF] |\n     *     [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]\n     * ```\n     *\n     * [custom element name]: https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name\n     * NOTE: We're a bit more lax here since HTML technically does not allow uppercase HTML element but we do\n     * since other tag-based engines like React allow it\n     */\n    Parser.prototype.parseTag = function (nestingLevel, parentArgType) {\n        var startPosition = this.clonePosition();\n        this.bump(); // `<`\n        var tagName = this.parseTagName();\n        this.bumpSpace();\n        if (this.bumpIf('/>')) {\n            // Self closing tag\n            return {\n                val: {\n                    type: TYPE.literal,\n                    value: \"<\".concat(tagName, \"/>\"),\n                    location: createLocation(startPosition, this.clonePosition()),\n                },\n                err: null,\n            };\n        }\n        else if (this.bumpIf('>')) {\n            var childrenResult = this.parseMessage(nestingLevel + 1, parentArgType, true);\n            if (childrenResult.err) {\n                return childrenResult;\n            }\n            var children = childrenResult.val;\n            // Expecting a close tag\n            var endTagStartPosition = this.clonePosition();\n            if (this.bumpIf('</')) {\n                if (this.isEOF() || !_isAlpha(this.char())) {\n                    return this.error(ErrorKind.INVALID_TAG, createLocation(endTagStartPosition, this.clonePosition()));\n                }\n                var closingTagNameStartPosition = this.clonePosition();\n                var closingTagName = this.parseTagName();\n                if (tagName !== closingTagName) {\n                    return this.error(ErrorKind.UNMATCHED_CLOSING_TAG, createLocation(closingTagNameStartPosition, this.clonePosition()));\n                }\n                this.bumpSpace();\n                if (!this.bumpIf('>')) {\n                    return this.error(ErrorKind.INVALID_TAG, createLocation(endTagStartPosition, this.clonePosition()));\n                }\n                return {\n                    val: {\n                        type: TYPE.tag,\n                        value: tagName,\n                        children: children,\n                        location: createLocation(startPosition, this.clonePosition()),\n                    },\n                    err: null,\n                };\n            }\n            else {\n                return this.error(ErrorKind.UNCLOSED_TAG, createLocation(startPosition, this.clonePosition()));\n            }\n        }\n        else {\n            return this.error(ErrorKind.INVALID_TAG, createLocation(startPosition, this.clonePosition()));\n        }\n    };\n    /**\n     * This method assumes that the caller has peeked ahead for the first tag character.\n     */\n    Parser.prototype.parseTagName = function () {\n        var startOffset = this.offset();\n        this.bump(); // the first tag name character\n        while (!this.isEOF() && _isPotentialElementNameChar(this.char())) {\n            this.bump();\n        }\n        return this.message.slice(startOffset, this.offset());\n    };\n    Parser.prototype.parseLiteral = function (nestingLevel, parentArgType) {\n        var start = this.clonePosition();\n        var value = '';\n        while (true) {\n            var parseQuoteResult = this.tryParseQuote(parentArgType);\n            if (parseQuoteResult) {\n                value += parseQuoteResult;\n                continue;\n            }\n            var parseUnquotedResult = this.tryParseUnquoted(nestingLevel, parentArgType);\n            if (parseUnquotedResult) {\n                value += parseUnquotedResult;\n                continue;\n            }\n            var parseLeftAngleResult = this.tryParseLeftAngleBracket();\n            if (parseLeftAngleResult) {\n                value += parseLeftAngleResult;\n                continue;\n            }\n            break;\n        }\n        var location = createLocation(start, this.clonePosition());\n        return {\n            val: { type: TYPE.literal, value: value, location: location },\n            err: null,\n        };\n    };\n    Parser.prototype.tryParseLeftAngleBracket = function () {\n        if (!this.isEOF() &&\n            this.char() === 60 /* `<` */ &&\n            (this.ignoreTag ||\n                // If at the opening tag or closing tag position, bail.\n                !_isAlphaOrSlash(this.peek() || 0))) {\n            this.bump(); // `<`\n            return '<';\n        }\n        return null;\n    };\n    /**\n     * Starting with ICU 4.8, an ASCII apostrophe only starts quoted text if it immediately precedes\n     * a character that requires quoting (that is, \"only where needed\"), and works the same in\n     * nested messages as on the top level of the pattern. The new behavior is otherwise compatible.\n     */\n    Parser.prototype.tryParseQuote = function (parentArgType) {\n        if (this.isEOF() || this.char() !== 39 /* `'` */) {\n            return null;\n        }\n        // Parse escaped char following the apostrophe, or early return if there is no escaped char.\n        // Check if is valid escaped character\n        switch (this.peek()) {\n            case 39 /* `'` */:\n                // double quote, should return as a single quote.\n                this.bump();\n                this.bump();\n                return \"'\";\n            // '{', '<', '>', '}'\n            case 123:\n            case 60:\n            case 62:\n            case 125:\n                break;\n            case 35: // '#'\n                if (parentArgType === 'plural' || parentArgType === 'selectordinal') {\n                    break;\n                }\n                return null;\n            default:\n                return null;\n        }\n        this.bump(); // apostrophe\n        var codePoints = [this.char()]; // escaped char\n        this.bump();\n        // read chars until the optional closing apostrophe is found\n        while (!this.isEOF()) {\n            var ch = this.char();\n            if (ch === 39 /* `'` */) {\n                if (this.peek() === 39 /* `'` */) {\n                    codePoints.push(39);\n                    // Bump one more time because we need to skip 2 characters.\n                    this.bump();\n                }\n                else {\n                    // Optional closing apostrophe.\n                    this.bump();\n                    break;\n                }\n            }\n            else {\n                codePoints.push(ch);\n            }\n            this.bump();\n        }\n        return fromCodePoint.apply(void 0, codePoints);\n    };\n    Parser.prototype.tryParseUnquoted = function (nestingLevel, parentArgType) {\n        if (this.isEOF()) {\n            return null;\n        }\n        var ch = this.char();\n        if (ch === 60 /* `<` */ ||\n            ch === 123 /* `{` */ ||\n            (ch === 35 /* `#` */ &&\n                (parentArgType === 'plural' || parentArgType === 'selectordinal')) ||\n            (ch === 125 /* `}` */ && nestingLevel > 0)) {\n            return null;\n        }\n        else {\n            this.bump();\n            return fromCodePoint(ch);\n        }\n    };\n    Parser.prototype.parseArgument = function (nestingLevel, expectingCloseTag) {\n        var openingBracePosition = this.clonePosition();\n        this.bump(); // `{`\n        this.bumpSpace();\n        if (this.isEOF()) {\n            return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));\n        }\n        if (this.char() === 125 /* `}` */) {\n            this.bump();\n            return this.error(ErrorKind.EMPTY_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));\n        }\n        // argument name\n        var value = this.parseIdentifierIfPossible().value;\n        if (!value) {\n            return this.error(ErrorKind.MALFORMED_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));\n        }\n        this.bumpSpace();\n        if (this.isEOF()) {\n            return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));\n        }\n        switch (this.char()) {\n            // Simple argument: `{name}`\n            case 125 /* `}` */: {\n                this.bump(); // `}`\n                return {\n                    val: {\n                        type: TYPE.argument,\n                        // value does not include the opening and closing braces.\n                        value: value,\n                        location: createLocation(openingBracePosition, this.clonePosition()),\n                    },\n                    err: null,\n                };\n            }\n            // Argument with options: `{name, format, ...}`\n            case 44 /* `,` */: {\n                this.bump(); // `,`\n                this.bumpSpace();\n                if (this.isEOF()) {\n                    return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));\n                }\n                return this.parseArgumentOptions(nestingLevel, expectingCloseTag, value, openingBracePosition);\n            }\n            default:\n                return this.error(ErrorKind.MALFORMED_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));\n        }\n    };\n    /**\n     * Advance the parser until the end of the identifier, if it is currently on\n     * an identifier character. Return an empty string otherwise.\n     */\n    Parser.prototype.parseIdentifierIfPossible = function () {\n        var startingPosition = this.clonePosition();\n        var startOffset = this.offset();\n        var value = matchIdentifierAtIndex(this.message, startOffset);\n        var endOffset = startOffset + value.length;\n        this.bumpTo(endOffset);\n        var endPosition = this.clonePosition();\n        var location = createLocation(startingPosition, endPosition);\n        return { value: value, location: location };\n    };\n    Parser.prototype.parseArgumentOptions = function (nestingLevel, expectingCloseTag, value, openingBracePosition) {\n        var _a;\n        // Parse this range:\n        // {name, type, style}\n        //        ^---^\n        var typeStartPosition = this.clonePosition();\n        var argType = this.parseIdentifierIfPossible().value;\n        var typeEndPosition = this.clonePosition();\n        switch (argType) {\n            case '':\n                // Expecting a style string number, date, time, plural, selectordinal, or select.\n                return this.error(ErrorKind.EXPECT_ARGUMENT_TYPE, createLocation(typeStartPosition, typeEndPosition));\n            case 'number':\n            case 'date':\n            case 'time': {\n                // Parse this range:\n                // {name, number, style}\n                //              ^-------^\n                this.bumpSpace();\n                var styleAndLocation = null;\n                if (this.bumpIf(',')) {\n                    this.bumpSpace();\n                    var styleStartPosition = this.clonePosition();\n                    var result = this.parseSimpleArgStyleIfPossible();\n                    if (result.err) {\n                        return result;\n                    }\n                    var style = trimEnd(result.val);\n                    if (style.length === 0) {\n                        return this.error(ErrorKind.EXPECT_ARGUMENT_STYLE, createLocation(this.clonePosition(), this.clonePosition()));\n                    }\n                    var styleLocation = createLocation(styleStartPosition, this.clonePosition());\n                    styleAndLocation = { style: style, styleLocation: styleLocation };\n                }\n                var argCloseResult = this.tryParseArgumentClose(openingBracePosition);\n                if (argCloseResult.err) {\n                    return argCloseResult;\n                }\n                var location_1 = createLocation(openingBracePosition, this.clonePosition());\n                // Extract style or skeleton\n                if (styleAndLocation && startsWith(styleAndLocation === null || styleAndLocation === void 0 ? void 0 : styleAndLocation.style, '::', 0)) {\n                    // Skeleton starts with `::`.\n                    var skeleton = trimStart(styleAndLocation.style.slice(2));\n                    if (argType === 'number') {\n                        var result = this.parseNumberSkeletonFromString(skeleton, styleAndLocation.styleLocation);\n                        if (result.err) {\n                            return result;\n                        }\n                        return {\n                            val: { type: TYPE.number, value: value, location: location_1, style: result.val },\n                            err: null,\n                        };\n                    }\n                    else {\n                        if (skeleton.length === 0) {\n                            return this.error(ErrorKind.EXPECT_DATE_TIME_SKELETON, location_1);\n                        }\n                        var style = {\n                            type: SKELETON_TYPE.dateTime,\n                            pattern: skeleton,\n                            location: styleAndLocation.styleLocation,\n                            parsedOptions: this.shouldParseSkeletons\n                                ? parseDateTimeSkeleton(skeleton)\n                                : {},\n                        };\n                        var type = argType === 'date' ? TYPE.date : TYPE.time;\n                        return {\n                            val: { type: type, value: value, location: location_1, style: style },\n                            err: null,\n                        };\n                    }\n                }\n                // Regular style or no style.\n                return {\n                    val: {\n                        type: argType === 'number'\n                            ? TYPE.number\n                            : argType === 'date'\n                                ? TYPE.date\n                                : TYPE.time,\n                        value: value,\n                        location: location_1,\n                        style: (_a = styleAndLocation === null || styleAndLocation === void 0 ? void 0 : styleAndLocation.style) !== null && _a !== void 0 ? _a : null,\n                    },\n                    err: null,\n                };\n            }\n            case 'plural':\n            case 'selectordinal':\n            case 'select': {\n                // Parse this range:\n                // {name, plural, options}\n                //              ^---------^\n                var typeEndPosition_1 = this.clonePosition();\n                this.bumpSpace();\n                if (!this.bumpIf(',')) {\n                    return this.error(ErrorKind.EXPECT_SELECT_ARGUMENT_OPTIONS, createLocation(typeEndPosition_1, __assign({}, typeEndPosition_1)));\n                }\n                this.bumpSpace();\n                // Parse offset:\n                // {name, plural, offset:1, options}\n                //                ^-----^\n                //\n                // or the first option:\n                //\n                // {name, plural, one {...} other {...}}\n                //                ^--^\n                var identifierAndLocation = this.parseIdentifierIfPossible();\n                var pluralOffset = 0;\n                if (argType !== 'select' && identifierAndLocation.value === 'offset') {\n                    if (!this.bumpIf(':')) {\n                        return this.error(ErrorKind.EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE, createLocation(this.clonePosition(), this.clonePosition()));\n                    }\n                    this.bumpSpace();\n                    var result = this.tryParseDecimalInteger(ErrorKind.EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE, ErrorKind.INVALID_PLURAL_ARGUMENT_OFFSET_VALUE);\n                    if (result.err) {\n                        return result;\n                    }\n                    // Parse another identifier for option parsing\n                    this.bumpSpace();\n                    identifierAndLocation = this.parseIdentifierIfPossible();\n                    pluralOffset = result.val;\n                }\n                var optionsResult = this.tryParsePluralOrSelectOptions(nestingLevel, argType, expectingCloseTag, identifierAndLocation);\n                if (optionsResult.err) {\n                    return optionsResult;\n                }\n                var argCloseResult = this.tryParseArgumentClose(openingBracePosition);\n                if (argCloseResult.err) {\n                    return argCloseResult;\n                }\n                var location_2 = createLocation(openingBracePosition, this.clonePosition());\n                if (argType === 'select') {\n                    return {\n                        val: {\n                            type: TYPE.select,\n                            value: value,\n                            options: fromEntries(optionsResult.val),\n                            location: location_2,\n                        },\n                        err: null,\n                    };\n                }\n                else {\n                    return {\n                        val: {\n                            type: TYPE.plural,\n                            value: value,\n                            options: fromEntries(optionsResult.val),\n                            offset: pluralOffset,\n                            pluralType: argType === 'plural' ? 'cardinal' : 'ordinal',\n                            location: location_2,\n                        },\n                        err: null,\n                    };\n                }\n            }\n            default:\n                return this.error(ErrorKind.INVALID_ARGUMENT_TYPE, createLocation(typeStartPosition, typeEndPosition));\n        }\n    };\n    Parser.prototype.tryParseArgumentClose = function (openingBracePosition) {\n        // Parse: {value, number, ::currency/GBP }\n        //\n        if (this.isEOF() || this.char() !== 125 /* `}` */) {\n            return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));\n        }\n        this.bump(); // `}`\n        return { val: true, err: null };\n    };\n    /**\n     * See: https://github.com/unicode-org/icu/blob/af7ed1f6d2298013dc303628438ec4abe1f16479/icu4c/source/common/messagepattern.cpp#L659\n     */\n    Parser.prototype.parseSimpleArgStyleIfPossible = function () {\n        var nestedBraces = 0;\n        var startPosition = this.clonePosition();\n        while (!this.isEOF()) {\n            var ch = this.char();\n            switch (ch) {\n                case 39 /* `'` */: {\n                    // Treat apostrophe as quoting but include it in the style part.\n                    // Find the end of the quoted literal text.\n                    this.bump();\n                    var apostrophePosition = this.clonePosition();\n                    if (!this.bumpUntil(\"'\")) {\n                        return this.error(ErrorKind.UNCLOSED_QUOTE_IN_ARGUMENT_STYLE, createLocation(apostrophePosition, this.clonePosition()));\n                    }\n                    this.bump();\n                    break;\n                }\n                case 123 /* `{` */: {\n                    nestedBraces += 1;\n                    this.bump();\n                    break;\n                }\n                case 125 /* `}` */: {\n                    if (nestedBraces > 0) {\n                        nestedBraces -= 1;\n                    }\n                    else {\n                        return {\n                            val: this.message.slice(startPosition.offset, this.offset()),\n                            err: null,\n                        };\n                    }\n                    break;\n                }\n                default:\n                    this.bump();\n                    break;\n            }\n        }\n        return {\n            val: this.message.slice(startPosition.offset, this.offset()),\n            err: null,\n        };\n    };\n    Parser.prototype.parseNumberSkeletonFromString = function (skeleton, location) {\n        var tokens = [];\n        try {\n            tokens = parseNumberSkeletonFromString(skeleton);\n        }\n        catch (e) {\n            return this.error(ErrorKind.INVALID_NUMBER_SKELETON, location);\n        }\n        return {\n            val: {\n                type: SKELETON_TYPE.number,\n                tokens: tokens,\n                location: location,\n                parsedOptions: this.shouldParseSkeletons\n                    ? parseNumberSkeleton(tokens)\n                    : {},\n            },\n            err: null,\n        };\n    };\n    /**\n     * @param nesting_level The current nesting level of messages.\n     *     This can be positive when parsing message fragment in select or plural argument options.\n     * @param parent_arg_type The parent argument's type.\n     * @param parsed_first_identifier If provided, this is the first identifier-like selector of\n     *     the argument. It is a by-product of a previous parsing attempt.\n     * @param expecting_close_tag If true, this message is directly or indirectly nested inside\n     *     between a pair of opening and closing tags. The nested message will not parse beyond\n     *     the closing tag boundary.\n     */\n    Parser.prototype.tryParsePluralOrSelectOptions = function (nestingLevel, parentArgType, expectCloseTag, parsedFirstIdentifier) {\n        var _a;\n        var hasOtherClause = false;\n        var options = [];\n        var parsedSelectors = new Set();\n        var selector = parsedFirstIdentifier.value, selectorLocation = parsedFirstIdentifier.location;\n        // Parse:\n        // one {one apple}\n        // ^--^\n        while (true) {\n            if (selector.length === 0) {\n                var startPosition = this.clonePosition();\n                if (parentArgType !== 'select' && this.bumpIf('=')) {\n                    // Try parse `={number}` selector\n                    var result = this.tryParseDecimalInteger(ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR, ErrorKind.INVALID_PLURAL_ARGUMENT_SELECTOR);\n                    if (result.err) {\n                        return result;\n                    }\n                    selectorLocation = createLocation(startPosition, this.clonePosition());\n                    selector = this.message.slice(startPosition.offset, this.offset());\n                }\n                else {\n                    break;\n                }\n            }\n            // Duplicate selector clauses\n            if (parsedSelectors.has(selector)) {\n                return this.error(parentArgType === 'select'\n                    ? ErrorKind.DUPLICATE_SELECT_ARGUMENT_SELECTOR\n                    : ErrorKind.DUPLICATE_PLURAL_ARGUMENT_SELECTOR, selectorLocation);\n            }\n            if (selector === 'other') {\n                hasOtherClause = true;\n            }\n            // Parse:\n            // one {one apple}\n            //     ^----------^\n            this.bumpSpace();\n            var openingBracePosition = this.clonePosition();\n            if (!this.bumpIf('{')) {\n                return this.error(parentArgType === 'select'\n                    ? ErrorKind.EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT\n                    : ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT, createLocation(this.clonePosition(), this.clonePosition()));\n            }\n            var fragmentResult = this.parseMessage(nestingLevel + 1, parentArgType, expectCloseTag);\n            if (fragmentResult.err) {\n                return fragmentResult;\n            }\n            var argCloseResult = this.tryParseArgumentClose(openingBracePosition);\n            if (argCloseResult.err) {\n                return argCloseResult;\n            }\n            options.push([\n                selector,\n                {\n                    value: fragmentResult.val,\n                    location: createLocation(openingBracePosition, this.clonePosition()),\n                },\n            ]);\n            // Keep track of the existing selectors\n            parsedSelectors.add(selector);\n            // Prep next selector clause.\n            this.bumpSpace();\n            (_a = this.parseIdentifierIfPossible(), selector = _a.value, selectorLocation = _a.location);\n        }\n        if (options.length === 0) {\n            return this.error(parentArgType === 'select'\n                ? ErrorKind.EXPECT_SELECT_ARGUMENT_SELECTOR\n                : ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR, createLocation(this.clonePosition(), this.clonePosition()));\n        }\n        if (this.requiresOtherClause && !hasOtherClause) {\n            return this.error(ErrorKind.MISSING_OTHER_CLAUSE, createLocation(this.clonePosition(), this.clonePosition()));\n        }\n        return { val: options, err: null };\n    };\n    Parser.prototype.tryParseDecimalInteger = function (expectNumberError, invalidNumberError) {\n        var sign = 1;\n        var startingPosition = this.clonePosition();\n        if (this.bumpIf('+')) {\n        }\n        else if (this.bumpIf('-')) {\n            sign = -1;\n        }\n        var hasDigits = false;\n        var decimal = 0;\n        while (!this.isEOF()) {\n            var ch = this.char();\n            if (ch >= 48 /* `0` */ && ch <= 57 /* `9` */) {\n                hasDigits = true;\n                decimal = decimal * 10 + (ch - 48);\n                this.bump();\n            }\n            else {\n                break;\n            }\n        }\n        var location = createLocation(startingPosition, this.clonePosition());\n        if (!hasDigits) {\n            return this.error(expectNumberError, location);\n        }\n        decimal *= sign;\n        if (!isSafeInteger(decimal)) {\n            return this.error(invalidNumberError, location);\n        }\n        return { val: decimal, err: null };\n    };\n    Parser.prototype.offset = function () {\n        return this.position.offset;\n    };\n    Parser.prototype.isEOF = function () {\n        return this.offset() === this.message.length;\n    };\n    Parser.prototype.clonePosition = function () {\n        // This is much faster than `Object.assign` or spread.\n        return {\n            offset: this.position.offset,\n            line: this.position.line,\n            column: this.position.column,\n        };\n    };\n    /**\n     * Return the code point at the current position of the parser.\n     * Throws if the index is out of bound.\n     */\n    Parser.prototype.char = function () {\n        var offset = this.position.offset;\n        if (offset >= this.message.length) {\n            throw Error('out of bound');\n        }\n        var code = codePointAt(this.message, offset);\n        if (code === undefined) {\n            throw Error(\"Offset \".concat(offset, \" is at invalid UTF-16 code unit boundary\"));\n        }\n        return code;\n    };\n    Parser.prototype.error = function (kind, location) {\n        return {\n            val: null,\n            err: {\n                kind: kind,\n                message: this.message,\n                location: location,\n            },\n        };\n    };\n    /** Bump the parser to the next UTF-16 code unit. */\n    Parser.prototype.bump = function () {\n        if (this.isEOF()) {\n            return;\n        }\n        var code = this.char();\n        if (code === 10 /* '\\n' */) {\n            this.position.line += 1;\n            this.position.column = 1;\n            this.position.offset += 1;\n        }\n        else {\n            this.position.column += 1;\n            // 0 ~ 0x10000 -> unicode BMP, otherwise skip the surrogate pair.\n            this.position.offset += code < 0x10000 ? 1 : 2;\n        }\n    };\n    /**\n     * If the substring starting at the current position of the parser has\n     * the given prefix, then bump the parser to the character immediately\n     * following the prefix and return true. Otherwise, don't bump the parser\n     * and return false.\n     */\n    Parser.prototype.bumpIf = function (prefix) {\n        if (startsWith(this.message, prefix, this.offset())) {\n            for (var i = 0; i < prefix.length; i++) {\n                this.bump();\n            }\n            return true;\n        }\n        return false;\n    };\n    /**\n     * Bump the parser until the pattern character is found and return `true`.\n     * Otherwise bump to the end of the file and return `false`.\n     */\n    Parser.prototype.bumpUntil = function (pattern) {\n        var currentOffset = this.offset();\n        var index = this.message.indexOf(pattern, currentOffset);\n        if (index >= 0) {\n            this.bumpTo(index);\n            return true;\n        }\n        else {\n            this.bumpTo(this.message.length);\n            return false;\n        }\n    };\n    /**\n     * Bump the parser to the target offset.\n     * If target offset is beyond the end of the input, bump the parser to the end of the input.\n     */\n    Parser.prototype.bumpTo = function (targetOffset) {\n        if (this.offset() > targetOffset) {\n            throw Error(\"targetOffset \".concat(targetOffset, \" must be greater than or equal to the current offset \").concat(this.offset()));\n        }\n        targetOffset = Math.min(targetOffset, this.message.length);\n        while (true) {\n            var offset = this.offset();\n            if (offset === targetOffset) {\n                break;\n            }\n            if (offset > targetOffset) {\n                throw Error(\"targetOffset \".concat(targetOffset, \" is at invalid UTF-16 code unit boundary\"));\n            }\n            this.bump();\n            if (this.isEOF()) {\n                break;\n            }\n        }\n    };\n    /** advance the parser through all whitespace to the next non-whitespace code unit. */\n    Parser.prototype.bumpSpace = function () {\n        while (!this.isEOF() && _isWhiteSpace(this.char())) {\n            this.bump();\n        }\n    };\n    /**\n     * Peek at the *next* Unicode codepoint in the input without advancing the parser.\n     * If the input has been exhausted, then this returns null.\n     */\n    Parser.prototype.peek = function () {\n        if (this.isEOF()) {\n            return null;\n        }\n        var code = this.char();\n        var offset = this.offset();\n        var nextCode = this.message.charCodeAt(offset + (code >= 0x10000 ? 2 : 1));\n        return nextCode !== null && nextCode !== void 0 ? nextCode : null;\n    };\n    return Parser;\n}());\nexport { Parser };\n/**\n * This check if codepoint is alphabet (lower & uppercase)\n * @param codepoint\n * @returns\n */\nfunction _isAlpha(codepoint) {\n    return ((codepoint >= 97 && codepoint <= 122) ||\n        (codepoint >= 65 && codepoint <= 90));\n}\nfunction _isAlphaOrSlash(codepoint) {\n    return _isAlpha(codepoint) || codepoint === 47; /* '/' */\n}\n/** See `parseTag` function docs. */\nfunction _isPotentialElementNameChar(c) {\n    return (c === 45 /* '-' */ ||\n        c === 46 /* '.' */ ||\n        (c >= 48 && c <= 57) /* 0..9 */ ||\n        c === 95 /* '_' */ ||\n        (c >= 97 && c <= 122) /** a..z */ ||\n        (c >= 65 && c <= 90) /* A..Z */ ||\n        c == 0xb7 ||\n        (c >= 0xc0 && c <= 0xd6) ||\n        (c >= 0xd8 && c <= 0xf6) ||\n        (c >= 0xf8 && c <= 0x37d) ||\n        (c >= 0x37f && c <= 0x1fff) ||\n        (c >= 0x200c && c <= 0x200d) ||\n        (c >= 0x203f && c <= 0x2040) ||\n        (c >= 0x2070 && c <= 0x218f) ||\n        (c >= 0x2c00 && c <= 0x2fef) ||\n        (c >= 0x3001 && c <= 0xd7ff) ||\n        (c >= 0xf900 && c <= 0xfdcf) ||\n        (c >= 0xfdf0 && c <= 0xfffd) ||\n        (c >= 0x10000 && c <= 0xeffff));\n}\n/**\n * Code point equivalent of regex `\\p{White_Space}`.\n * From: https://www.unicode.org/Public/UCD/latest/ucd/PropList.txt\n */\nfunction _isWhiteSpace(c) {\n    return ((c >= 0x0009 && c <= 0x000d) ||\n        c === 0x0020 ||\n        c === 0x0085 ||\n        (c >= 0x200e && c <= 0x200f) ||\n        c === 0x2028 ||\n        c === 0x2029);\n}\n/**\n * Code point equivalent of regex `\\p{Pattern_Syntax}`.\n * See https://www.unicode.org/Public/UCD/latest/ucd/PropList.txt\n */\nfunction _isPatternSyntax(c) {\n    return ((c >= 0x0021 && c <= 0x0023) ||\n        c === 0x0024 ||\n        (c >= 0x0025 && c <= 0x0027) ||\n        c === 0x0028 ||\n        c === 0x0029 ||\n        c === 0x002a ||\n        c === 0x002b ||\n        c === 0x002c ||\n        c === 0x002d ||\n        (c >= 0x002e && c <= 0x002f) ||\n        (c >= 0x003a && c <= 0x003b) ||\n        (c >= 0x003c && c <= 0x003e) ||\n        (c >= 0x003f && c <= 0x0040) ||\n        c === 0x005b ||\n        c === 0x005c ||\n        c === 0x005d ||\n        c === 0x005e ||\n        c === 0x0060 ||\n        c === 0x007b ||\n        c === 0x007c ||\n        c === 0x007d ||\n        c === 0x007e ||\n        c === 0x00a1 ||\n        (c >= 0x00a2 && c <= 0x00a5) ||\n        c === 0x00a6 ||\n        c === 0x00a7 ||\n        c === 0x00a9 ||\n        c === 0x00ab ||\n        c === 0x00ac ||\n        c === 0x00ae ||\n        c === 0x00b0 ||\n        c === 0x00b1 ||\n        c === 0x00b6 ||\n        c === 0x00bb ||\n        c === 0x00bf ||\n        c === 0x00d7 ||\n        c === 0x00f7 ||\n        (c >= 0x2010 && c <= 0x2015) ||\n        (c >= 0x2016 && c <= 0x2017) ||\n        c === 0x2018 ||\n        c === 0x2019 ||\n        c === 0x201a ||\n        (c >= 0x201b && c <= 0x201c) ||\n        c === 0x201d ||\n        c === 0x201e ||\n        c === 0x201f ||\n        (c >= 0x2020 && c <= 0x2027) ||\n        (c >= 0x2030 && c <= 0x2038) ||\n        c === 0x2039 ||\n        c === 0x203a ||\n        (c >= 0x203b && c <= 0x203e) ||\n        (c >= 0x2041 && c <= 0x2043) ||\n        c === 0x2044 ||\n        c === 0x2045 ||\n        c === 0x2046 ||\n        (c >= 0x2047 && c <= 0x2051) ||\n        c === 0x2052 ||\n        c === 0x2053 ||\n        (c >= 0x2055 && c <= 0x205e) ||\n        (c >= 0x2190 && c <= 0x2194) ||\n        (c >= 0x2195 && c <= 0x2199) ||\n        (c >= 0x219a && c <= 0x219b) ||\n        (c >= 0x219c && c <= 0x219f) ||\n        c === 0x21a0 ||\n        (c >= 0x21a1 && c <= 0x21a2) ||\n        c === 0x21a3 ||\n        (c >= 0x21a4 && c <= 0x21a5) ||\n        c === 0x21a6 ||\n        (c >= 0x21a7 && c <= 0x21ad) ||\n        c === 0x21ae ||\n        (c >= 0x21af && c <= 0x21cd) ||\n        (c >= 0x21ce && c <= 0x21cf) ||\n        (c >= 0x21d0 && c <= 0x21d1) ||\n        c === 0x21d2 ||\n        c === 0x21d3 ||\n        c === 0x21d4 ||\n        (c >= 0x21d5 && c <= 0x21f3) ||\n        (c >= 0x21f4 && c <= 0x22ff) ||\n        (c >= 0x2300 && c <= 0x2307) ||\n        c === 0x2308 ||\n        c === 0x2309 ||\n        c === 0x230a ||\n        c === 0x230b ||\n        (c >= 0x230c && c <= 0x231f) ||\n        (c >= 0x2320 && c <= 0x2321) ||\n        (c >= 0x2322 && c <= 0x2328) ||\n        c === 0x2329 ||\n        c === 0x232a ||\n        (c >= 0x232b && c <= 0x237b) ||\n        c === 0x237c ||\n        (c >= 0x237d && c <= 0x239a) ||\n        (c >= 0x239b && c <= 0x23b3) ||\n        (c >= 0x23b4 && c <= 0x23db) ||\n        (c >= 0x23dc && c <= 0x23e1) ||\n        (c >= 0x23e2 && c <= 0x2426) ||\n        (c >= 0x2427 && c <= 0x243f) ||\n        (c >= 0x2440 && c <= 0x244a) ||\n        (c >= 0x244b && c <= 0x245f) ||\n        (c >= 0x2500 && c <= 0x25b6) ||\n        c === 0x25b7 ||\n        (c >= 0x25b8 && c <= 0x25c0) ||\n        c === 0x25c1 ||\n        (c >= 0x25c2 && c <= 0x25f7) ||\n        (c >= 0x25f8 && c <= 0x25ff) ||\n        (c >= 0x2600 && c <= 0x266e) ||\n        c === 0x266f ||\n        (c >= 0x2670 && c <= 0x2767) ||\n        c === 0x2768 ||\n        c === 0x2769 ||\n        c === 0x276a ||\n        c === 0x276b ||\n        c === 0x276c ||\n        c === 0x276d ||\n        c === 0x276e ||\n        c === 0x276f ||\n        c === 0x2770 ||\n        c === 0x2771 ||\n        c === 0x2772 ||\n        c === 0x2773 ||\n        c === 0x2774 ||\n        c === 0x2775 ||\n        (c >= 0x2794 && c <= 0x27bf) ||\n        (c >= 0x27c0 && c <= 0x27c4) ||\n        c === 0x27c5 ||\n        c === 0x27c6 ||\n        (c >= 0x27c7 && c <= 0x27e5) ||\n        c === 0x27e6 ||\n        c === 0x27e7 ||\n        c === 0x27e8 ||\n        c === 0x27e9 ||\n        c === 0x27ea ||\n        c === 0x27eb ||\n        c === 0x27ec ||\n        c === 0x27ed ||\n        c === 0x27ee ||\n        c === 0x27ef ||\n        (c >= 0x27f0 && c <= 0x27ff) ||\n        (c >= 0x2800 && c <= 0x28ff) ||\n        (c >= 0x2900 && c <= 0x2982) ||\n        c === 0x2983 ||\n        c === 0x2984 ||\n        c === 0x2985 ||\n        c === 0x2986 ||\n        c === 0x2987 ||\n        c === 0x2988 ||\n        c === 0x2989 ||\n        c === 0x298a ||\n        c === 0x298b ||\n        c === 0x298c ||\n        c === 0x298d ||\n        c === 0x298e ||\n        c === 0x298f ||\n        c === 0x2990 ||\n        c === 0x2991 ||\n        c === 0x2992 ||\n        c === 0x2993 ||\n        c === 0x2994 ||\n        c === 0x2995 ||\n        c === 0x2996 ||\n        c === 0x2997 ||\n        c === 0x2998 ||\n        (c >= 0x2999 && c <= 0x29d7) ||\n        c === 0x29d8 ||\n        c === 0x29d9 ||\n        c === 0x29da ||\n        c === 0x29db ||\n        (c >= 0x29dc && c <= 0x29fb) ||\n        c === 0x29fc ||\n        c === 0x29fd ||\n        (c >= 0x29fe && c <= 0x2aff) ||\n        (c >= 0x2b00 && c <= 0x2b2f) ||\n        (c >= 0x2b30 && c <= 0x2b44) ||\n        (c >= 0x2b45 && c <= 0x2b46) ||\n        (c >= 0x2b47 && c <= 0x2b4c) ||\n        (c >= 0x2b4d && c <= 0x2b73) ||\n        (c >= 0x2b74 && c <= 0x2b75) ||\n        (c >= 0x2b76 && c <= 0x2b95) ||\n        c === 0x2b96 ||\n        (c >= 0x2b97 && c <= 0x2bff) ||\n        (c >= 0x2e00 && c <= 0x2e01) ||\n        c === 0x2e02 ||\n        c === 0x2e03 ||\n        c === 0x2e04 ||\n        c === 0x2e05 ||\n        (c >= 0x2e06 && c <= 0x2e08) ||\n        c === 0x2e09 ||\n        c === 0x2e0a ||\n        c === 0x2e0b ||\n        c === 0x2e0c ||\n        c === 0x2e0d ||\n        (c >= 0x2e0e && c <= 0x2e16) ||\n        c === 0x2e17 ||\n        (c >= 0x2e18 && c <= 0x2e19) ||\n        c === 0x2e1a ||\n        c === 0x2e1b ||\n        c === 0x2e1c ||\n        c === 0x2e1d ||\n        (c >= 0x2e1e && c <= 0x2e1f) ||\n        c === 0x2e20 ||\n        c === 0x2e21 ||\n        c === 0x2e22 ||\n        c === 0x2e23 ||\n        c === 0x2e24 ||\n        c === 0x2e25 ||\n        c === 0x2e26 ||\n        c === 0x2e27 ||\n        c === 0x2e28 ||\n        c === 0x2e29 ||\n        (c >= 0x2e2a && c <= 0x2e2e) ||\n        c === 0x2e2f ||\n        (c >= 0x2e30 && c <= 0x2e39) ||\n        (c >= 0x2e3a && c <= 0x2e3b) ||\n        (c >= 0x2e3c && c <= 0x2e3f) ||\n        c === 0x2e40 ||\n        c === 0x2e41 ||\n        c === 0x2e42 ||\n        (c >= 0x2e43 && c <= 0x2e4f) ||\n        (c >= 0x2e50 && c <= 0x2e51) ||\n        c === 0x2e52 ||\n        (c >= 0x2e53 && c <= 0x2e7f) ||\n        (c >= 0x3001 && c <= 0x3003) ||\n        c === 0x3008 ||\n        c === 0x3009 ||\n        c === 0x300a ||\n        c === 0x300b ||\n        c === 0x300c ||\n        c === 0x300d ||\n        c === 0x300e ||\n        c === 0x300f ||\n        c === 0x3010 ||\n        c === 0x3011 ||\n        (c >= 0x3012 && c <= 0x3013) ||\n        c === 0x3014 ||\n        c === 0x3015 ||\n        c === 0x3016 ||\n        c === 0x3017 ||\n        c === 0x3018 ||\n        c === 0x3019 ||\n        c === 0x301a ||\n        c === 0x301b ||\n        c === 0x301c ||\n        c === 0x301d ||\n        (c >= 0x301e && c <= 0x301f) ||\n        c === 0x3020 ||\n        c === 0x3030 ||\n        c === 0xfd3e ||\n        c === 0xfd3f ||\n        (c >= 0xfe45 && c <= 0xfe46));\n}\n","// @generated from regex-gen.ts\nexport var WHITE_SPACE_REGEX = /[\\t-\\r \\x85\\u200E\\u200F\\u2028\\u2029]/i;\n","import { getNamedFormat, filterProps } from './utils';\nimport { FormatError, ErrorCode } from 'intl-messageformat';\nimport { IntlFormatError } from './error';\nvar RELATIVE_TIME_FORMAT_OPTIONS = ['numeric', 'style'];\nfunction getFormatter(_a, getRelativeTimeFormat, options) {\n    var locale = _a.locale, formats = _a.formats, onError = _a.onError;\n    if (options === void 0) { options = {}; }\n    var format = options.format;\n    var defaults = (!!format && getNamedFormat(formats, 'relative', format, onError)) || {};\n    var filteredOptions = filterProps(options, RELATIVE_TIME_FORMAT_OPTIONS, defaults);\n    return getRelativeTimeFormat(locale, filteredOptions);\n}\nexport function formatRelativeTime(config, getRelativeTimeFormat, value, unit, options) {\n    if (options === void 0) { options = {}; }\n    if (!unit) {\n        unit = 'second';\n    }\n    var RelativeTimeFormat = Intl.RelativeTimeFormat;\n    if (!RelativeTimeFormat) {\n        config.onError(new FormatError(\"Intl.RelativeTimeFormat is not available in this environment.\\nTry polyfilling it using \\\"@formatjs/intl-relativetimeformat\\\"\\n\", ErrorCode.MISSING_INTL_API));\n    }\n    try {\n        return getFormatter(config, getRelativeTimeFormat, options).format(value, unit);\n    }\n    catch (e) {\n        config.onError(new IntlFormatError('Error formatting relative time.', config.locale, e));\n    }\n    return String(value);\n}\n","import { filterProps } from './utils';\nimport { IntlFormatError } from './error';\nimport { ErrorCode, FormatError } from 'intl-messageformat';\nvar PLURAL_FORMAT_OPTIONS = [\n    'localeMatcher',\n    'type',\n];\nexport function formatPlural(_a, getPluralRules, value, options) {\n    var locale = _a.locale, onError = _a.onError;\n    if (options === void 0) { options = {}; }\n    if (!Intl.PluralRules) {\n        onError(new FormatError(\"Intl.PluralRules is not available in this environment.\\nTry polyfilling it using \\\"@formatjs/intl-pluralrules\\\"\\n\", ErrorCode.MISSING_INTL_API));\n    }\n    var filteredOptions = filterProps(options, PLURAL_FORMAT_OPTIONS);\n    try {\n        return getPluralRules(locale, filteredOptions).select(value);\n    }\n    catch (e) {\n        onError(new IntlFormatError('Error formatting plural.', locale, e));\n    }\n    return 'other';\n}\n","import { filterProps } from './utils';\nimport { FormatError, ErrorCode } from 'intl-messageformat';\nimport { IntlErrorCode, IntlError } from './error';\nvar DISPLAY_NAMES_OPTONS = [\n    'localeMatcher',\n    'style',\n    'type',\n    'fallback',\n];\nexport function formatDisplayName(_a, getDisplayNames, value, options) {\n    var locale = _a.locale, onError = _a.onError;\n    var DisplayNames = Intl.DisplayNames;\n    if (!DisplayNames) {\n        onError(new FormatError(\"Intl.DisplayNames is not available in this environment.\\nTry polyfilling it using \\\"@formatjs/intl-displaynames\\\"\\n\", ErrorCode.MISSING_INTL_API));\n    }\n    var filteredOptions = filterProps(options, DISPLAY_NAMES_OPTONS);\n    try {\n        return getDisplayNames(locale, filteredOptions).of(value);\n    }\n    catch (e) {\n        onError(new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting display name.', e));\n    }\n}\n","import { __extends } from \"tslib\";\nexport var IntlErrorCode;\n(function (IntlErrorCode) {\n    IntlErrorCode[\"FORMAT_ERROR\"] = \"FORMAT_ERROR\";\n    IntlErrorCode[\"UNSUPPORTED_FORMATTER\"] = \"UNSUPPORTED_FORMATTER\";\n    IntlErrorCode[\"INVALID_CONFIG\"] = \"INVALID_CONFIG\";\n    IntlErrorCode[\"MISSING_DATA\"] = \"MISSING_DATA\";\n    IntlErrorCode[\"MISSING_TRANSLATION\"] = \"MISSING_TRANSLATION\";\n})(IntlErrorCode || (IntlErrorCode = {}));\nvar IntlError = /** @class */ (function (_super) {\n    __extends(IntlError, _super);\n    function IntlError(code, message, exception) {\n        var _this = this;\n        var err = exception\n            ? exception instanceof Error\n                ? exception\n                : new Error(String(exception))\n            : undefined;\n        _this = _super.call(this, \"[@formatjs/intl Error \".concat(code, \"] \").concat(message, \" \\n\").concat(err ? \"\\n\".concat(err.message, \"\\n\").concat(err.stack) : '')) || this;\n        _this.code = code;\n        // @ts-ignore just so we don't need to declare dep on @types/node\n        if (typeof Error.captureStackTrace === 'function') {\n            // @ts-ignore just so we don't need to declare dep on @types/node\n            Error.captureStackTrace(_this, IntlError);\n        }\n        return _this;\n    }\n    return IntlError;\n}(Error));\nexport { IntlError };\nvar UnsupportedFormatterError = /** @class */ (function (_super) {\n    __extends(UnsupportedFormatterError, _super);\n    function UnsupportedFormatterError(message, exception) {\n        return _super.call(this, IntlErrorCode.UNSUPPORTED_FORMATTER, message, exception) || this;\n    }\n    return UnsupportedFormatterError;\n}(IntlError));\nexport { UnsupportedFormatterError };\nvar InvalidConfigError = /** @class */ (function (_super) {\n    __extends(InvalidConfigError, _super);\n    function InvalidConfigError(message, exception) {\n        return _super.call(this, IntlErrorCode.INVALID_CONFIG, message, exception) || this;\n    }\n    return InvalidConfigError;\n}(IntlError));\nexport { InvalidConfigError };\nvar MissingDataError = /** @class */ (function (_super) {\n    __extends(MissingDataError, _super);\n    function MissingDataError(message, exception) {\n        return _super.call(this, IntlErrorCode.MISSING_DATA, message, exception) || this;\n    }\n    return MissingDataError;\n}(IntlError));\nexport { MissingDataError };\nvar IntlFormatError = /** @class */ (function (_super) {\n    __extends(IntlFormatError, _super);\n    function IntlFormatError(message, locale, exception) {\n        return _super.call(this, IntlErrorCode.FORMAT_ERROR, \"\".concat(message, \" \\nLocale: \").concat(locale, \"\\n\"), exception) || this;\n    }\n    return IntlFormatError;\n}(IntlError));\nexport { IntlFormatError };\nvar MessageFormatError = /** @class */ (function (_super) {\n    __extends(MessageFormatError, _super);\n    function MessageFormatError(message, locale, descriptor, exception) {\n        var _this = _super.call(this, \"\".concat(message, \" \\nMessageID: \").concat(descriptor === null || descriptor === void 0 ? void 0 : descriptor.id, \"\\nDefault Message: \").concat(descriptor === null || descriptor === void 0 ? void 0 : descriptor.defaultMessage, \"\\nDescription: \").concat(descriptor === null || descriptor === void 0 ? void 0 : descriptor.description, \" \\n\"), locale, exception) || this;\n        _this.descriptor = descriptor;\n        return _this;\n    }\n    return MessageFormatError;\n}(IntlFormatError));\nexport { MessageFormatError };\nvar MissingTranslationError = /** @class */ (function (_super) {\n    __extends(MissingTranslationError, _super);\n    function MissingTranslationError(descriptor, locale) {\n        var _this = _super.call(this, IntlErrorCode.MISSING_TRANSLATION, \"Missing message: \\\"\".concat(descriptor.id, \"\\\" for locale \\\"\").concat(locale, \"\\\", using \").concat(descriptor.defaultMessage ? 'default message' : 'id', \" as fallback.\")) || this;\n        _this.descriptor = descriptor;\n        return _this;\n    }\n    return MissingTranslationError;\n}(IntlError));\nexport { MissingTranslationError };\n","\"use strict\";\n\nvar deselectCurrent = require(\"toggle-selection\");\n\nvar clipboardToIE11Formatting = {\n  \"text/plain\": \"Text\",\n  \"text/html\": \"Url\",\n  \"default\": \"Text\"\n}\n\nvar defaultMessage = \"Copy to clipboard: #{key}, Enter\";\n\nfunction format(message) {\n  var copyKey = (/mac os x/i.test(navigator.userAgent) ? \"⌘\" : \"Ctrl\") + \"+C\";\n  return message.replace(/#{\\s*key\\s*}/g, copyKey);\n}\n\nfunction copy(text, options) {\n  var debug,\n    message,\n    reselectPrevious,\n    range,\n    selection,\n    mark,\n    success = false;\n  if (!options) {\n    options = {};\n  }\n  debug = options.debug || false;\n  try {\n    reselectPrevious = deselectCurrent();\n\n    range = document.createRange();\n    selection = document.getSelection();\n\n    mark = document.createElement(\"span\");\n    mark.textContent = text;\n    // reset user styles for span element\n    mark.style.all = \"unset\";\n    // prevents scrolling to the end of the page\n    mark.style.position = \"fixed\";\n    mark.style.top = 0;\n    mark.style.clip = \"rect(0, 0, 0, 0)\";\n    // used to preserve spaces and line breaks\n    mark.style.whiteSpace = \"pre\";\n    // do not inherit user-select (it may be `none`)\n    mark.style.webkitUserSelect = \"text\";\n    mark.style.MozUserSelect = \"text\";\n    mark.style.msUserSelect = \"text\";\n    mark.style.userSelect = \"text\";\n    mark.addEventListener(\"copy\", function(e) {\n      e.stopPropagation();\n      if (options.format) {\n        e.preventDefault();\n        if (typeof e.clipboardData === \"undefined\") { // IE 11\n          debug && console.warn(\"unable to use e.clipboardData\");\n          debug && console.warn(\"trying IE specific stuff\");\n          window.clipboardData.clearData();\n          var format = clipboardToIE11Formatting[options.format] || clipboardToIE11Formatting[\"default\"]\n          window.clipboardData.setData(format, text);\n        } else { // all other browsers\n          e.clipboardData.clearData();\n          e.clipboardData.setData(options.format, text);\n        }\n      }\n      if (options.onCopy) {\n        e.preventDefault();\n        options.onCopy(e.clipboardData);\n      }\n    });\n\n    document.body.appendChild(mark);\n\n    range.selectNodeContents(mark);\n    selection.addRange(range);\n\n    var successful = document.execCommand(\"copy\");\n    if (!successful) {\n      throw new Error(\"copy command was unsuccessful\");\n    }\n    success = true;\n  } catch (err) {\n    debug && console.error(\"unable to copy using execCommand: \", err);\n    debug && console.warn(\"trying IE specific stuff\");\n    try {\n      window.clipboardData.setData(options.format || \"text\", text);\n      options.onCopy && options.onCopy(window.clipboardData);\n      success = true;\n    } catch (err) {\n      debug && console.error(\"unable to copy using clipboardData: \", err);\n      debug && console.error(\"falling back to prompt\");\n      message = format(\"message\" in options ? options.message : defaultMessage);\n      window.prompt(message, text);\n    }\n  } finally {\n    if (selection) {\n      if (typeof selection.removeRange == \"function\") {\n        selection.removeRange(range);\n      } else {\n        selection.removeAllRanges();\n      }\n    }\n\n    if (mark) {\n      document.body.removeChild(mark);\n    }\n    reselectPrevious();\n  }\n\n  return success;\n}\n\nmodule.exports = copy;\n","export var ErrorKind;\n(function (ErrorKind) {\n    /** Argument is unclosed (e.g. `{0`) */\n    ErrorKind[ErrorKind[\"EXPECT_ARGUMENT_CLOSING_BRACE\"] = 1] = \"EXPECT_ARGUMENT_CLOSING_BRACE\";\n    /** Argument is empty (e.g. `{}`). */\n    ErrorKind[ErrorKind[\"EMPTY_ARGUMENT\"] = 2] = \"EMPTY_ARGUMENT\";\n    /** Argument is malformed (e.g. `{foo!}``) */\n    ErrorKind[ErrorKind[\"MALFORMED_ARGUMENT\"] = 3] = \"MALFORMED_ARGUMENT\";\n    /** Expect an argument type (e.g. `{foo,}`) */\n    ErrorKind[ErrorKind[\"EXPECT_ARGUMENT_TYPE\"] = 4] = \"EXPECT_ARGUMENT_TYPE\";\n    /** Unsupported argument type (e.g. `{foo,foo}`) */\n    ErrorKind[ErrorKind[\"INVALID_ARGUMENT_TYPE\"] = 5] = \"INVALID_ARGUMENT_TYPE\";\n    /** Expect an argument style (e.g. `{foo, number, }`) */\n    ErrorKind[ErrorKind[\"EXPECT_ARGUMENT_STYLE\"] = 6] = \"EXPECT_ARGUMENT_STYLE\";\n    /** The number skeleton is invalid. */\n    ErrorKind[ErrorKind[\"INVALID_NUMBER_SKELETON\"] = 7] = \"INVALID_NUMBER_SKELETON\";\n    /** The date time skeleton is invalid. */\n    ErrorKind[ErrorKind[\"INVALID_DATE_TIME_SKELETON\"] = 8] = \"INVALID_DATE_TIME_SKELETON\";\n    /** Exepct a number skeleton following the `::` (e.g. `{foo, number, ::}`) */\n    ErrorKind[ErrorKind[\"EXPECT_NUMBER_SKELETON\"] = 9] = \"EXPECT_NUMBER_SKELETON\";\n    /** Exepct a date time skeleton following the `::` (e.g. `{foo, date, ::}`) */\n    ErrorKind[ErrorKind[\"EXPECT_DATE_TIME_SKELETON\"] = 10] = \"EXPECT_DATE_TIME_SKELETON\";\n    /** Unmatched apostrophes in the argument style (e.g. `{foo, number, 'test`) */\n    ErrorKind[ErrorKind[\"UNCLOSED_QUOTE_IN_ARGUMENT_STYLE\"] = 11] = \"UNCLOSED_QUOTE_IN_ARGUMENT_STYLE\";\n    /** Missing select argument options (e.g. `{foo, select}`) */\n    ErrorKind[ErrorKind[\"EXPECT_SELECT_ARGUMENT_OPTIONS\"] = 12] = \"EXPECT_SELECT_ARGUMENT_OPTIONS\";\n    /** Expecting an offset value in `plural` or `selectordinal` argument (e.g `{foo, plural, offset}`) */\n    ErrorKind[ErrorKind[\"EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE\"] = 13] = \"EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE\";\n    /** Offset value in `plural` or `selectordinal` is invalid (e.g. `{foo, plural, offset: x}`) */\n    ErrorKind[ErrorKind[\"INVALID_PLURAL_ARGUMENT_OFFSET_VALUE\"] = 14] = \"INVALID_PLURAL_ARGUMENT_OFFSET_VALUE\";\n    /** Expecting a selector in `select` argument (e.g `{foo, select}`) */\n    ErrorKind[ErrorKind[\"EXPECT_SELECT_ARGUMENT_SELECTOR\"] = 15] = \"EXPECT_SELECT_ARGUMENT_SELECTOR\";\n    /** Expecting a selector in `plural` or `selectordinal` argument (e.g `{foo, plural}`) */\n    ErrorKind[ErrorKind[\"EXPECT_PLURAL_ARGUMENT_SELECTOR\"] = 16] = \"EXPECT_PLURAL_ARGUMENT_SELECTOR\";\n    /** Expecting a message fragment after the `select` selector (e.g. `{foo, select, apple}`) */\n    ErrorKind[ErrorKind[\"EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT\"] = 17] = \"EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT\";\n    /**\n     * Expecting a message fragment after the `plural` or `selectordinal` selector\n     * (e.g. `{foo, plural, one}`)\n     */\n    ErrorKind[ErrorKind[\"EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT\"] = 18] = \"EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT\";\n    /** Selector in `plural` or `selectordinal` is malformed (e.g. `{foo, plural, =x {#}}`) */\n    ErrorKind[ErrorKind[\"INVALID_PLURAL_ARGUMENT_SELECTOR\"] = 19] = \"INVALID_PLURAL_ARGUMENT_SELECTOR\";\n    /**\n     * Duplicate selectors in `plural` or `selectordinal` argument.\n     * (e.g. {foo, plural, one {#} one {#}})\n     */\n    ErrorKind[ErrorKind[\"DUPLICATE_PLURAL_ARGUMENT_SELECTOR\"] = 20] = \"DUPLICATE_PLURAL_ARGUMENT_SELECTOR\";\n    /** Duplicate selectors in `select` argument.\n     * (e.g. {foo, select, apple {apple} apple {apple}})\n     */\n    ErrorKind[ErrorKind[\"DUPLICATE_SELECT_ARGUMENT_SELECTOR\"] = 21] = \"DUPLICATE_SELECT_ARGUMENT_SELECTOR\";\n    /** Plural or select argument option must have `other` clause. */\n    ErrorKind[ErrorKind[\"MISSING_OTHER_CLAUSE\"] = 22] = \"MISSING_OTHER_CLAUSE\";\n    /** The tag is malformed. (e.g. `<bold!>foo</bold!>) */\n    ErrorKind[ErrorKind[\"INVALID_TAG\"] = 23] = \"INVALID_TAG\";\n    /** The tag name is invalid. (e.g. `<123>foo</123>`) */\n    ErrorKind[ErrorKind[\"INVALID_TAG_NAME\"] = 25] = \"INVALID_TAG_NAME\";\n    /** The closing tag does not match the opening tag. (e.g. `<bold>foo</italic>`) */\n    ErrorKind[ErrorKind[\"UNMATCHED_CLOSING_TAG\"] = 26] = \"UNMATCHED_CLOSING_TAG\";\n    /** The opening tag has unmatched closing tag. (e.g. `<bold>foo`) */\n    ErrorKind[ErrorKind[\"UNCLOSED_TAG\"] = 27] = \"UNCLOSED_TAG\";\n})(ErrorKind || (ErrorKind = {}));\n","/**\n * Cannot do Math.log(x) / Math.log(10) bc if IEEE floating point issue\n * @param x number\n */\nexport function getMagnitude(x) {\n    // Cannot count string length via Number.toString because it may use scientific notation\n    // for very small or very large numbers.\n    return Math.floor(Math.log(x) * Math.LOG10E);\n}\nexport function repeat(s, times) {\n    if (typeof s.repeat === 'function') {\n        return s.repeat(times);\n    }\n    var arr = new Array(times);\n    for (var i = 0; i < arr.length; i++) {\n        arr[i] = s;\n    }\n    return arr.join('');\n}\nexport function setInternalSlot(map, pl, field, value) {\n    if (!map.get(pl)) {\n        map.set(pl, Object.create(null));\n    }\n    var slots = map.get(pl);\n    slots[field] = value;\n}\nexport function setMultiInternalSlots(map, pl, props) {\n    for (var _i = 0, _a = Object.keys(props); _i < _a.length; _i++) {\n        var k = _a[_i];\n        setInternalSlot(map, pl, k, props[k]);\n    }\n}\nexport function getInternalSlot(map, pl, field) {\n    return getMultiInternalSlots(map, pl, field)[field];\n}\nexport function getMultiInternalSlots(map, pl) {\n    var fields = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        fields[_i - 2] = arguments[_i];\n    }\n    var slots = map.get(pl);\n    if (!slots) {\n        throw new TypeError(\"\".concat(pl, \" InternalSlot has not been initialized\"));\n    }\n    return fields.reduce(function (all, f) {\n        all[f] = slots[f];\n        return all;\n    }, Object.create(null));\n}\nexport function isLiteralPart(patternPart) {\n    return patternPart.type === 'literal';\n}\n/*\n  17 ECMAScript Standard Built-in Objects:\n    Every built-in Function object, including constructors, that is not\n    identified as an anonymous function has a name property whose value\n    is a String.\n\n    Unless otherwise specified, the name property of a built-in Function\n    object, if it exists, has the attributes { [[Writable]]: false,\n    [[Enumerable]]: false, [[Configurable]]: true }.\n*/\nexport function defineProperty(target, name, _a) {\n    var value = _a.value;\n    Object.defineProperty(target, name, {\n        configurable: true,\n        enumerable: false,\n        writable: true,\n        value: value,\n    });\n}\nexport var UNICODE_EXTENSION_SEQUENCE_REGEX = /-u(?:-[0-9a-z]{2,8})+/gi;\nexport function invariant(condition, message, Err) {\n    if (Err === void 0) { Err = Error; }\n    if (!condition) {\n        throw new Err(message);\n    }\n}\n","export var TYPE;\n(function (TYPE) {\n    /**\n     * Raw text\n     */\n    TYPE[TYPE[\"literal\"] = 0] = \"literal\";\n    /**\n     * Variable w/o any format, e.g `var` in `this is a {var}`\n     */\n    TYPE[TYPE[\"argument\"] = 1] = \"argument\";\n    /**\n     * Variable w/ number format\n     */\n    TYPE[TYPE[\"number\"] = 2] = \"number\";\n    /**\n     * Variable w/ date format\n     */\n    TYPE[TYPE[\"date\"] = 3] = \"date\";\n    /**\n     * Variable w/ time format\n     */\n    TYPE[TYPE[\"time\"] = 4] = \"time\";\n    /**\n     * Variable w/ select format\n     */\n    TYPE[TYPE[\"select\"] = 5] = \"select\";\n    /**\n     * Variable w/ plural format\n     */\n    TYPE[TYPE[\"plural\"] = 6] = \"plural\";\n    /**\n     * Only possible within plural argument.\n     * This is the `#` symbol that will be substituted with the count.\n     */\n    TYPE[TYPE[\"pound\"] = 7] = \"pound\";\n    /**\n     * XML-like tag\n     */\n    TYPE[TYPE[\"tag\"] = 8] = \"tag\";\n})(TYPE || (TYPE = {}));\nexport var SKELETON_TYPE;\n(function (SKELETON_TYPE) {\n    SKELETON_TYPE[SKELETON_TYPE[\"number\"] = 0] = \"number\";\n    SKELETON_TYPE[SKELETON_TYPE[\"dateTime\"] = 1] = \"dateTime\";\n})(SKELETON_TYPE || (SKELETON_TYPE = {}));\n/**\n * Type Guards\n */\nexport function isLiteralElement(el) {\n    return el.type === TYPE.literal;\n}\nexport function isArgumentElement(el) {\n    return el.type === TYPE.argument;\n}\nexport function isNumberElement(el) {\n    return el.type === TYPE.number;\n}\nexport function isDateElement(el) {\n    return el.type === TYPE.date;\n}\nexport function isTimeElement(el) {\n    return el.type === TYPE.time;\n}\nexport function isSelectElement(el) {\n    return el.type === TYPE.select;\n}\nexport function isPluralElement(el) {\n    return el.type === TYPE.plural;\n}\nexport function isPoundElement(el) {\n    return el.type === TYPE.pound;\n}\nexport function isTagElement(el) {\n    return el.type === TYPE.tag;\n}\nexport function isNumberSkeleton(el) {\n    return !!(el && typeof el === 'object' && el.type === SKELETON_TYPE.number);\n}\nexport function isDateTimeSkeleton(el) {\n    return !!(el && typeof el === 'object' && el.type === SKELETON_TYPE.dateTime);\n}\nexport function createLiteralElement(value) {\n    return {\n        type: TYPE.literal,\n        value: value,\n    };\n}\nexport function createNumberElement(value, style) {\n    return {\n        type: TYPE.number,\n        value: value,\n        style: style,\n    };\n}\n","/*!\n  Copyright (c) 2017 Jed Watson.\n  Licensed under the MIT License (MIT), see\n  http://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames () {\n\t\tvar classes = [];\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (!arg) continue;\n\n\t\t\tvar argType = typeof arg;\n\n\t\t\tif (argType === 'string' || argType === 'number') {\n\t\t\t\tclasses.push(arg);\n\t\t\t} else if (Array.isArray(arg) && arg.length) {\n\t\t\t\tvar inner = classNames.apply(null, arg);\n\t\t\t\tif (inner) {\n\t\t\t\t\tclasses.push(inner);\n\t\t\t\t}\n\t\t\t} else if (argType === 'object') {\n\t\t\t\tfor (var key in arg) {\n\t\t\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\t\t\tclasses.push(key);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn classes.join(' ');\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tclassNames.default = classNames;\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n","import { __assign } from \"tslib\";\nimport { createFormatters, DEFAULT_INTL_CONFIG } from './utils';\nimport { InvalidConfigError, MissingDataError } from './error';\nimport { formatNumber, formatNumberToParts } from './number';\nimport { formatRelativeTime } from './relativeTime';\nimport { formatDate, formatDateToParts, formatTime, formatTimeToParts, formatDateTimeRange, } from './dateTime';\nimport { formatPlural } from './plural';\nimport { formatMessage } from './message';\nimport { formatList, formatListToParts } from './list';\nimport { formatDisplayName } from './displayName';\nfunction messagesContainString(messages) {\n    var firstMessage = messages ? messages[Object.keys(messages)[0]] : undefined;\n    return typeof firstMessage === 'string';\n}\nfunction verifyConfigMessages(config) {\n    if (config.defaultRichTextElements &&\n        messagesContainString(config.messages || {})) {\n        console.warn(\"[@formatjs/intl] \\\"defaultRichTextElements\\\" was specified but \\\"message\\\" was not pre-compiled. \\nPlease consider using \\\"@formatjs/cli\\\" to pre-compile your messages for performance.\\nFor more details see https://formatjs.io/docs/getting-started/message-distribution\");\n    }\n}\n/**\n * Create intl object\n * @param config intl config\n * @param cache cache for formatter instances to prevent memory leak\n */\nexport function createIntl(config, cache) {\n    var formatters = createFormatters(cache);\n    var resolvedConfig = __assign(__assign({}, DEFAULT_INTL_CONFIG), config);\n    var locale = resolvedConfig.locale, defaultLocale = resolvedConfig.defaultLocale, onError = resolvedConfig.onError;\n    if (!locale) {\n        if (onError) {\n            onError(new InvalidConfigError(\"\\\"locale\\\" was not configured, using \\\"\".concat(defaultLocale, \"\\\" as fallback. See https://formatjs.io/docs/react-intl/api#intlshape for more details\")));\n        }\n        // Since there's no registered locale data for `locale`, this will\n        // fallback to the `defaultLocale` to make sure things can render.\n        // The `messages` are overridden to the `defaultProps` empty object\n        // to maintain referential equality across re-renders. It's assumed\n        // each <FormattedMessage> contains a `defaultMessage` prop.\n        resolvedConfig.locale = resolvedConfig.defaultLocale || 'en';\n    }\n    else if (!Intl.NumberFormat.supportedLocalesOf(locale).length && onError) {\n        onError(new MissingDataError(\"Missing locale data for locale: \\\"\".concat(locale, \"\\\" in Intl.NumberFormat. Using default locale: \\\"\").concat(defaultLocale, \"\\\" as fallback. See https://formatjs.io/docs/react-intl#runtime-requirements for more details\")));\n    }\n    else if (!Intl.DateTimeFormat.supportedLocalesOf(locale).length &&\n        onError) {\n        onError(new MissingDataError(\"Missing locale data for locale: \\\"\".concat(locale, \"\\\" in Intl.DateTimeFormat. Using default locale: \\\"\").concat(defaultLocale, \"\\\" as fallback. See https://formatjs.io/docs/react-intl#runtime-requirements for more details\")));\n    }\n    verifyConfigMessages(resolvedConfig);\n    return __assign(__assign({}, resolvedConfig), { formatters: formatters, formatNumber: formatNumber.bind(null, resolvedConfig, formatters.getNumberFormat), formatNumberToParts: formatNumberToParts.bind(null, resolvedConfig, formatters.getNumberFormat), formatRelativeTime: formatRelativeTime.bind(null, resolvedConfig, formatters.getRelativeTimeFormat), formatDate: formatDate.bind(null, resolvedConfig, formatters.getDateTimeFormat), formatDateToParts: formatDateToParts.bind(null, resolvedConfig, formatters.getDateTimeFormat), formatTime: formatTime.bind(null, resolvedConfig, formatters.getDateTimeFormat), formatDateTimeRange: formatDateTimeRange.bind(null, resolvedConfig, formatters.getDateTimeFormat), formatTimeToParts: formatTimeToParts.bind(null, resolvedConfig, formatters.getDateTimeFormat), formatPlural: formatPlural.bind(null, resolvedConfig, formatters.getPluralRules), formatMessage: formatMessage.bind(null, resolvedConfig, formatters), $t: formatMessage.bind(null, resolvedConfig, formatters), formatList: formatList.bind(null, resolvedConfig, formatters.getListFormat), formatListToParts: formatListToParts.bind(null, resolvedConfig, formatters.getListFormat), formatDisplayName: formatDisplayName.bind(null, resolvedConfig, formatters.getDisplayNames) });\n}\n","//\n// Main\n//\nexport default function memoize(fn, options) {\n    var cache = options && options.cache ? options.cache : cacheDefault;\n    var serializer = options && options.serializer ? options.serializer : serializerDefault;\n    var strategy = options && options.strategy ? options.strategy : strategyDefault;\n    return strategy(fn, {\n        cache: cache,\n        serializer: serializer,\n    });\n}\n//\n// Strategy\n//\nfunction isPrimitive(value) {\n    return (value == null || typeof value === 'number' || typeof value === 'boolean'); // || typeof value === \"string\" 'unsafe' primitive for our needs\n}\nfunction monadic(fn, cache, serializer, arg) {\n    var cacheKey = isPrimitive(arg) ? arg : serializer(arg);\n    var computedValue = cache.get(cacheKey);\n    if (typeof computedValue === 'undefined') {\n        computedValue = fn.call(this, arg);\n        cache.set(cacheKey, computedValue);\n    }\n    return computedValue;\n}\nfunction variadic(fn, cache, serializer) {\n    var args = Array.prototype.slice.call(arguments, 3);\n    var cacheKey = serializer(args);\n    var computedValue = cache.get(cacheKey);\n    if (typeof computedValue === 'undefined') {\n        computedValue = fn.apply(this, args);\n        cache.set(cacheKey, computedValue);\n    }\n    return computedValue;\n}\nfunction assemble(fn, context, strategy, cache, serialize) {\n    return strategy.bind(context, fn, cache, serialize);\n}\nfunction strategyDefault(fn, options) {\n    var strategy = fn.length === 1 ? monadic : variadic;\n    return assemble(fn, this, strategy, options.cache.create(), options.serializer);\n}\nfunction strategyVariadic(fn, options) {\n    return assemble(fn, this, variadic, options.cache.create(), options.serializer);\n}\nfunction strategyMonadic(fn, options) {\n    return assemble(fn, this, monadic, options.cache.create(), options.serializer);\n}\n//\n// Serializer\n//\nvar serializerDefault = function () {\n    return JSON.stringify(arguments);\n};\n//\n// Cache\n//\nfunction ObjectWithoutPrototypeCache() {\n    this.cache = Object.create(null);\n}\nObjectWithoutPrototypeCache.prototype.get = function (key) {\n    return this.cache[key];\n};\nObjectWithoutPrototypeCache.prototype.set = function (key, value) {\n    this.cache[key] = value;\n};\nvar cacheDefault = {\n    create: function create() {\n        // @ts-ignore\n        return new ObjectWithoutPrototypeCache();\n    },\n};\nexport var strategies = {\n    variadic: strategyVariadic,\n    monadic: strategyMonadic,\n};\n","import { __assign, __spreadArray } from \"tslib\";\nimport { IntlMessageFormat } from 'intl-messageformat';\nimport memoize, { strategies } from '@formatjs/fast-memoize';\nimport { UnsupportedFormatterError } from './error';\nexport function filterProps(props, allowlist, defaults) {\n    if (defaults === void 0) { defaults = {}; }\n    return allowlist.reduce(function (filtered, name) {\n        if (name in props) {\n            filtered[name] = props[name];\n        }\n        else if (name in defaults) {\n            filtered[name] = defaults[name];\n        }\n        return filtered;\n    }, {});\n}\nvar defaultErrorHandler = function (error) {\n    // @ts-ignore just so we don't need to declare dep on @types/node\n    if (process.env.NODE_ENV !== 'production') {\n        console.error(error);\n    }\n};\nexport var DEFAULT_INTL_CONFIG = {\n    formats: {},\n    messages: {},\n    timeZone: undefined,\n    defaultLocale: 'en',\n    defaultFormats: {},\n    fallbackOnEmptyString: true,\n    onError: defaultErrorHandler,\n};\nexport function createIntlCache() {\n    return {\n        dateTime: {},\n        number: {},\n        message: {},\n        relativeTime: {},\n        pluralRules: {},\n        list: {},\n        displayNames: {},\n    };\n}\nfunction createFastMemoizeCache(store) {\n    return {\n        create: function () {\n            return {\n                get: function (key) {\n                    return store[key];\n                },\n                set: function (key, value) {\n                    store[key] = value;\n                },\n            };\n        },\n    };\n}\n/**\n * Create intl formatters and populate cache\n * @param cache explicit cache to prevent leaking memory\n */\nexport function createFormatters(cache) {\n    if (cache === void 0) { cache = createIntlCache(); }\n    var RelativeTimeFormat = Intl.RelativeTimeFormat;\n    var ListFormat = Intl.ListFormat;\n    var DisplayNames = Intl.DisplayNames;\n    var getDateTimeFormat = memoize(function () {\n        var _a;\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return new ((_a = Intl.DateTimeFormat).bind.apply(_a, __spreadArray([void 0], args, false)))();\n    }, {\n        cache: createFastMemoizeCache(cache.dateTime),\n        strategy: strategies.variadic,\n    });\n    var getNumberFormat = memoize(function () {\n        var _a;\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return new ((_a = Intl.NumberFormat).bind.apply(_a, __spreadArray([void 0], args, false)))();\n    }, {\n        cache: createFastMemoizeCache(cache.number),\n        strategy: strategies.variadic,\n    });\n    var getPluralRules = memoize(function () {\n        var _a;\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return new ((_a = Intl.PluralRules).bind.apply(_a, __spreadArray([void 0], args, false)))();\n    }, {\n        cache: createFastMemoizeCache(cache.pluralRules),\n        strategy: strategies.variadic,\n    });\n    return {\n        getDateTimeFormat: getDateTimeFormat,\n        getNumberFormat: getNumberFormat,\n        getMessageFormat: memoize(function (message, locales, overrideFormats, opts) {\n            return new IntlMessageFormat(message, locales, overrideFormats, __assign({ formatters: {\n                    getNumberFormat: getNumberFormat,\n                    getDateTimeFormat: getDateTimeFormat,\n                    getPluralRules: getPluralRules,\n                } }, (opts || {})));\n        }, {\n            cache: createFastMemoizeCache(cache.message),\n            strategy: strategies.variadic,\n        }),\n        getRelativeTimeFormat: memoize(function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            return new (RelativeTimeFormat.bind.apply(RelativeTimeFormat, __spreadArray([void 0], args, false)))();\n        }, {\n            cache: createFastMemoizeCache(cache.relativeTime),\n            strategy: strategies.variadic,\n        }),\n        getPluralRules: getPluralRules,\n        getListFormat: memoize(function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            return new (ListFormat.bind.apply(ListFormat, __spreadArray([void 0], args, false)))();\n        }, {\n            cache: createFastMemoizeCache(cache.list),\n            strategy: strategies.variadic,\n        }),\n        getDisplayNames: memoize(function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            return new (DisplayNames.bind.apply(DisplayNames, __spreadArray([void 0], args, false)))();\n        }, {\n            cache: createFastMemoizeCache(cache.displayNames),\n            strategy: strategies.variadic,\n        }),\n    };\n}\nexport function getNamedFormat(formats, type, name, onError) {\n    var formatType = formats && formats[type];\n    var format;\n    if (formatType) {\n        format = formatType[name];\n    }\n    if (format) {\n        return format;\n    }\n    onError(new UnsupportedFormatterError(\"No \".concat(type, \" format named: \").concat(name)));\n}\n","import { __assign } from \"tslib\";\nimport { ErrorKind } from './error';\nimport { Parser } from './parser';\nimport { isDateElement, isDateTimeSkeleton, isNumberElement, isNumberSkeleton, isPluralElement, isSelectElement, isTagElement, isTimeElement, } from './types';\nfunction pruneLocation(els) {\n    els.forEach(function (el) {\n        delete el.location;\n        if (isSelectElement(el) || isPluralElement(el)) {\n            for (var k in el.options) {\n                delete el.options[k].location;\n                pruneLocation(el.options[k].value);\n            }\n        }\n        else if (isNumberElement(el) && isNumberSkeleton(el.style)) {\n            delete el.style.location;\n        }\n        else if ((isDateElement(el) || isTimeElement(el)) &&\n            isDateTimeSkeleton(el.style)) {\n            delete el.style.location;\n        }\n        else if (isTagElement(el)) {\n            pruneLocation(el.children);\n        }\n    });\n}\nexport function parse(message, opts) {\n    if (opts === void 0) { opts = {}; }\n    opts = __assign({ shouldParseSkeletons: true, requiresOtherClause: true }, opts);\n    var result = new Parser(message, opts).parse();\n    if (result.err) {\n        var error = SyntaxError(ErrorKind[result.err.kind]);\n        // @ts-expect-error Assign to error object\n        error.location = result.err.location;\n        // @ts-expect-error Assign to error object\n        error.originalMessage = result.err.message;\n        throw error;\n    }\n    if (!(opts === null || opts === void 0 ? void 0 : opts.captureLocation)) {\n        pruneLocation(result.val);\n    }\n    return result.val;\n}\nexport * from './types';\n"],"sourceRoot":""}