{"version":3,"sources":["webpack://remark42/webpack/runtime/create fake namespace object","webpack://remark42/webpack/runtime/load script","webpack://remark42/./node_modules/bem-react-helper/index.js","webpack://remark42/./node_modules/classnames/index.js","webpack://remark42/./node_modules/fast-memoize/src/index.js","webpack://remark42/./node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js","webpack://remark42/./node_modules/hoist-non-react-statics/node_modules/react-is/cjs/react-is.production.min.js","webpack://remark42/./node_modules/hoist-non-react-statics/node_modules/react-is/index.js","webpack://remark42/./node_modules/shallow-equal/objects/index.js","webpack://remark42/./app/components/avatar-icon/avatar-icon.svg","webpack://remark42/webpack/bootstrap","webpack://remark42/webpack/runtime/compat get default export","webpack://remark42/webpack/runtime/define property getters","webpack://remark42/webpack/runtime/ensure chunk","webpack://remark42/webpack/runtime/get javascript chunk filename","webpack://remark42/webpack/runtime/get mini-css chunk filename","webpack://remark42/webpack/runtime/hasOwnProperty shorthand","webpack://remark42/webpack/runtime/make namespace object","webpack://remark42/webpack/runtime/publicPath","webpack://remark42/webpack/runtime/jsonp chunk loading","webpack://remark42/./node_modules/preact/dist/preact.module.js","webpack://remark42/./node_modules/react-intl/node_modules/tslib/tslib.es6.js","webpack://remark42/./node_modules/preact/hooks/dist/hooks.module.js","webpack://remark42/./node_modules/preact/compat/dist/compat.module.js","webpack://remark42/./node_modules/react-intl/lib/src/components/injectIntl.js","webpack://remark42/./node_modules/@formatjs/ecma402-abstract/lib/utils.js","webpack://remark42/./node_modules/@formatjs/intl/node_modules/tslib/tslib.es6.js","webpack://remark42/./node_modules/intl-messageformat/node_modules/tslib/tslib.es6.js","webpack://remark42/./node_modules/intl-messageformat-parser/node_modules/tslib/tslib.es6.js","webpack://remark42/./node_modules/intl-messageformat-parser/lib/src/types.js","webpack://remark42/./node_modules/intl-messageformat-parser/lib/src/skeleton.js","webpack://remark42/./node_modules/intl-messageformat-parser/lib/src/parser.js","webpack://remark42/./node_modules/intl-messageformat-parser/lib/src/normalize.js","webpack://remark42/./node_modules/intl-messageformat-parser/lib/index.js","webpack://remark42/./node_modules/intl-messageformat/lib/src/error.js","webpack://remark42/./node_modules/intl-messageformat/lib/src/formatters.js","webpack://remark42/./node_modules/intl-messageformat/lib/src/core.js","webpack://remark42/./node_modules/@formatjs/intl/lib/src/error.js","webpack://remark42/./node_modules/@formatjs/intl/lib/src/utils.js","webpack://remark42/./node_modules/react-intl/lib/src/utils.js","webpack://remark42/./node_modules/@formatjs/intl/lib/src/message.js","webpack://remark42/./node_modules/@formatjs/intl/lib/src/number.js","webpack://remark42/./node_modules/@formatjs/intl/lib/src/relativeTime.js","webpack://remark42/./node_modules/@formatjs/intl/lib/src/dateTime.js","webpack://remark42/./node_modules/@formatjs/intl/lib/src/plural.js","webpack://remark42/./node_modules/@formatjs/intl/lib/src/list.js","webpack://remark42/./node_modules/@formatjs/intl/lib/src/displayName.js","webpack://remark42/./node_modules/@formatjs/intl/lib/src/create-intl.js","webpack://remark42/./node_modules/react-intl/lib/src/components/provider.js","webpack://remark42/./node_modules/react-intl/lib/src/components/createFormattedComponent.js","webpack://remark42/./node_modules/react-intl/lib/index.js","webpack://remark42/./app/utils/errorUtils.ts","webpack://remark42/./app/common/constants.config.ts","webpack://remark42/./app/common/constants.ts","webpack://remark42/./app/common/settings.ts","webpack://remark42/./app/utils/parseQuery.ts","webpack://remark42/./app/common/static-store.ts","webpack://remark42/./app/common/fetcher.ts","webpack://remark42/./app/common/cookies.ts","webpack://remark42/./app/common/api.getLastComments.ts","webpack://remark42/./app/utils/loadLocale.ts","webpack://remark42/./node_modules/react-intl/lib/src/components/useIntl.js","webpack://remark42/./app/common/accessibility.ts","webpack://remark42/./app/common/types.ts","webpack://remark42/./app/components/avatar-icon/avatar-icon.tsx","webpack://remark42/./app/components/button/button.tsx","webpack://remark42/./app/components/countdown/index.tsx","webpack://remark42/./app/utils/exclude.ts","webpack://remark42/./node_modules/react-intl/lib/src/components/message.js","webpack://remark42/./app/components/comment/getVoteMessage.ts","webpack://remark42/./app/components/comment/getBlockingDurations.ts","webpack://remark42/./app/components/comment/comment.tsx","webpack://remark42/./app/utils/debounce.ts","webpack://remark42/./app/utils/postMessage.ts","webpack://remark42/./app/common/copy.ts","webpack://remark42/./app/utils/isUserAnonymous.ts","webpack://remark42/./app/components/list-comments/list-comments.tsx","webpack://remark42/./app/components/list-comments/list-comments.module.css?ab8a","webpack://remark42/./app/last-comments.tsx","webpack://remark42/./app/utils/getLocale.ts"],"names":["leafPrototypes","getProto","inProgress","dataWebpackPrefix","b","name","props","arguments","length","undefined","defaultMods","result","_props$mix","mix","_props$mods","mods","addMod","key","value","mod","camelToKebab","push","join","Object","keys","forEach","hasOwnProperty","concat","str","toString","replace","toLowerCase","defineProperty","exports","module","default","hasOwn","classNames","classes","i","arg","argType","Array","isArray","inner","apply","call","monadic","fn","cache","serializer","cacheKey","computedValue","get","this","set","variadic","args","prototype","slice","assemble","context","strategy","serialize","bind","strategyDefault","options","create","serializerDefault","JSON","stringify","ObjectWithoutPrototypeCache","has","cacheDefault","strategies","reactIs","REACT_STATICS","childContextTypes","contextType","contextTypes","defaultProps","displayName","getDefaultProps","getDerivedStateFromError","getDerivedStateFromProps","mixins","propTypes","type","KNOWN_STATICS","caller","callee","arity","MEMO_STATICS","compare","TYPE_STATICS","getStatics","component","isMemo","ForwardRef","render","Memo","getOwnPropertyNames","getOwnPropertySymbols","getOwnPropertyDescriptor","getPrototypeOf","objectPrototype","hoistNonReactStatics","targetComponent","sourceComponent","blacklist","inheritedComponent","targetStatics","sourceStatics","descriptor","e","Symbol","for","c","d","f","g","h","k","l","m","n","p","q","r","t","v","w","x","y","z","a","u","$$typeof","A","AsyncMode","ConcurrentMode","ContextConsumer","ContextProvider","Element","Fragment","Lazy","Portal","Profiler","StrictMode","Suspense","isAsyncMode","isConcurrentMode","isContextConsumer","isContextProvider","isElement","isForwardRef","isFragment","isLazy","isPortal","isProfiler","isStrictMode","isSuspense","isValidElementType","typeOf","objA","objB","aKeys","bKeys","len","__webpack_module_cache__","__webpack_require__","moduleId","__webpack_modules__","getter","__esModule","obj","mode","then","ns","def","current","indexOf","definition","o","enumerable","chunkId","Promise","all","reduce","promises","miniCssF","prop","url","done","script","needAttach","scripts","document","getElementsByTagName","s","getAttribute","createElement","charset","timeout","nc","setAttribute","src","onScriptComplete","prev","event","onerror","onload","clearTimeout","doneFns","parentNode","removeChild","setTimeout","target","head","appendChild","toStringTag","installedChunks","668","j","installedChunkData","promise","resolve","reject","error","Error","errorType","realSrc","message","request","webpackJsonpCallback","parentChunkLoadingFunction","data","chunkIds","moreModules","runtime","resolves","shift","chunkLoadingGlobal","self","children","ref","__k","__","__b","__e","__d","__c","__h","constructor","__v","vnode","_","base","__r","debounceRendering","sort","some","__P","T","__n","ownerSVGElement","P","L","I","nextSibling","insertBefore","setProperty","test","C","style","cssText","addEventListener","H","$","removeEventListener","removeAttribute","__E","M","sub","state","__s","componentWillMount","componentDidMount","componentWillReceiveProps","shouldComponentUpdate","componentWillUpdate","componentDidUpdate","getChildContext","getSnapshotBeforeUpdate","diffed","localName","nodeType","createTextNode","createElementNS","is","childNodes","dangerouslySetInnerHTML","attributes","__html","innerHTML","firstChild","checked","unmount","componentWillUnmount","N","O","S","Consumer","Provider","splice","setState","componentDidCatch","forceUpdate","extendStatics","setPrototypeOf","__proto__","__extends","assign","__rest","propertyIsEnumerable","__spreadArrays","il","jl","__H","F","useDebugValue","requestAnimationFrame","cancelAnimationFrame","filter","E","isReactComponent","__f","isPureReactComponent","R","map","count","only","toArray","__u","U","D","__O","pop","fallback","delete","revealOrder","size","Map","reverse","W","V","textContent","configurable","writable","B","Z","cancelBubble","Y","defaultPrevented","persist","isPropagationStopped","isDefaultPrevented","nativeEvent","class","G","multiple","selected","defaultValue","className","J","K","ReactCurrentDispatcher","readContext","Q","X","nn","tn","en","rn","un","performance","now","Date","on","ln","cn","an","sn","hn","pn","useState","useReducer","useEffect","useLayoutEffect","useRef","useImperativeHandle","useMemo","useCallback","useContext","version","Children","hydrate","unmountComponentAtNode","createPortal","createContext","createFactory","cloneElement","createRef","isValidElement","findDOMNode","Component","PureComponent","memo","forwardRef","unstable_batchedUpdates","SuspenseList","lazy","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","IntlContext","Context","invariant","condition","Err","TypeError","String","TYPE","SKELETON_TYPE","isLiteralElement","el","literal","isArgumentElement","argument","isNumberElement","number","isDateElement","date","isTimeElement","time","isSelectElement","select","isPluralElement","plural","isPoundElement","pound","isTagElement","tag","isNumberSkeleton","isDateTimeSkeleton","DATE_TIME_REGEX","FRACTION_PRECISION_REGEX","SIGNIFICANT_PRECISION_REGEX","INTEGER_WIDTH_REGEX","CONCISE_INTEGER_WIDTH_REGEX","parseSignificantPrecision","g1","g2","minimumSignificantDigits","maximumSignificantDigits","parseSign","signDisplay","currencySign","parseConciseScientificAndEngineeringStem","stem","notation","minimumIntegerDigits","parseNotationOptions","opt","parseNumberSkeleton","tokens","_i","tokens_1","token","scale","currency","useGrouping","maximumFractionDigits","unit","compactDisplay","currencyDisplay","unitDisplay","parseFloat","RangeError","g3","g4","g5","minimumFractionDigits","signOpts","conciseScientificAndEngineeringOpts","SyntaxError","_super","expected","found","location","_this","captureStackTrace","buildMessage","hex","ch","charCodeAt","toUpperCase","literalEscape","classEscape","describeExpectation","expectation","text","escapedParts","parts","part","inverted","description","expected1","descriptions","describeExpected","found1","pegParse","input","peg$result","peg$FAILED","peg$startRuleFunctions","start","peg$parsestart","peg$startRuleFunction","peg$c3","peg$c4","peg$literalExpectation","peg$c5","peg$c9","peg$c11","peg$otherExpectation","peg$c14","peg$c17","peg$c20","peg$c21","peg$c22","peg$c23","peg$c24","peg$c25","peg$c27","peg$c28","peg$c29","peg$classExpectation","peg$c30","peg$c31","peg$c33","peg$c35","peg$c38","peg$c39","peg$c42","messageCtx","peg$c43","peg$c44","peg$c45","peg$c46","peg$c47","insertLocation","peg$c48","peg$c49","peg$c50","peg$c51","peg$c52","peg$c53","peg$c54","peg$c55","peg$c58","peg$c59","peg$c60","peg$c61","peg$c62","peg$c63","peg$c64","peg$c65","peg$c66","peg$c67","peg$c69","peg$c70","peg$c73","peg$c78","peg$c79","peg$c80","peg$c81","peg$c82","peg$c83","peg$c84","peg$c85","peg$c87","peg$c90","peg$c91","peg$c92","peg$c97","peg$c99","peg$c100","peg$c101","peg$c103","peg$c105","peg$c106","peg$c107","peg$c108","peg$c110","peg$c111","peg$currPos","peg$savedPos","peg$posDetailsCache","line","column","peg$maxFailPos","peg$maxFailExpected","peg$silentFails","startRule","substring","peg$computeLocation","location1","peg$buildSimpleError","text1","ignoreCase","peg$computePosDetails","pos","details","startPos","endPos","startPosDetails","endPosDetails","offset","end","peg$fail","peg$parsemessage","s0","s1","peg$parsemessageElement","s2","ignoreTag","s3","open","close","peg$parseselfClosingTag","peg$parseopeningTag","peg$parseclosingTag","peg$parsetagElement","messageText","peg$parsemessageText","peg$parseliteralElement","s5","peg$parse_","peg$parseargNameOrNumber","peg$parseargumentElement","s7","s9","s10","s11","s12","substr","peg$parsenumberSkeletonToken","parsedOptions","shouldParseSkeleton","peg$parsenumberSkeleton","peg$parsenumberArgStyle","peg$parsenumberFormatElement","pattern","skeleton","peg$parsedateTimeSkeletonLiteral","peg$parsedateTimeSkeletonPattern","match","era","year","month","day","weekday","hour12","hourCycle","hour","minute","second","timeZoneName","peg$parsedateTimeSkeleton","peg$parsedateOrTimeArgStyle","peg$parsedateOrTimeFormatElement","peg$parsesimpleFormatElement","s13","s14","s15","peg$parsenumber","peg$parsepluralOption","pluralType","_a","id","optionLocation","peg$c68","peg$parsepluralElement","peg$parseselectOption","peg$c71","peg$parseselectElement","peg$parsepoundElement","peg$parsedoubleApostrophes","peg$parsequotedString","peg$parseunquotedString","peg$parsenonTagStartingAngleBracket","s4","peg$parsevalidTag","peg$parsenumberSkeletonId","peg$parsewhiteSpace","charAt","peg$parsenumberSkeletonTokenOption","peg$c36","s6","peg$parseargName","peg$parsepluralRuleSelectValue","peg$parsepatternSyntax","num","peg$parseargNumber","isInPluralOption","peg$c98","peg$parseescapedChar","peg$c95","peg$parsetagName","parseInt","captureLocation","PLURAL_HASHTAG_REGEX","normalizeHashtagInPlural","els","matchingLiteralElIndex","literalEl","el_1","newValue","newEls","parse","opts","ErrorCode","PART_TYPE","FormatError","msg","code","originalMessage","InvalidValueError","variableId","InvalidValueTypeError","MissingValueError","isFormatXMLElementFn","formatToParts","locales","formatters","formats","values","currentPluralValue","els_1","getNumberFormat","format","varName","getDateTimeFormat","value_1","formatFn","chunks","other","Intl","PluralRules","rule","getPluralRules","lastPart","createFastMemoizeCache","store","IntlErrorCode","memoizeIntl","IntlMessageFormat","overrideFormats","defaultConfig","configs","defaultLocale","formatterCache","dateTime","pluralRules","ast","resolvedOptions","locale","NumberFormat","supportedLocalesOf","getAst","__parse","c1","c2","DateTimeFormat","memoizedDefaultLocale","percent","short","medium","long","full","IntlError","exception","stack","UnsupportedFormatterError","UNSUPPORTED_FORMATTER","InvalidConfigError","INVALID_CONFIG","MissingDataError","MISSING_DATA","MessageFormatError","FORMAT_ERROR","defaultMessage","MissingTranslationError","MISSING_TRANSLATION","filterProps","whitelist","defaults","filtered","DEFAULT_INTL_CONFIG","messages","timeZone","defaultFormats","onError","getNamedFormat","formatType","intl","textComponent","setTimeZoneInOptions","deepMergeOptions","opts1","opts2","deepMergeFormatsAndSetTimeZone","f1","mfFormats","formatMessage","messageDescriptor","defaultRichTextElements","msgId","getMessageFormat","NUMBER_FORMAT_OPTIONS","getFormatter","formatNumber","config","formatNumberToParts","RELATIVE_TIME_FORMAT_OPTIONS","formatRelativeTime","getRelativeTimeFormat","RelativeTimeFormat","DATE_TIME_FORMAT_OPTIONS","filteredOptions","timeStyle","dateStyle","formatDate","_b","formatTime","formatDateTimeRange","from","to","formatRange","formatDateToParts","formatTimeToParts","PLURAL_FORMAT_OPTIONS","formatPlural","LIST_FORMAT_OPTIONS","formatList","getListFormat","ListFormat","richValues_1","serializedValues","generateToken","val","DISPLAY_NAMES_OPTONS","formatDisplayName","getDisplayNames","DisplayNames","of","createIntl","relativeTime","list","displayNames","createFormatters","resolvedConfig","messagesContainString","console","warn","verifyConfigMessages","shallowEquals","processIntlConfig","wrapRichTextChunksInFragment","assignUniqueKeysToFormatXMLElementFnArgument","acc","formatXMLElementFn","rawValues","rest","rawDefaultRichTextElements","coreIntl","IntlProvider","prevConfig","DisplayName","DisplayNameParts","createFormattedDateTimePartsComponent","ComponentParts","formatProps","createFormattedComponent","formattedValue","failedFetch","0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","errorMessageForCodes","entries","httpMessages","notAuthorized","forbidden","toManyRequest","unexpectedError","httpErrorMap","extractErrorMessageFromResponse","response","defaultErrorMessage","RequestError","super","BASE_URL","window","remark_config","host","THEMES","querySettings","navigator","userAgent","localStorage","setItem","removeItem","parent","search","params","URLSearchParams","parseQuery","max_shown_comments","theme","show_email_subscription","siteId","site_id","page_title","StaticStore","edit_duration","max_comment_size","admins","admin_email","auth_providers","critical_score","low_score","positive_score","readonly_age","max_image_size","simple_view","anon_vote","email_notifications","emoji_enabled","query","JWT_HEADER","activeJwtToken","createFetcher","baseUrl","method","uri","body","queryString","site","headers","matches","cookie","RegExp","decodeURIComponent","getCookie","FormData","res","fetch","timestamp","isNaN","timeDiff","getTime","includes","status","err","json","put","post","apiFetcher","getLastComments","max","enMessages","loadLocale","catch","useIntl","getHandleClickProps","handler","role","onClick","onKeyPress","preventDefault","handleBtnKeyPress","tabIndex","CommentMode","AvatarIcon","picture","alt","Button","kind","Countdown","elemRef","nextProps","clearInterval","intervalID","Math","toFixed","innerText","onTimePassed","tick","setInterval","exclude","clone","item","FormattedMessage","otherProps","nextValues","nextOtherProps","Text","_c","tagName","nodes","voteMessages","VoteMessagesTypes","getVoteMessage","OWN_COMMENT","GUEST","ONLY_POST_PAGE","READONLY","DELETED","ANONYMOUS","ONLY_POSITIVE","blockingMessages","getBlockingDurations","label","getTextSnippet","html","tmp","snippet","FormatTime","votingPromise","textNode","updateState","newState","scoreDelta","vote","cachedScore","score","inView","renderDummy","user","editDuration","serverClientTimeDiff","editDeadline","isCopied","voteErrorMessage","initial","toggleReplying","editMode","setReplyEditState","Reply","None","toggleEditing","Edit","toggleUserInfoVisibility","isUserInfoShown","postMessage","togglePin","pin","promptMessage","confirm","setPinState","toggleVerify","verified","userId","userName","setVerifiedStatus","onBlockUserClick","blur","blockUser","wait","debounce","ttl","blockDuration","find","duration","onUnblockUserClick","unblockUser","deleteComment","removeComment","hideUser","hideUserComment","handleVoteError","originalScore","originalDelta","sendVotingRequest","votingValue","putCommentVote","increaseScore","decreaseScore","addComment","title","pid","updateComment","scrollToParent","parentCommentNode","getElementById","scrollTo","getBoundingClientRect","top","scrollIntoView","copyComment","element","previouslyFocusedElement","activeElement","contain","position","left","fontSize","selection","getSelection","originalRange","rangeCount","getRangeAt","append","selectionStart","selectionEnd","isSuccess","execCommand","remove","removeAllRanges","addRange","focus","copy","isAdmin","admin","isGuest","isAnonymous","isCurrentUser","getDownvoteDisabledReason","view","post_info","read_only","getUpvoteDisabledReason","getCommentControls","controls","isUserBanned","blockingDurations","onBlur","onChange","disabled","block","isReplying","isEditing","lowCommentScore","downvotingDisabledReason","isDownvotingDisabled","upvotingDisabledReason","isUpvotingDisabled","editable","repliesCount","scoreSignEnabled","uploadImageHandler","uploadImage","commentControls","CommentForm","controversyText","controversy","orig","entity","span","abs","sign","pinned","useless","guest","replying","editing","level","collapsed","href","locator","width","height","scrollWidth","scrollHeight","goToParentMessage","aria-label","active","clickable","aria-disabled","isCommentsDisabled","onSubmit","onCancel","getPreview","autofocus","simpleView","errorMessage","comments","comment","init","getElementsByClassName","max_last_comments","styles","rel","node","dataset","readyState"],"mappings":"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","file":"last-comments.mjs","sourcesContent":["var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);\nvar leafPrototypes;\n// create a fake namespace object\n// mode & 1: value is a module id, require it\n// mode & 2: merge all properties of value into the ns\n// mode & 4: return value when already ns object\n// mode & 16: return value when it's Promise-like\n// mode & 8|1: behave like require\n__webpack_require__.t = function(value, mode) {\n\tif(mode & 1) value = this(value);\n\tif(mode & 8) return value;\n\tif(typeof value === 'object' && value) {\n\t\tif((mode & 4) && value.__esModule) return value;\n\t\tif((mode & 16) && typeof value.then === 'function') return value;\n\t}\n\tvar ns = Object.create(null);\n\t__webpack_require__.r(ns);\n\tvar def = {};\n\tleafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];\n\tfor(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {\n\t\tObject.getOwnPropertyNames(current).forEach(key => def[key] = () => value[key]);\n\t}\n\tdef['default'] = () => value;\n\t__webpack_require__.d(ns, def);\n\treturn ns;\n};","var inProgress = {};\nvar dataWebpackPrefix = \"remark42:\";\n// loadScript function to load a script via script tag\n__webpack_require__.l = (url, done, key, chunkId) => {\n\tif(inProgress[url]) { inProgress[url].push(done); return; }\n\tvar script, needAttach;\n\tif(key !== undefined) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tfor(var i = 0; i < scripts.length; i++) {\n\t\t\tvar s = scripts[i];\n\t\t\tif(s.getAttribute(\"src\") == url || s.getAttribute(\"data-webpack\") == dataWebpackPrefix + key) { script = s; break; }\n\t\t}\n\t}\n\tif(!script) {\n\t\tneedAttach = true;\n\t\tscript = document.createElement('script');\n\n\t\tscript.charset = 'utf-8';\n\t\tscript.timeout = 120;\n\t\tif (__webpack_require__.nc) {\n\t\t\tscript.setAttribute(\"nonce\", __webpack_require__.nc);\n\t\t}\n\t\tscript.setAttribute(\"data-webpack\", dataWebpackPrefix + key);\n\t\tscript.src = url;\n\t}\n\tinProgress[url] = [done];\n\tvar onScriptComplete = (prev, event) => {\n\t\t// avoid mem leaks in IE.\n\t\tscript.onerror = script.onload = null;\n\t\tclearTimeout(timeout);\n\t\tvar doneFns = inProgress[url];\n\t\tdelete inProgress[url];\n\t\tscript.parentNode && script.parentNode.removeChild(script);\n\t\tdoneFns && doneFns.forEach((fn) => (fn(event)));\n\t\tif(prev) return prev(event);\n\t}\n\t;\n\tvar timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), 120000);\n\tscript.onerror = onScriptComplete.bind(null, script.onerror);\n\tscript.onload = onScriptComplete.bind(null, script.onload);\n\tneedAttach && document.head.appendChild(script);\n};","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nmodule.exports = b;\nexports.default = b;\n\n\nfunction b(name) {\n  var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  var defaultMods = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n  var result = [name];\n  var _props$mix = props.mix,\n      mix = _props$mix === undefined ? [] : _props$mix,\n      _props$mods = props.mods,\n      mods = _props$mods === undefined ? {} : _props$mods;\n\n  var addMod = function addMod(key, value) {\n    var mod = [name, camelToKebab(key)];\n\n    if (typeof value !== 'boolean') {\n      mod.push(camelToKebab(value));\n    }\n\n    result.push(mod.join('_'));\n  };\n\n  Object.keys(defaultMods).forEach(function (key) {\n    if (!mods.hasOwnProperty(key) && defaultMods[key]) {\n      addMod(key, defaultMods[key]);\n    }\n  });\n\n  Object.keys(mods).forEach(function (key) {\n    if (mods[key]) {\n      addMod(key, mods[key]);\n    }\n  });\n\n  if (mix) {\n    result = result.concat(mix);\n  }\n\n  return result.join(' ');\n}\n\nfunction camelToKebab(str) {\n  return str.toString().replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();\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","//\n// Main\n//\n\nfunction memoize (fn, options) {\n  var cache = options && options.cache\n    ? options.cache\n    : cacheDefault\n\n  var serializer = options && options.serializer\n    ? options.serializer\n    : serializerDefault\n\n  var strategy = options && options.strategy\n    ? options.strategy\n    : strategyDefault\n\n  return strategy(fn, {\n    cache: cache,\n    serializer: serializer\n  })\n}\n\n//\n// Strategy\n//\n\nfunction isPrimitive (value) {\n  return value == null || typeof value === 'number' || typeof value === 'boolean' // || typeof value === \"string\" 'unsafe' primitive for our needs\n}\n\nfunction monadic (fn, cache, serializer, arg) {\n  var cacheKey = isPrimitive(arg) ? arg : serializer(arg)\n\n  var computedValue = cache.get(cacheKey)\n  if (typeof computedValue === 'undefined') {\n    computedValue = fn.call(this, arg)\n    cache.set(cacheKey, computedValue)\n  }\n\n  return computedValue\n}\n\nfunction variadic (fn, cache, serializer) {\n  var args = Array.prototype.slice.call(arguments, 3)\n  var cacheKey = serializer(args)\n\n  var computedValue = cache.get(cacheKey)\n  if (typeof computedValue === 'undefined') {\n    computedValue = fn.apply(this, args)\n    cache.set(cacheKey, computedValue)\n  }\n\n  return computedValue\n}\n\nfunction assemble (fn, context, strategy, cache, serialize) {\n  return strategy.bind(\n    context,\n    fn,\n    cache,\n    serialize\n  )\n}\n\nfunction strategyDefault (fn, options) {\n  var strategy = fn.length === 1 ? monadic : variadic\n\n  return assemble(\n    fn,\n    this,\n    strategy,\n    options.cache.create(),\n    options.serializer\n  )\n}\n\nfunction strategyVariadic (fn, options) {\n  var strategy = variadic\n\n  return assemble(\n    fn,\n    this,\n    strategy,\n    options.cache.create(),\n    options.serializer\n  )\n}\n\nfunction strategyMonadic (fn, options) {\n  var strategy = monadic\n\n  return assemble(\n    fn,\n    this,\n    strategy,\n    options.cache.create(),\n    options.serializer\n  )\n}\n\n//\n// Serializer\n//\n\nfunction serializerDefault () {\n  return JSON.stringify(arguments)\n}\n\n//\n// Cache\n//\n\nfunction ObjectWithoutPrototypeCache () {\n  this.cache = Object.create(null)\n}\n\nObjectWithoutPrototypeCache.prototype.has = function (key) {\n  return (key in this.cache)\n}\n\nObjectWithoutPrototypeCache.prototype.get = function (key) {\n  return this.cache[key]\n}\n\nObjectWithoutPrototypeCache.prototype.set = function (key, value) {\n  this.cache[key] = value\n}\n\nvar cacheDefault = {\n  create: function create () {\n    return new ObjectWithoutPrototypeCache()\n  }\n}\n\n//\n// API\n//\n\nmodule.exports = memoize\nmodule.exports.strategies = {\n  variadic: strategyVariadic,\n  monadic: strategyMonadic\n}\n","'use strict';\n\nvar reactIs = require('react-is');\n\n/**\n * Copyright 2015, Yahoo! Inc.\n * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.\n */\nvar REACT_STATICS = {\n  childContextTypes: true,\n  contextType: true,\n  contextTypes: true,\n  defaultProps: true,\n  displayName: true,\n  getDefaultProps: true,\n  getDerivedStateFromError: true,\n  getDerivedStateFromProps: true,\n  mixins: true,\n  propTypes: true,\n  type: true\n};\nvar KNOWN_STATICS = {\n  name: true,\n  length: true,\n  prototype: true,\n  caller: true,\n  callee: true,\n  arguments: true,\n  arity: true\n};\nvar FORWARD_REF_STATICS = {\n  '$$typeof': true,\n  render: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true\n};\nvar MEMO_STATICS = {\n  '$$typeof': true,\n  compare: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true,\n  type: true\n};\nvar TYPE_STATICS = {};\nTYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;\nTYPE_STATICS[reactIs.Memo] = MEMO_STATICS;\n\nfunction getStatics(component) {\n  // React v16.11 and below\n  if (reactIs.isMemo(component)) {\n    return MEMO_STATICS;\n  } // React v16.12 and above\n\n\n  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;\n}\n\nvar defineProperty = Object.defineProperty;\nvar getOwnPropertyNames = Object.getOwnPropertyNames;\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar getPrototypeOf = Object.getPrototypeOf;\nvar objectPrototype = Object.prototype;\nfunction hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {\n  if (typeof sourceComponent !== 'string') {\n    // don't hoist over string (html) components\n    if (objectPrototype) {\n      var inheritedComponent = getPrototypeOf(sourceComponent);\n\n      if (inheritedComponent && inheritedComponent !== objectPrototype) {\n        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);\n      }\n    }\n\n    var keys = getOwnPropertyNames(sourceComponent);\n\n    if (getOwnPropertySymbols) {\n      keys = keys.concat(getOwnPropertySymbols(sourceComponent));\n    }\n\n    var targetStatics = getStatics(targetComponent);\n    var sourceStatics = getStatics(sourceComponent);\n\n    for (var i = 0; i < keys.length; ++i) {\n      var key = keys[i];\n\n      if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {\n        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);\n\n        try {\n          // Avoid failures from read-only properties\n          defineProperty(targetComponent, key, descriptor);\n        } catch (e) {}\n      }\n    }\n  }\n\n  return targetComponent;\n}\n\nmodule.exports = hoistNonReactStatics;\n","/** @license React v16.13.1\n * react-is.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';var b=\"function\"===typeof Symbol&&Symbol.for,c=b?Symbol.for(\"react.element\"):60103,d=b?Symbol.for(\"react.portal\"):60106,e=b?Symbol.for(\"react.fragment\"):60107,f=b?Symbol.for(\"react.strict_mode\"):60108,g=b?Symbol.for(\"react.profiler\"):60114,h=b?Symbol.for(\"react.provider\"):60109,k=b?Symbol.for(\"react.context\"):60110,l=b?Symbol.for(\"react.async_mode\"):60111,m=b?Symbol.for(\"react.concurrent_mode\"):60111,n=b?Symbol.for(\"react.forward_ref\"):60112,p=b?Symbol.for(\"react.suspense\"):60113,q=b?\nSymbol.for(\"react.suspense_list\"):60120,r=b?Symbol.for(\"react.memo\"):60115,t=b?Symbol.for(\"react.lazy\"):60116,v=b?Symbol.for(\"react.block\"):60121,w=b?Symbol.for(\"react.fundamental\"):60117,x=b?Symbol.for(\"react.responder\"):60118,y=b?Symbol.for(\"react.scope\"):60119;\nfunction z(a){if(\"object\"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return a;default:return u}}case d:return u}}}function A(a){return z(a)===m}exports.AsyncMode=l;exports.ConcurrentMode=m;exports.ContextConsumer=k;exports.ContextProvider=h;exports.Element=c;exports.ForwardRef=n;exports.Fragment=e;exports.Lazy=t;exports.Memo=r;exports.Portal=d;\nexports.Profiler=g;exports.StrictMode=f;exports.Suspense=p;exports.isAsyncMode=function(a){return A(a)||z(a)===l};exports.isConcurrentMode=A;exports.isContextConsumer=function(a){return z(a)===k};exports.isContextProvider=function(a){return z(a)===h};exports.isElement=function(a){return\"object\"===typeof a&&null!==a&&a.$$typeof===c};exports.isForwardRef=function(a){return z(a)===n};exports.isFragment=function(a){return z(a)===e};exports.isLazy=function(a){return z(a)===t};\nexports.isMemo=function(a){return z(a)===r};exports.isPortal=function(a){return z(a)===d};exports.isProfiler=function(a){return z(a)===g};exports.isStrictMode=function(a){return z(a)===f};exports.isSuspense=function(a){return z(a)===p};\nexports.isValidElementType=function(a){return\"string\"===typeof a||\"function\"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||\"object\"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v)};exports.typeOf=z;\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-is.production.min.js');\n} else {\n  module.exports = require('./cjs/react-is.development.js');\n}\n","'use strict';\n\nfunction shallowEqualObjects(objA, objB) {\n  if (objA === objB) {\n    return true;\n  }\n\n  if (!objA || !objB) {\n    return false;\n  }\n\n  var aKeys = Object.keys(objA);\n  var bKeys = Object.keys(objB);\n  var len = aKeys.length;\n\n  if (bKeys.length !== len) {\n    return false;\n  }\n\n  for (var i = 0; i < len; i++) {\n    var key = aKeys[i];\n\n    if (objA[key] !== objB[key] || !Object.prototype.hasOwnProperty.call(objB, key)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nmodule.exports = shallowEqualObjects;\n","export default \"/web/avatar-icon.svg\";","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tif(__webpack_module_cache__[moduleId]) {\n\t\treturn __webpack_module_cache__[moduleId].exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.f = {};\n// This file contains only the entry chunk.\n// The chunk loading function for additional chunks\n__webpack_require__.e = (chunkId) => {\n\treturn Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {\n\t\t__webpack_require__.f[key](chunkId, promises);\n\t\treturn promises;\n\t}, []));\n};","// This function allow to reference async chunks\n__webpack_require__.u = (chunkId) => {\n\t// return url for filenames based on template\n\treturn \"\" + {\"43\":\"ja\",\"135\":\"fi\",\"220\":\"ua\",\"231\":\"fr\",\"300\":\"tr\",\"313\":\"be\",\"352\":\"es\",\"372\":\"bg\",\"491\":\"ko\",\"640\":\"pl\",\"677\":\"bp\",\"697\":\"ru\",\"913\":\"de\",\"922\":\"zh\",\"936\":\"vi\"}[chunkId] + \".mjs\";\n};","// This function allow to reference all chunks\n__webpack_require__.miniCssF = (chunkId) => {\n\t// return url for filenames based on template\n\treturn undefined;\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.p = \"/web/\";","// no baseURI\n\n// object to store loaded and loading chunks\n// undefined = chunk not loaded, null = chunk preloaded/prefetched\n// Promise = chunk loading, 0 = chunk loaded\nvar installedChunks = {\n\t668: 0\n};\n\n\n__webpack_require__.f.j = (chunkId, promises) => {\n\t\t// JSONP chunk loading for javascript\n\t\tvar installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;\n\t\tif(installedChunkData !== 0) { // 0 means \"already installed\".\n\n\t\t\t// a Promise means \"currently loading\".\n\t\t\tif(installedChunkData) {\n\t\t\t\tpromises.push(installedChunkData[2]);\n\t\t\t} else {\n\t\t\t\tif(true) { // all chunks have JS\n\t\t\t\t\t// setup Promise in chunk cache\n\t\t\t\t\tvar promise = new Promise((resolve, reject) => {\n\t\t\t\t\t\tinstalledChunkData = installedChunks[chunkId] = [resolve, reject];\n\t\t\t\t\t});\n\t\t\t\t\tpromises.push(installedChunkData[2] = promise);\n\n\t\t\t\t\t// start chunk loading\n\t\t\t\t\tvar url = __webpack_require__.p + __webpack_require__.u(chunkId);\n\t\t\t\t\t// create error before stack unwound to get useful stacktrace later\n\t\t\t\t\tvar error = new Error();\n\t\t\t\t\tvar loadingEnded = (event) => {\n\t\t\t\t\t\tif(__webpack_require__.o(installedChunks, chunkId)) {\n\t\t\t\t\t\t\tinstalledChunkData = installedChunks[chunkId];\n\t\t\t\t\t\t\tif(installedChunkData !== 0) installedChunks[chunkId] = undefined;\n\t\t\t\t\t\t\tif(installedChunkData) {\n\t\t\t\t\t\t\t\tvar errorType = event && (event.type === 'load' ? 'missing' : event.type);\n\t\t\t\t\t\t\t\tvar realSrc = event && event.target && event.target.src;\n\t\t\t\t\t\t\t\terror.message = 'Loading chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';\n\t\t\t\t\t\t\t\terror.name = 'ChunkLoadError';\n\t\t\t\t\t\t\t\terror.type = errorType;\n\t\t\t\t\t\t\t\terror.request = realSrc;\n\t\t\t\t\t\t\t\tinstalledChunkData[1](error);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t\t__webpack_require__.l(url, loadingEnded, \"chunk-\" + chunkId, chunkId);\n\t\t\t\t} else installedChunks[chunkId] = 0;\n\t\t\t}\n\t\t}\n};\n\n// no prefetching\n\n// no preloaded\n\n// no HMR\n\n// no HMR manifest\n\n// no deferred startup\n\n// install a JSONP callback for chunk loading\nvar webpackJsonpCallback = (parentChunkLoadingFunction, data) => {\n\tvar [chunkIds, moreModules, runtime] = data;\n\t// add \"moreModules\" to the modules object,\n\t// then flag all \"chunkIds\" as loaded and fire callback\n\tvar moduleId, chunkId, i = 0, resolves = [];\n\tfor(;i < chunkIds.length; i++) {\n\t\tchunkId = chunkIds[i];\n\t\tif(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {\n\t\t\tresolves.push(installedChunks[chunkId][0]);\n\t\t}\n\t\tinstalledChunks[chunkId] = 0;\n\t}\n\tfor(moduleId in moreModules) {\n\t\tif(__webpack_require__.o(moreModules, moduleId)) {\n\t\t\t__webpack_require__.m[moduleId] = moreModules[moduleId];\n\t\t}\n\t}\n\tif(runtime) runtime(__webpack_require__);\n\tif(parentChunkLoadingFunction) parentChunkLoadingFunction(data);\n\twhile(resolves.length) {\n\t\tresolves.shift()();\n\t}\n\n}\n\nvar chunkLoadingGlobal = self[\"webpackChunkremark42\"] = self[\"webpackChunkremark42\"] || [];\nchunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));\nchunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));\n\n// no deferred startup","var n,l,u,i,t,r,o={},f=[],e=/acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i;function c(n,l){for(var u in l)n[u]=l[u];return n}function s(n){var l=n.parentNode;l&&l.removeChild(n)}function a(n,l,u){var i,t,r,o=arguments,f={};for(r in l)\"key\"==r?i=l[r]:\"ref\"==r?t=l[r]:f[r]=l[r];if(arguments.length>3)for(u=[u],r=3;r<arguments.length;r++)u.push(o[r]);if(null!=u&&(f.children=u),\"function\"==typeof n&&null!=n.defaultProps)for(r in n.defaultProps)void 0===f[r]&&(f[r]=n.defaultProps[r]);return v(n,f,i,t,null)}function v(l,u,i,t,r){var o={type:l,props:u,key:i,ref:t,__k:null,__:null,__b:0,__e:null,__d:void 0,__c:null,__h:null,constructor:void 0,__v:null==r?++n.__v:r};return null!=n.vnode&&n.vnode(o),o}function h(){return{current:null}}function y(n){return n.children}function p(n,l){this.props=n,this.context=l}function d(n,l){if(null==l)return n.__?d(n.__,n.__.__k.indexOf(n)+1):null;for(var u;l<n.__k.length;l++)if(null!=(u=n.__k[l])&&null!=u.__e)return u.__e;return\"function\"==typeof n.type?d(n):null}function _(n){var l,u;if(null!=(n=n.__)&&null!=n.__c){for(n.__e=n.__c.base=null,l=0;l<n.__k.length;l++)if(null!=(u=n.__k[l])&&null!=u.__e){n.__e=n.__c.base=u.__e;break}return _(n)}}function k(l){(!l.__d&&(l.__d=!0)&&u.push(l)&&!m.__r++||t!==n.debounceRendering)&&((t=n.debounceRendering)||i)(m)}function m(){for(var n;m.__r=u.length;)n=u.sort(function(n,l){return n.__v.__b-l.__v.__b}),u=[],n.some(function(n){var l,u,i,t,r,o;n.__d&&(r=(t=(l=n).__v).__e,(o=l.__P)&&(u=[],(i=c({},t)).__v=t.__v+1,T(o,t,i,l.__n,void 0!==o.ownerSVGElement,null!=t.__h?[r]:null,u,null==r?d(t):r,t.__h),j(u,t),t.__e!=r&&_(t)))})}function b(n,l,u,i,t,r,e,c,s,a){var h,p,_,k,m,b,w,A=i&&i.__k||f,P=A.length;for(u.__k=[],h=0;h<l.length;h++)if(null!=(k=u.__k[h]=null==(k=l[h])||\"boolean\"==typeof k?null:\"string\"==typeof k||\"number\"==typeof k?v(null,k,null,null,k):Array.isArray(k)?v(y,{children:k},null,null,null):k.__b>0?v(k.type,k.props,k.key,null,k.__v):k)){if(k.__=u,k.__b=u.__b+1,null===(_=A[h])||_&&k.key==_.key&&k.type===_.type)A[h]=void 0;else for(p=0;p<P;p++){if((_=A[p])&&k.key==_.key&&k.type===_.type){A[p]=void 0;break}_=null}T(n,k,_=_||o,t,r,e,c,s,a),m=k.__e,(p=k.ref)&&_.ref!=p&&(w||(w=[]),_.ref&&w.push(_.ref,null,k),w.push(p,k.__c||m,k)),null!=m?(null==b&&(b=m),\"function\"==typeof k.type&&null!=k.__k&&k.__k===_.__k?k.__d=s=g(k,s,n):s=x(n,k,_,A,m,s),a||\"option\"!==u.type?\"function\"==typeof u.type&&(u.__d=s):n.value=\"\"):s&&_.__e==s&&s.parentNode!=n&&(s=d(_))}for(u.__e=b,h=P;h--;)null!=A[h]&&(\"function\"==typeof u.type&&null!=A[h].__e&&A[h].__e==u.__d&&(u.__d=d(i,h+1)),L(A[h],A[h]));if(w)for(h=0;h<w.length;h++)I(w[h],w[++h],w[++h])}function g(n,l,u){var i,t;for(i=0;i<n.__k.length;i++)(t=n.__k[i])&&(t.__=n,l=\"function\"==typeof t.type?g(t,l,u):x(u,t,t,n.__k,t.__e,l));return l}function w(n,l){return l=l||[],null==n||\"boolean\"==typeof n||(Array.isArray(n)?n.some(function(n){w(n,l)}):l.push(n)),l}function x(n,l,u,i,t,r){var o,f,e;if(void 0!==l.__d)o=l.__d,l.__d=void 0;else if(null==u||t!=r||null==t.parentNode)n:if(null==r||r.parentNode!==n)n.appendChild(t),o=null;else{for(f=r,e=0;(f=f.nextSibling)&&e<i.length;e+=2)if(f==t)break n;n.insertBefore(t,r),o=r}return void 0!==o?o:t.nextSibling}function A(n,l,u,i,t){var r;for(r in u)\"children\"===r||\"key\"===r||r in l||C(n,r,null,u[r],i);for(r in l)t&&\"function\"!=typeof l[r]||\"children\"===r||\"key\"===r||\"value\"===r||\"checked\"===r||u[r]===l[r]||C(n,r,l[r],u[r],i)}function P(n,l,u){\"-\"===l[0]?n.setProperty(l,u):n[l]=null==u?\"\":\"number\"!=typeof u||e.test(l)?u:u+\"px\"}function C(n,l,u,i,t){var r;n:if(\"style\"===l)if(\"string\"==typeof u)n.style.cssText=u;else{if(\"string\"==typeof i&&(n.style.cssText=i=\"\"),i)for(l in i)u&&l in u||P(n.style,l,\"\");if(u)for(l in u)i&&u[l]===i[l]||P(n.style,l,u[l])}else if(\"o\"===l[0]&&\"n\"===l[1])r=l!==(l=l.replace(/Capture$/,\"\")),l=l.toLowerCase()in n?l.toLowerCase().slice(2):l.slice(2),n.l||(n.l={}),n.l[l+r]=u,u?i||n.addEventListener(l,r?H:$,r):n.removeEventListener(l,r?H:$,r);else if(\"dangerouslySetInnerHTML\"!==l){if(t)l=l.replace(/xlink[H:h]/,\"h\").replace(/sName$/,\"s\");else if(\"href\"!==l&&\"list\"!==l&&\"form\"!==l&&\"download\"!==l&&l in n)try{n[l]=null==u?\"\":u;break n}catch(n){}\"function\"==typeof u||(null!=u&&(!1!==u||\"a\"===l[0]&&\"r\"===l[1])?n.setAttribute(l,u):n.removeAttribute(l))}}function $(l){this.l[l.type+!1](n.event?n.event(l):l)}function H(l){this.l[l.type+!0](n.event?n.event(l):l)}function T(l,u,i,t,r,o,f,e,s){var a,v,h,d,_,k,m,g,w,x,A,P=u.type;if(void 0!==u.constructor)return null;null!=i.__h&&(s=i.__h,e=u.__e=i.__e,u.__h=null,o=[e]),(a=n.__b)&&a(u);try{n:if(\"function\"==typeof P){if(g=u.props,w=(a=P.contextType)&&t[a.__c],x=a?w?w.props.value:a.__:t,i.__c?m=(v=u.__c=i.__c).__=v.__E:(\"prototype\"in P&&P.prototype.render?u.__c=v=new P(g,x):(u.__c=v=new p(g,x),v.constructor=P,v.render=M),w&&w.sub(v),v.props=g,v.state||(v.state={}),v.context=x,v.__n=t,h=v.__d=!0,v.__h=[]),null==v.__s&&(v.__s=v.state),null!=P.getDerivedStateFromProps&&(v.__s==v.state&&(v.__s=c({},v.__s)),c(v.__s,P.getDerivedStateFromProps(g,v.__s))),d=v.props,_=v.state,h)null==P.getDerivedStateFromProps&&null!=v.componentWillMount&&v.componentWillMount(),null!=v.componentDidMount&&v.__h.push(v.componentDidMount);else{if(null==P.getDerivedStateFromProps&&g!==d&&null!=v.componentWillReceiveProps&&v.componentWillReceiveProps(g,x),!v.__e&&null!=v.shouldComponentUpdate&&!1===v.shouldComponentUpdate(g,v.__s,x)||u.__v===i.__v){v.props=g,v.state=v.__s,u.__v!==i.__v&&(v.__d=!1),v.__v=u,u.__e=i.__e,u.__k=i.__k,v.__h.length&&f.push(v);break n}null!=v.componentWillUpdate&&v.componentWillUpdate(g,v.__s,x),null!=v.componentDidUpdate&&v.__h.push(function(){v.componentDidUpdate(d,_,k)})}v.context=x,v.props=g,v.state=v.__s,(a=n.__r)&&a(u),v.__d=!1,v.__v=u,v.__P=l,a=v.render(v.props,v.state,v.context),v.state=v.__s,null!=v.getChildContext&&(t=c(c({},t),v.getChildContext())),h||null==v.getSnapshotBeforeUpdate||(k=v.getSnapshotBeforeUpdate(d,_)),A=null!=a&&a.type===y&&null==a.key?a.props.children:a,b(l,Array.isArray(A)?A:[A],u,i,t,r,o,f,e,s),v.base=u.__e,u.__h=null,v.__h.length&&f.push(v),m&&(v.__E=v.__=null),v.__e=!1}else null==o&&u.__v===i.__v?(u.__k=i.__k,u.__e=i.__e):u.__e=z(i.__e,u,i,t,r,o,f,s);(a=n.diffed)&&a(u)}catch(l){u.__v=null,(s||null!=o)&&(u.__e=e,u.__h=!!s,o[o.indexOf(e)]=null),n.__e(l,u,i)}}function j(l,u){n.__c&&n.__c(u,l),l.some(function(u){try{l=u.__h,u.__h=[],l.some(function(n){n.call(u)})}catch(l){n.__e(l,u.__v)}})}function z(n,l,u,i,t,r,e,c){var a,v,h,y,p=u.props,d=l.props,_=l.type,k=0;if(\"svg\"===_&&(t=!0),null!=r)for(;k<r.length;k++)if((a=r[k])&&(a===n||(_?a.localName==_:3==a.nodeType))){n=a,r[k]=null;break}if(null==n){if(null===_)return document.createTextNode(d);n=t?document.createElementNS(\"http://www.w3.org/2000/svg\",_):document.createElement(_,d.is&&d),r=null,c=!1}if(null===_)p===d||c&&n.data===d||(n.data=d);else{if(r=r&&f.slice.call(n.childNodes),v=(p=u.props||o).dangerouslySetInnerHTML,h=d.dangerouslySetInnerHTML,!c){if(null!=r)for(p={},y=0;y<n.attributes.length;y++)p[n.attributes[y].name]=n.attributes[y].value;(h||v)&&(h&&(v&&h.__html==v.__html||h.__html===n.innerHTML)||(n.innerHTML=h&&h.__html||\"\"))}if(A(n,d,p,t,c),h)l.__k=[];else if(k=l.props.children,b(n,Array.isArray(k)?k:[k],l,u,i,t&&\"foreignObject\"!==_,r,e,n.firstChild,c),null!=r)for(k=r.length;k--;)null!=r[k]&&s(r[k]);c||(\"value\"in d&&void 0!==(k=d.value)&&(k!==n.value||\"progress\"===_&&!k)&&C(n,\"value\",k,p.value,!1),\"checked\"in d&&void 0!==(k=d.checked)&&k!==n.checked&&C(n,\"checked\",k,p.checked,!1))}return n}function I(l,u,i){try{\"function\"==typeof l?l(u):l.current=u}catch(l){n.__e(l,i)}}function L(l,u,i){var t,r,o;if(n.unmount&&n.unmount(l),(t=l.ref)&&(t.current&&t.current!==l.__e||I(t,null,u)),i||\"function\"==typeof l.type||(i=null!=(r=l.__e)),l.__e=l.__d=void 0,null!=(t=l.__c)){if(t.componentWillUnmount)try{t.componentWillUnmount()}catch(l){n.__e(l,u)}t.base=t.__P=null}if(t=l.__k)for(o=0;o<t.length;o++)t[o]&&L(t[o],u,i);null!=r&&s(r)}function M(n,l,u){return this.constructor(n,u)}function N(l,u,i){var t,r,e;n.__&&n.__(l,u),r=(t=\"function\"==typeof i)?null:i&&i.__k||u.__k,e=[],T(u,l=(!t&&i||u).__k=a(y,null,[l]),r||o,o,void 0!==u.ownerSVGElement,!t&&i?[i]:r?null:u.firstChild?f.slice.call(u.childNodes):null,e,!t&&i?i:r?r.__e:u.firstChild,t),j(e,l)}function O(n,l){N(n,l,O)}function S(n,l,u){var i,t,r,o=arguments,f=c({},n.props);for(r in l)\"key\"==r?i=l[r]:\"ref\"==r?t=l[r]:f[r]=l[r];if(arguments.length>3)for(u=[u],r=3;r<arguments.length;r++)u.push(o[r]);return null!=u&&(f.children=u),v(n.type,f,i||n.key,t||n.ref,null)}function q(n,l){var u={__c:l=\"__cC\"+r++,__:n,Consumer:function(n,l){return n.children(l)},Provider:function(n){var u,i;return this.getChildContext||(u=[],(i={})[l]=this,this.getChildContext=function(){return i},this.shouldComponentUpdate=function(n){this.props.value!==n.value&&u.some(k)},this.sub=function(n){u.push(n);var l=n.componentWillUnmount;n.componentWillUnmount=function(){u.splice(u.indexOf(n),1),l&&l.call(n)}}),n.children}};return u.Provider.__=u.Consumer.contextType=u}n={__e:function(n,l){for(var u,i,t;l=l.__;)if((u=l.__c)&&!u.__)try{if((i=u.constructor)&&null!=i.getDerivedStateFromError&&(u.setState(i.getDerivedStateFromError(n)),t=u.__d),null!=u.componentDidCatch&&(u.componentDidCatch(n),t=u.__d),t)return u.__E=u}catch(l){n=l}throw n},__v:0},l=function(n){return null!=n&&void 0===n.constructor},p.prototype.setState=function(n,l){var u;u=null!=this.__s&&this.__s!==this.state?this.__s:this.__s=c({},this.state),\"function\"==typeof n&&(n=n(c({},u),this.props)),n&&c(u,n),null!=n&&this.__v&&(l&&this.__h.push(l),k(this))},p.prototype.forceUpdate=function(n){this.__v&&(this.__e=!0,n&&this.__h.push(n),k(this))},p.prototype.render=y,u=[],i=\"function\"==typeof Promise?Promise.prototype.then.bind(Promise.resolve()):setTimeout,m.__r=0,r=0;export{N as render,O as hydrate,a as createElement,a as h,y as Fragment,h as createRef,l as isValidElement,p as Component,S as cloneElement,q as createContext,w as toChildArray,n as options};\n//# sourceMappingURL=preact.module.js.map\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import{options as n}from\"preact\";var t,u,r,o=0,i=[],c=n.__b,f=n.__r,e=n.diffed,a=n.__c,v=n.unmount;function m(t,r){n.__h&&n.__h(u,t,o||r),o=0;var i=u.__H||(u.__H={__:[],__h:[]});return t>=i.__.length&&i.__.push({}),i.__[t]}function l(n){return o=1,p(w,n)}function p(n,r,o){var i=m(t++,2);return i.t=n,i.__c||(i.__=[o?o(r):w(void 0,r),function(n){var t=i.t(i.__[0],n);i.__[0]!==t&&(i.__=[t,i.__[1]],i.__c.setState({}))}],i.__c=u),i.__}function y(r,o){var i=m(t++,3);!n.__s&&k(i.__H,o)&&(i.__=r,i.__H=o,u.__H.__h.push(i))}function h(r,o){var i=m(t++,4);!n.__s&&k(i.__H,o)&&(i.__=r,i.__H=o,u.__h.push(i))}function s(n){return o=5,d(function(){return{current:n}},[])}function _(n,t,u){o=6,h(function(){\"function\"==typeof n?n(t()):n&&(n.current=t())},null==u?u:u.concat(n))}function d(n,u){var r=m(t++,7);return k(r.__H,u)&&(r.__=n(),r.__H=u,r.__h=n),r.__}function A(n,t){return o=8,d(function(){return n},t)}function F(n){var r=u.context[n.__c],o=m(t++,9);return o.__c=n,r?(null==o.__&&(o.__=!0,r.sub(u)),r.props.value):n.__}function T(t,u){n.useDebugValue&&n.useDebugValue(u?u(t):t)}function q(n){var r=m(t++,10),o=l();return r.__=n,u.componentDidCatch||(u.componentDidCatch=function(n){r.__&&r.__(n),o[1](n)}),[o[0],function(){o[1](void 0)}]}function x(){i.forEach(function(t){if(t.__P)try{t.__H.__h.forEach(g),t.__H.__h.forEach(j),t.__H.__h=[]}catch(u){t.__H.__h=[],n.__e(u,t.__v)}}),i=[]}n.__b=function(n){u=null,c&&c(n)},n.__r=function(n){f&&f(n),t=0;var r=(u=n.__c).__H;r&&(r.__h.forEach(g),r.__h.forEach(j),r.__h=[])},n.diffed=function(t){e&&e(t);var o=t.__c;o&&o.__H&&o.__H.__h.length&&(1!==i.push(o)&&r===n.requestAnimationFrame||((r=n.requestAnimationFrame)||function(n){var t,u=function(){clearTimeout(r),b&&cancelAnimationFrame(t),setTimeout(n)},r=setTimeout(u,100);b&&(t=requestAnimationFrame(u))})(x)),u=void 0},n.__c=function(t,u){u.some(function(t){try{t.__h.forEach(g),t.__h=t.__h.filter(function(n){return!n.__||j(n)})}catch(r){u.some(function(n){n.__h&&(n.__h=[])}),u=[],n.__e(r,t.__v)}}),a&&a(t,u)},n.unmount=function(t){v&&v(t);var u=t.__c;if(u&&u.__H)try{u.__H.__.forEach(g)}catch(t){n.__e(t,u.__v)}};var b=\"function\"==typeof requestAnimationFrame;function g(n){var t=u;\"function\"==typeof n.__c&&n.__c(),u=t}function j(n){var t=u;n.__c=n.__(),u=t}function k(n,t){return!n||n.length!==t.length||t.some(function(t,u){return t!==n[u]})}function w(n,t){return\"function\"==typeof t?t(n):t}export{l as useState,p as useReducer,y as useEffect,h as useLayoutEffect,s as useRef,_ as useImperativeHandle,d as useMemo,A as useCallback,F as useContext,T as useDebugValue,q as useErrorBoundary};\n//# sourceMappingURL=hooks.module.js.map\n","import{useState as n,useReducer as t,useEffect as e,useLayoutEffect as r,useRef as u,useImperativeHandle as o,useMemo as i,useCallback as l,useContext as f,useDebugValue as c}from\"preact/hooks\";export*from\"preact/hooks\";import{Component as a,createElement as s,options as h,toChildArray as p,Fragment as v,render as d,hydrate as m,cloneElement as y,createRef as b,createContext as _}from\"preact\";export{createElement,createContext,createRef,Fragment,Component}from\"preact\";function C(n,t){for(var e in t)n[e]=t[e];return n}function S(n,t){for(var e in n)if(\"__source\"!==e&&!(e in t))return!0;for(var r in t)if(\"__source\"!==r&&n[r]!==t[r])return!0;return!1}function E(n){this.props=n}function g(n,t){function e(n){var e=this.props.ref,r=e==n.ref;return!r&&e&&(e.call?e(null):e.current=null),t?!t(this.props,n)||!r:S(this.props,n)}function r(t){return this.shouldComponentUpdate=e,s(n,t)}return r.displayName=\"Memo(\"+(n.displayName||n.name)+\")\",r.prototype.isReactComponent=!0,r.__f=!0,r}(E.prototype=new a).isPureReactComponent=!0,E.prototype.shouldComponentUpdate=function(n,t){return S(this.props,n)||S(this.state,t)};var w=h.__b;h.__b=function(n){n.type&&n.type.__f&&n.ref&&(n.props.ref=n.ref,n.ref=null),w&&w(n)};var R=\"undefined\"!=typeof Symbol&&Symbol.for&&Symbol.for(\"react.forward_ref\")||3911;function x(n){function t(t,e){var r=C({},t);return delete r.ref,n(r,(e=t.ref||e)&&(\"object\"!=typeof e||\"current\"in e)?e:null)}return t.$$typeof=R,t.render=t,t.prototype.isReactComponent=t.__f=!0,t.displayName=\"ForwardRef(\"+(n.displayName||n.name)+\")\",t}var N=function(n,t){return null==n?null:p(p(n).map(t))},k={map:N,forEach:N,count:function(n){return n?p(n).length:0},only:function(n){var t=p(n);if(1!==t.length)throw\"Children.only\";return t[0]},toArray:p},A=h.__e;function O(){this.__u=0,this.t=null,this.__b=null}function L(n){var t=n.__.__c;return t&&t.__e&&t.__e(n)}function U(n){var t,e,r;function u(u){if(t||(t=n()).then(function(n){e=n.default||n},function(n){r=n}),r)throw r;if(!e)throw t;return s(e,u)}return u.displayName=\"Lazy\",u.__f=!0,u}function D(){this.u=null,this.o=null}h.__e=function(n,t,e){if(n.then)for(var r,u=t;u=u.__;)if((r=u.__c)&&r.__c)return null==t.__e&&(t.__e=e.__e,t.__k=e.__k),r.__c(n,t);A(n,t,e)},(O.prototype=new a).__c=function(n,t){var e=t.__c,r=this;null==r.t&&(r.t=[]),r.t.push(e);var u=L(r.__v),o=!1,i=function(){o||(o=!0,e.componentWillUnmount=e.__c,u?u(l):l())};e.__c=e.componentWillUnmount,e.componentWillUnmount=function(){i(),e.__c&&e.__c()};var l=function(){if(!--r.__u){if(r.state.__e){var n=r.state.__e;r.__v.__k[0]=function n(t,e,r){return t&&(t.__v=null,t.__k=t.__k&&t.__k.map(function(t){return n(t,e,r)}),t.__c&&t.__c.__P===e&&(t.__e&&r.insertBefore(t.__e,t.__d),t.__c.__e=!0,t.__c.__P=r)),t}(n,n.__c.__P,n.__c.__O)}var t;for(r.setState({__e:r.__b=null});t=r.t.pop();)t.forceUpdate()}},f=!0===t.__h;r.__u++||f||r.setState({__e:r.__b=r.__v.__k[0]}),n.then(i,i)},O.prototype.componentWillUnmount=function(){this.t=[]},O.prototype.render=function(n,t){if(this.__b){if(this.__v.__k){var e=document.createElement(\"div\"),r=this.__v.__k[0].__c;this.__v.__k[0]=function n(t,e,r){return t&&(t.__c&&t.__c.__H&&(t.__c.__H.__.forEach(function(n){\"function\"==typeof n.__c&&n.__c()}),t.__c.__H=null),null!=(t=C({},t)).__c&&(t.__c.__P===r&&(t.__c.__P=e),t.__c=null),t.__k=t.__k&&t.__k.map(function(t){return n(t,e,r)})),t}(this.__b,e,r.__O=r.__P)}this.__b=null}var u=t.__e&&s(v,null,n.fallback);return u&&(u.__h=null),[s(v,null,t.__e?null:n.children),u]};var F=function(n,t,e){if(++e[1]===e[0]&&n.o.delete(t),n.props.revealOrder&&(\"t\"!==n.props.revealOrder[0]||!n.o.size))for(e=n.u;e;){for(;e.length>3;)e.pop()();if(e[1]<e[0])break;n.u=e=e[2]}};function M(n){return this.getChildContext=function(){return n.context},n.children}function T(n){var t=this,e=n.i;t.componentWillUnmount=function(){d(null,t.l),t.l=null,t.i=null},t.i&&t.i!==e&&t.componentWillUnmount(),n.__v?(t.l||(t.i=e,t.l={nodeType:1,parentNode:e,childNodes:[],appendChild:function(n){this.childNodes.push(n),t.i.appendChild(n)},insertBefore:function(n,e){this.childNodes.push(n),t.i.appendChild(n)},removeChild:function(n){this.childNodes.splice(this.childNodes.indexOf(n)>>>1,1),t.i.removeChild(n)}}),d(s(M,{context:t.context},n.__v),t.l)):t.l&&t.componentWillUnmount()}function j(n,t){return s(T,{__v:n,i:t})}(D.prototype=new a).__e=function(n){var t=this,e=L(t.__v),r=t.o.get(n);return r[0]++,function(u){var o=function(){t.props.revealOrder?(r.push(u),F(t,n,r)):u()};e?e(o):o()}},D.prototype.render=function(n){this.u=null,this.o=new Map;var t=p(n.children);n.revealOrder&&\"b\"===n.revealOrder[0]&&t.reverse();for(var e=t.length;e--;)this.o.set(t[e],this.u=[1,0,this.u]);return n.children},D.prototype.componentDidUpdate=D.prototype.componentDidMount=function(){var n=this;this.o.forEach(function(t,e){F(n,e,t)})};var I=\"undefined\"!=typeof Symbol&&Symbol.for&&Symbol.for(\"react.element\")||60103,W=/^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|fill|flood|font|glyph(?!R)|horiz|marker(?!H|W|U)|overline|paint|stop|strikethrough|stroke|text(?!L)|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/,P=function(n){return(\"undefined\"!=typeof Symbol&&\"symbol\"==typeof Symbol()?/fil|che|rad/i:/fil|che|ra/i).test(n)};function V(n,t,e){return null==t.__k&&(t.textContent=\"\"),d(n,t),\"function\"==typeof e&&e(),n?n.__c:null}function z(n,t,e){return m(n,t),\"function\"==typeof e&&e(),n?n.__c:null}a.prototype.isReactComponent={},[\"componentWillMount\",\"componentWillReceiveProps\",\"componentWillUpdate\"].forEach(function(n){Object.defineProperty(a.prototype,n,{configurable:!0,get:function(){return this[\"UNSAFE_\"+n]},set:function(t){Object.defineProperty(this,n,{configurable:!0,writable:!0,value:t})}})});var B=h.event;function H(){}function Z(){return this.cancelBubble}function Y(){return this.defaultPrevented}h.event=function(n){return B&&(n=B(n)),n.persist=H,n.isPropagationStopped=Z,n.isDefaultPrevented=Y,n.nativeEvent=n};var $,q={configurable:!0,get:function(){return this.class}},G=h.vnode;h.vnode=function(n){var t=n.type,e=n.props,r=e;if(\"string\"==typeof t){for(var u in r={},e){var o=e[u];\"value\"===u&&\"defaultValue\"in e&&null==o||(\"defaultValue\"===u&&\"value\"in e&&null==e.value?u=\"value\":\"download\"===u&&!0===o?o=\"\":/ondoubleclick/i.test(u)?u=\"ondblclick\":/^onchange(textarea|input)/i.test(u+t)&&!P(e.type)?u=\"oninput\":/^on(Ani|Tra|Tou|BeforeInp)/.test(u)?u=u.toLowerCase():W.test(u)?u=u.replace(/[A-Z0-9]/,\"-$&\").toLowerCase():null===o&&(o=void 0),r[u]=o)}\"select\"==t&&r.multiple&&Array.isArray(r.value)&&(r.value=p(e.children).forEach(function(n){n.props.selected=-1!=r.value.indexOf(n.props.value)})),\"select\"==t&&null!=r.defaultValue&&(r.value=p(e.children).forEach(function(n){n.props.selected=r.multiple?-1!=r.defaultValue.indexOf(n.props.value):r.defaultValue==n.props.value})),n.props=r}t&&e.class!=e.className&&(q.enumerable=\"className\"in e,null!=e.className&&(r.class=e.className),Object.defineProperty(r,\"className\",q)),n.$$typeof=I,G&&G(n)};var J=h.__r;h.__r=function(n){J&&J(n),$=n.__c};var K={ReactCurrentDispatcher:{current:{readContext:function(n){return $.__n[n.__c].props.value}}}},Q=1,X=2,nn=3,tn=4,en=5;function rn(n,t){return t()}var un=\"object\"==typeof performance&&\"function\"==typeof performance.now?performance.now.bind(performance):function(){return Date.now()},on=\"16.8.0\";function ln(n){return s.bind(null,n)}function fn(n){return!!n&&n.$$typeof===I}function cn(n){return fn(n)?y.apply(null,arguments):n}function an(n){return!!n.__k&&(d(null,n),!0)}function sn(n){return n&&(n.base||1===n.nodeType&&n)||null}var hn=function(n,t){return n(t)},pn=v;export default{useState:n,useReducer:t,useEffect:e,useLayoutEffect:r,useRef:u,useImperativeHandle:o,useMemo:i,useCallback:l,useContext:f,useDebugValue:c,version:\"16.8.0\",Children:k,render:V,hydrate:z,unmountComponentAtNode:an,createPortal:j,createElement:s,createContext:_,createFactory:ln,cloneElement:cn,createRef:b,Fragment:v,isValidElement:fn,findDOMNode:sn,Component:a,PureComponent:E,memo:g,forwardRef:x,unstable_batchedUpdates:hn,StrictMode:v,Suspense:O,SuspenseList:D,lazy:U,__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED:K};export{on as version,k as Children,V as render,z as hydrate,an as unmountComponentAtNode,j as createPortal,ln as createFactory,cn as cloneElement,fn as isValidElement,sn as findDOMNode,E as PureComponent,g as memo,x as forwardRef,hn as unstable_batchedUpdates,pn as StrictMode,O as Suspense,D as SuspenseList,U as lazy,K as __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,Q as unstable_ImmediatePriority,X as unstable_UserBlockingPriority,nn as unstable_NormalPriority,tn as unstable_LowPriority,en as unstable_IdlePriority,rn as unstable_runWithPriority,un as unstable_now};\n//# sourceMappingURL=compat.module.js.map\n","import { __assign } from \"tslib\";\nimport * as React from 'react';\nimport hoistNonReactStatics_ from 'hoist-non-react-statics';\n// Since rollup cannot deal with namespace being a function,\n// this is to interop with TypeScript since `invariant`\n// does not export a default\n// https://github.com/rollup/rollup/issues/1267\nvar hoistNonReactStatics = hoistNonReactStatics_.default || hoistNonReactStatics_;\nimport { invariantIntlContext } from '../utils';\nfunction getDisplayName(Component) {\n    return Component.displayName || Component.name || 'Component';\n}\n// TODO: We should provide initial value here\nvar IntlContext = React.createContext(null);\nvar IntlConsumer = IntlContext.Consumer, IntlProvider = IntlContext.Provider;\nexport var Provider = IntlProvider;\nexport var Context = IntlContext;\nexport default function injectIntl(WrappedComponent, options) {\n    var _a = options || {}, _b = _a.intlPropName, intlPropName = _b === void 0 ? 'intl' : _b, _c = _a.forwardRef, forwardRef = _c === void 0 ? false : _c, _d = _a.enforceContext, enforceContext = _d === void 0 ? true : _d;\n    var WithIntl = function (props) { return (React.createElement(IntlConsumer, null, function (intl) {\n        var _a;\n        if (enforceContext) {\n            invariantIntlContext(intl);\n        }\n        var intlProp = (_a = {}, _a[intlPropName] = intl, _a);\n        return (React.createElement(WrappedComponent, __assign({}, props, intlProp, { ref: forwardRef ? props.forwardedRef : null })));\n    })); };\n    WithIntl.displayName = \"injectIntl(\" + getDisplayName(WrappedComponent) + \")\";\n    WithIntl.WrappedComponent = WrappedComponent;\n    if (forwardRef) {\n        return hoistNonReactStatics(React.forwardRef(function (props, ref) { return (React.createElement(WithIntl, __assign({}, props, { forwardedRef: ref }))); }), WrappedComponent);\n    }\n    return hoistNonReactStatics(WithIntl, WrappedComponent);\n}\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(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","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from) {\r\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\r\n        to[j] = from[i];\r\n    return to;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from) {\r\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\r\n        to[j] = from[i];\r\n    return to;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from) {\r\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\r\n        to[j] = from[i];\r\n    return to;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\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 === 0 /* number */);\n}\nexport function isDateTimeSkeleton(el) {\n    return !!(el && typeof el === 'object' && el.type === 1 /* 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","import { __assign } from \"tslib\";\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}\nfunction icuUnitToEcma(unit) {\n    return unit.replace(/^(.*?)-/, '');\n}\nvar FRACTION_PRECISION_REGEX = /^\\.(?:(0+)(\\*)?|(#+)|(0+)(#+))$/g;\nvar SIGNIFICANT_PRECISION_REGEX = /^(@+)?(\\+|#+)?$/g;\nvar INTEGER_WIDTH_REGEX = /(\\*)(0+)|(#+)(0+)|(0+)/g;\nvar CONCISE_INTEGER_WIDTH_REGEX = /^(0+)$/;\nfunction parseSignificantPrecision(str) {\n    var result = {};\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            if (token.options.length) {\n                result = __assign(__assign({}, result), parseSignificantPrecision(token.options[0]));\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","// @ts-nocheck\nimport { __assign, __extends } from \"tslib\";\n// @generated\nimport { TYPE, } from './types';\nimport { parseDateTimeSkeleton, parseNumberSkeleton } from './skeleton';\nvar SyntaxError = /** @class */ (function (_super) {\n    __extends(SyntaxError, _super);\n    function SyntaxError(message, expected, found, location) {\n        var _this = _super.call(this) || this;\n        _this.message = message;\n        _this.expected = expected;\n        _this.found = found;\n        _this.location = location;\n        _this.name = \"SyntaxError\";\n        if (typeof Error.captureStackTrace === \"function\") {\n            Error.captureStackTrace(_this, SyntaxError);\n        }\n        return _this;\n    }\n    SyntaxError.buildMessage = function (expected, found) {\n        function hex(ch) {\n            return ch.charCodeAt(0).toString(16).toUpperCase();\n        }\n        function literalEscape(s) {\n            return s\n                .replace(/\\\\/g, \"\\\\\\\\\")\n                .replace(/\"/g, \"\\\\\\\"\")\n                .replace(/\\0/g, \"\\\\0\")\n                .replace(/\\t/g, \"\\\\t\")\n                .replace(/\\n/g, \"\\\\n\")\n                .replace(/\\r/g, \"\\\\r\")\n                .replace(/[\\x00-\\x0F]/g, function (ch) { return \"\\\\x0\" + hex(ch); })\n                .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function (ch) { return \"\\\\x\" + hex(ch); });\n        }\n        function classEscape(s) {\n            return s\n                .replace(/\\\\/g, \"\\\\\\\\\")\n                .replace(/\\]/g, \"\\\\]\")\n                .replace(/\\^/g, \"\\\\^\")\n                .replace(/-/g, \"\\\\-\")\n                .replace(/\\0/g, \"\\\\0\")\n                .replace(/\\t/g, \"\\\\t\")\n                .replace(/\\n/g, \"\\\\n\")\n                .replace(/\\r/g, \"\\\\r\")\n                .replace(/[\\x00-\\x0F]/g, function (ch) { return \"\\\\x0\" + hex(ch); })\n                .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function (ch) { return \"\\\\x\" + hex(ch); });\n        }\n        function describeExpectation(expectation) {\n            switch (expectation.type) {\n                case \"literal\":\n                    return \"\\\"\" + literalEscape(expectation.text) + \"\\\"\";\n                case \"class\":\n                    var escapedParts = expectation.parts.map(function (part) {\n                        return Array.isArray(part)\n                            ? classEscape(part[0]) + \"-\" + classEscape(part[1])\n                            : classEscape(part);\n                    });\n                    return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts + \"]\";\n                case \"any\":\n                    return \"any character\";\n                case \"end\":\n                    return \"end of input\";\n                case \"other\":\n                    return expectation.description;\n            }\n        }\n        function describeExpected(expected1) {\n            var descriptions = expected1.map(describeExpectation);\n            var i;\n            var j;\n            descriptions.sort();\n            if (descriptions.length > 0) {\n                for (i = 1, j = 1; i < descriptions.length; i++) {\n                    if (descriptions[i - 1] !== descriptions[i]) {\n                        descriptions[j] = descriptions[i];\n                        j++;\n                    }\n                }\n                descriptions.length = j;\n            }\n            switch (descriptions.length) {\n                case 1:\n                    return descriptions[0];\n                case 2:\n                    return descriptions[0] + \" or \" + descriptions[1];\n                default:\n                    return descriptions.slice(0, -1).join(\", \")\n                        + \", or \"\n                        + descriptions[descriptions.length - 1];\n            }\n        }\n        function describeFound(found1) {\n            return found1 ? \"\\\"\" + literalEscape(found1) + \"\\\"\" : \"end of input\";\n        }\n        return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n    };\n    return SyntaxError;\n}(Error));\nexport { SyntaxError };\nfunction peg$parse(input, options) {\n    options = options !== undefined ? options : {};\n    var peg$FAILED = {};\n    var peg$startRuleFunctions = { start: peg$parsestart };\n    var peg$startRuleFunction = peg$parsestart;\n    var peg$c0 = function () { return !ignoreTag; };\n    var peg$c1 = function (x) { return x; };\n    var peg$c2 = function () { return ignoreTag; };\n    var peg$c3 = \"<\";\n    var peg$c4 = peg$literalExpectation(\"<\", false);\n    var peg$c5 = function (parts) {\n        return parts.join('');\n    };\n    var peg$c6 = function () { return '<'; };\n    var peg$c7 = function (messageText) {\n        return __assign({ type: TYPE.literal, value: messageText }, insertLocation());\n    };\n    var peg$c8 = \"#\";\n    var peg$c9 = peg$literalExpectation(\"#\", false);\n    var peg$c10 = function () {\n        return __assign({ type: TYPE.pound }, insertLocation());\n    };\n    var peg$c11 = peg$otherExpectation(\"tagElement\");\n    var peg$c12 = function (open, children, close) {\n        if (open !== close) {\n            error(\"Mismatch tag \\\"\" + open + \"\\\" !== \\\"\" + close + \"\\\"\", location());\n        }\n        return __assign({ type: TYPE.tag, value: open, children: children }, insertLocation());\n    };\n    var peg$c13 = \"/>\";\n    var peg$c14 = peg$literalExpectation(\"/>\", false);\n    var peg$c15 = function (value) {\n        return __assign({ type: TYPE.literal, value: value.join('') }, insertLocation());\n    };\n    var peg$c16 = \">\";\n    var peg$c17 = peg$literalExpectation(\">\", false);\n    var peg$c18 = function (tag) { return tag; };\n    var peg$c19 = \"</\";\n    var peg$c20 = peg$literalExpectation(\"</\", false);\n    var peg$c21 = peg$otherExpectation(\"argumentElement\");\n    var peg$c22 = \"{\";\n    var peg$c23 = peg$literalExpectation(\"{\", false);\n    var peg$c24 = \"}\";\n    var peg$c25 = peg$literalExpectation(\"}\", false);\n    var peg$c26 = function (value) {\n        return __assign({ type: TYPE.argument, value: value }, insertLocation());\n    };\n    var peg$c27 = peg$otherExpectation(\"numberSkeletonId\");\n    var peg$c28 = /^['\\/{}]/;\n    var peg$c29 = peg$classExpectation([\"'\", \"/\", \"{\", \"}\"], false, false);\n    var peg$c30 = peg$anyExpectation();\n    var peg$c31 = peg$otherExpectation(\"numberSkeletonTokenOption\");\n    var peg$c32 = \"/\";\n    var peg$c33 = peg$literalExpectation(\"/\", false);\n    var peg$c34 = function (option) { return option; };\n    var peg$c35 = peg$otherExpectation(\"numberSkeletonToken\");\n    var peg$c36 = function (stem, options) {\n        return { stem: stem, options: options };\n    };\n    var peg$c37 = function (tokens) {\n        return __assign({ type: 0 /* number */, tokens: tokens, parsedOptions: shouldParseSkeleton ? parseNumberSkeleton(tokens) : {} }, insertLocation());\n    };\n    var peg$c38 = \"::\";\n    var peg$c39 = peg$literalExpectation(\"::\", false);\n    var peg$c40 = function (skeleton) { return skeleton; };\n    var peg$c41 = function () { messageCtx.push('numberArgStyle'); return true; };\n    var peg$c42 = function (style) {\n        messageCtx.pop();\n        return style.replace(/\\s*$/, '');\n    };\n    var peg$c43 = \",\";\n    var peg$c44 = peg$literalExpectation(\",\", false);\n    var peg$c45 = \"number\";\n    var peg$c46 = peg$literalExpectation(\"number\", false);\n    var peg$c47 = function (value, type, style) {\n        return __assign({ type: type === 'number' ? TYPE.number : type === 'date' ? TYPE.date : TYPE.time, style: style && style[2], value: value }, insertLocation());\n    };\n    var peg$c48 = \"'\";\n    var peg$c49 = peg$literalExpectation(\"'\", false);\n    var peg$c50 = /^[^']/;\n    var peg$c51 = peg$classExpectation([\"'\"], true, false);\n    var peg$c52 = /^[^a-zA-Z'{}]/;\n    var peg$c53 = peg$classExpectation([[\"a\", \"z\"], [\"A\", \"Z\"], \"'\", \"{\", \"}\"], true, false);\n    var peg$c54 = /^[a-zA-Z]/;\n    var peg$c55 = peg$classExpectation([[\"a\", \"z\"], [\"A\", \"Z\"]], false, false);\n    var peg$c56 = function (pattern) {\n        return __assign({ type: 1 /* dateTime */, pattern: pattern, parsedOptions: shouldParseSkeleton ? parseDateTimeSkeleton(pattern) : {} }, insertLocation());\n    };\n    var peg$c57 = function () { messageCtx.push('dateOrTimeArgStyle'); return true; };\n    var peg$c58 = \"date\";\n    var peg$c59 = peg$literalExpectation(\"date\", false);\n    var peg$c60 = \"time\";\n    var peg$c61 = peg$literalExpectation(\"time\", false);\n    var peg$c62 = \"plural\";\n    var peg$c63 = peg$literalExpectation(\"plural\", false);\n    var peg$c64 = \"selectordinal\";\n    var peg$c65 = peg$literalExpectation(\"selectordinal\", false);\n    var peg$c66 = \"offset:\";\n    var peg$c67 = peg$literalExpectation(\"offset:\", false);\n    var peg$c68 = function (value, pluralType, offset, options) {\n        return __assign({ type: TYPE.plural, pluralType: pluralType === 'plural' ? 'cardinal' : 'ordinal', value: value, offset: offset ? offset[2] : 0, options: options.reduce(function (all, _a) {\n                var id = _a.id, value = _a.value, optionLocation = _a.location;\n                if (id in all) {\n                    error(\"Duplicate option \\\"\" + id + \"\\\" in plural element: \\\"\" + text() + \"\\\"\", location());\n                }\n                all[id] = {\n                    value: value,\n                    location: optionLocation\n                };\n                return all;\n            }, {}) }, insertLocation());\n    };\n    var peg$c69 = \"select\";\n    var peg$c70 = peg$literalExpectation(\"select\", false);\n    var peg$c71 = function (value, options) {\n        return __assign({ type: TYPE.select, value: value, options: options.reduce(function (all, _a) {\n                var id = _a.id, value = _a.value, optionLocation = _a.location;\n                if (id in all) {\n                    error(\"Duplicate option \\\"\" + id + \"\\\" in select element: \\\"\" + text() + \"\\\"\", location());\n                }\n                all[id] = {\n                    value: value,\n                    location: optionLocation\n                };\n                return all;\n            }, {}) }, insertLocation());\n    };\n    var peg$c72 = \"=\";\n    var peg$c73 = peg$literalExpectation(\"=\", false);\n    var peg$c74 = function (id) { messageCtx.push('select'); return true; };\n    var peg$c75 = function (id, value) {\n        messageCtx.pop();\n        return __assign({ id: id,\n            value: value }, insertLocation());\n    };\n    var peg$c76 = function (id) { messageCtx.push('plural'); return true; };\n    var peg$c77 = function (id, value) {\n        messageCtx.pop();\n        return __assign({ id: id,\n            value: value }, insertLocation());\n    };\n    var peg$c78 = peg$otherExpectation(\"whitespace\");\n    var peg$c79 = /^[\\t-\\r \\x85\\xA0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000]/;\n    var peg$c80 = peg$classExpectation([[\"\\t\", \"\\r\"], \" \", \"\\x85\", \"\\xA0\", \"\\u1680\", [\"\\u2000\", \"\\u200A\"], \"\\u2028\", \"\\u2029\", \"\\u202F\", \"\\u205F\", \"\\u3000\"], false, false);\n    var peg$c81 = peg$otherExpectation(\"syntax pattern\");\n    var peg$c82 = /^[!-\\/:-@[-\\^`{-~\\xA1-\\xA7\\xA9\\xAB\\xAC\\xAE\\xB0\\xB1\\xB6\\xBB\\xBF\\xD7\\xF7\\u2010-\\u2027\\u2030-\\u203E\\u2041-\\u2053\\u2055-\\u205E\\u2190-\\u245F\\u2500-\\u2775\\u2794-\\u2BFF\\u2E00-\\u2E7F\\u3001-\\u3003\\u3008-\\u3020\\u3030\\uFD3E\\uFD3F\\uFE45\\uFE46]/;\n    var peg$c83 = peg$classExpectation([[\"!\", \"/\"], [\":\", \"@\"], [\"[\", \"^\"], \"`\", [\"{\", \"~\"], [\"\\xA1\", \"\\xA7\"], \"\\xA9\", \"\\xAB\", \"\\xAC\", \"\\xAE\", \"\\xB0\", \"\\xB1\", \"\\xB6\", \"\\xBB\", \"\\xBF\", \"\\xD7\", \"\\xF7\", [\"\\u2010\", \"\\u2027\"], [\"\\u2030\", \"\\u203E\"], [\"\\u2041\", \"\\u2053\"], [\"\\u2055\", \"\\u205E\"], [\"\\u2190\", \"\\u245F\"], [\"\\u2500\", \"\\u2775\"], [\"\\u2794\", \"\\u2BFF\"], [\"\\u2E00\", \"\\u2E7F\"], [\"\\u3001\", \"\\u3003\"], [\"\\u3008\", \"\\u3020\"], \"\\u3030\", \"\\uFD3E\", \"\\uFD3F\", \"\\uFE45\", \"\\uFE46\"], false, false);\n    var peg$c84 = peg$otherExpectation(\"optional whitespace\");\n    var peg$c85 = peg$otherExpectation(\"number\");\n    var peg$c86 = \"-\";\n    var peg$c87 = peg$literalExpectation(\"-\", false);\n    var peg$c88 = function (negative, num) {\n        return num\n            ? negative\n                ? -num\n                : num\n            : 0;\n    };\n    var peg$c89 = peg$otherExpectation(\"apostrophe\");\n    var peg$c90 = peg$otherExpectation(\"double apostrophes\");\n    var peg$c91 = \"''\";\n    var peg$c92 = peg$literalExpectation(\"''\", false);\n    var peg$c93 = function () { return \"'\"; };\n    var peg$c94 = function (escapedChar, quotedChars) {\n        return escapedChar + quotedChars.replace(\"''\", \"'\");\n    };\n    var peg$c95 = function (x) {\n        return (x !== '<' &&\n            x !== '{' &&\n            !(isInPluralOption() && x === '#') &&\n            !(isNestedMessageText() && x === '}'));\n    };\n    var peg$c96 = \"\\n\";\n    var peg$c97 = peg$literalExpectation(\"\\n\", false);\n    var peg$c98 = function (x) {\n        return x === '<' || x === '>' || x === '{' || x === '}' || (isInPluralOption() && x === '#');\n    };\n    var peg$c99 = peg$otherExpectation(\"argNameOrNumber\");\n    var peg$c100 = peg$otherExpectation(\"validTag\");\n    var peg$c101 = peg$otherExpectation(\"argNumber\");\n    var peg$c102 = \"0\";\n    var peg$c103 = peg$literalExpectation(\"0\", false);\n    var peg$c104 = function () { return 0; };\n    var peg$c105 = /^[1-9]/;\n    var peg$c106 = peg$classExpectation([[\"1\", \"9\"]], false, false);\n    var peg$c107 = /^[0-9]/;\n    var peg$c108 = peg$classExpectation([[\"0\", \"9\"]], false, false);\n    var peg$c109 = function (digits) {\n        return parseInt(digits.join(''), 10);\n    };\n    var peg$c110 = peg$otherExpectation(\"argName\");\n    var peg$c111 = peg$otherExpectation(\"tagName\");\n    var peg$currPos = 0;\n    var peg$savedPos = 0;\n    var peg$posDetailsCache = [{ line: 1, column: 1 }];\n    var peg$maxFailPos = 0;\n    var peg$maxFailExpected = [];\n    var peg$silentFails = 0;\n    var peg$result;\n    if (options.startRule !== undefined) {\n        if (!(options.startRule in peg$startRuleFunctions)) {\n            throw new Error(\"Can't start parsing from rule \\\"\" + options.startRule + \"\\\".\");\n        }\n        peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n    }\n    function text() {\n        return input.substring(peg$savedPos, peg$currPos);\n    }\n    function location() {\n        return peg$computeLocation(peg$savedPos, peg$currPos);\n    }\n    function expected(description, location1) {\n        location1 = location1 !== undefined\n            ? location1\n            : peg$computeLocation(peg$savedPos, peg$currPos);\n        throw peg$buildStructuredError([peg$otherExpectation(description)], input.substring(peg$savedPos, peg$currPos), location1);\n    }\n    function error(message, location1) {\n        location1 = location1 !== undefined\n            ? location1\n            : peg$computeLocation(peg$savedPos, peg$currPos);\n        throw peg$buildSimpleError(message, location1);\n    }\n    function peg$literalExpectation(text1, ignoreCase) {\n        return { type: \"literal\", text: text1, ignoreCase: ignoreCase };\n    }\n    function peg$classExpectation(parts, inverted, ignoreCase) {\n        return { type: \"class\", parts: parts, inverted: inverted, ignoreCase: ignoreCase };\n    }\n    function peg$anyExpectation() {\n        return { type: \"any\" };\n    }\n    function peg$endExpectation() {\n        return { type: \"end\" };\n    }\n    function peg$otherExpectation(description) {\n        return { type: \"other\", description: description };\n    }\n    function peg$computePosDetails(pos) {\n        var details = peg$posDetailsCache[pos];\n        var p;\n        if (details) {\n            return details;\n        }\n        else {\n            p = pos - 1;\n            while (!peg$posDetailsCache[p]) {\n                p--;\n            }\n            details = peg$posDetailsCache[p];\n            details = {\n                line: details.line,\n                column: details.column\n            };\n            while (p < pos) {\n                if (input.charCodeAt(p) === 10) {\n                    details.line++;\n                    details.column = 1;\n                }\n                else {\n                    details.column++;\n                }\n                p++;\n            }\n            peg$posDetailsCache[pos] = details;\n            return details;\n        }\n    }\n    function peg$computeLocation(startPos, endPos) {\n        var startPosDetails = peg$computePosDetails(startPos);\n        var endPosDetails = peg$computePosDetails(endPos);\n        return {\n            start: {\n                offset: startPos,\n                line: startPosDetails.line,\n                column: startPosDetails.column\n            },\n            end: {\n                offset: endPos,\n                line: endPosDetails.line,\n                column: endPosDetails.column\n            }\n        };\n    }\n    function peg$fail(expected1) {\n        if (peg$currPos < peg$maxFailPos) {\n            return;\n        }\n        if (peg$currPos > peg$maxFailPos) {\n            peg$maxFailPos = peg$currPos;\n            peg$maxFailExpected = [];\n        }\n        peg$maxFailExpected.push(expected1);\n    }\n    function peg$buildSimpleError(message, location1) {\n        return new SyntaxError(message, [], \"\", location1);\n    }\n    function peg$buildStructuredError(expected1, found, location1) {\n        return new SyntaxError(SyntaxError.buildMessage(expected1, found), expected1, found, location1);\n    }\n    function peg$parsestart() {\n        var s0;\n        s0 = peg$parsemessage();\n        return s0;\n    }\n    function peg$parsemessage() {\n        var s0, s1;\n        s0 = [];\n        s1 = peg$parsemessageElement();\n        while (s1 !== peg$FAILED) {\n            s0.push(s1);\n            s1 = peg$parsemessageElement();\n        }\n        return s0;\n    }\n    function peg$parsemessageElement() {\n        var s0, s1, s2;\n        s0 = peg$currPos;\n        peg$savedPos = peg$currPos;\n        s1 = peg$c0();\n        if (s1) {\n            s1 = undefined;\n        }\n        else {\n            s1 = peg$FAILED;\n        }\n        if (s1 !== peg$FAILED) {\n            s2 = peg$parsetagElement();\n            if (s2 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c1(s2);\n                s0 = s1;\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        if (s0 === peg$FAILED) {\n            s0 = peg$parseliteralElement();\n            if (s0 === peg$FAILED) {\n                s0 = peg$parseargumentElement();\n                if (s0 === peg$FAILED) {\n                    s0 = peg$parsesimpleFormatElement();\n                    if (s0 === peg$FAILED) {\n                        s0 = peg$parsepluralElement();\n                        if (s0 === peg$FAILED) {\n                            s0 = peg$parseselectElement();\n                            if (s0 === peg$FAILED) {\n                                s0 = peg$parsepoundElement();\n                            }\n                        }\n                    }\n                }\n            }\n        }\n        return s0;\n    }\n    function peg$parsemessageText() {\n        var s0, s1, s2, s3;\n        s0 = peg$currPos;\n        peg$savedPos = peg$currPos;\n        s1 = peg$c2();\n        if (s1) {\n            s1 = undefined;\n        }\n        else {\n            s1 = peg$FAILED;\n        }\n        if (s1 !== peg$FAILED) {\n            s2 = [];\n            s3 = peg$parsedoubleApostrophes();\n            if (s3 === peg$FAILED) {\n                s3 = peg$parsequotedString();\n                if (s3 === peg$FAILED) {\n                    s3 = peg$parseunquotedString();\n                    if (s3 === peg$FAILED) {\n                        if (input.charCodeAt(peg$currPos) === 60) {\n                            s3 = peg$c3;\n                            peg$currPos++;\n                        }\n                        else {\n                            s3 = peg$FAILED;\n                            if (peg$silentFails === 0) {\n                                peg$fail(peg$c4);\n                            }\n                        }\n                    }\n                }\n            }\n            if (s3 !== peg$FAILED) {\n                while (s3 !== peg$FAILED) {\n                    s2.push(s3);\n                    s3 = peg$parsedoubleApostrophes();\n                    if (s3 === peg$FAILED) {\n                        s3 = peg$parsequotedString();\n                        if (s3 === peg$FAILED) {\n                            s3 = peg$parseunquotedString();\n                            if (s3 === peg$FAILED) {\n                                if (input.charCodeAt(peg$currPos) === 60) {\n                                    s3 = peg$c3;\n                                    peg$currPos++;\n                                }\n                                else {\n                                    s3 = peg$FAILED;\n                                    if (peg$silentFails === 0) {\n                                        peg$fail(peg$c4);\n                                    }\n                                }\n                            }\n                        }\n                    }\n                }\n            }\n            else {\n                s2 = peg$FAILED;\n            }\n            if (s2 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c5(s2);\n                s0 = s1;\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        if (s0 === peg$FAILED) {\n            s0 = peg$currPos;\n            s1 = [];\n            s2 = peg$parsedoubleApostrophes();\n            if (s2 === peg$FAILED) {\n                s2 = peg$parsequotedString();\n                if (s2 === peg$FAILED) {\n                    s2 = peg$parseunquotedString();\n                    if (s2 === peg$FAILED) {\n                        s2 = peg$parsenonTagStartingAngleBracket();\n                    }\n                }\n            }\n            if (s2 !== peg$FAILED) {\n                while (s2 !== peg$FAILED) {\n                    s1.push(s2);\n                    s2 = peg$parsedoubleApostrophes();\n                    if (s2 === peg$FAILED) {\n                        s2 = peg$parsequotedString();\n                        if (s2 === peg$FAILED) {\n                            s2 = peg$parseunquotedString();\n                            if (s2 === peg$FAILED) {\n                                s2 = peg$parsenonTagStartingAngleBracket();\n                            }\n                        }\n                    }\n                }\n            }\n            else {\n                s1 = peg$FAILED;\n            }\n            if (s1 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c5(s1);\n            }\n            s0 = s1;\n        }\n        return s0;\n    }\n    function peg$parsenonTagStartingAngleBracket() {\n        var s0, s1, s2;\n        s0 = peg$currPos;\n        s1 = peg$currPos;\n        peg$silentFails++;\n        s2 = peg$parseopeningTag();\n        if (s2 === peg$FAILED) {\n            s2 = peg$parseclosingTag();\n            if (s2 === peg$FAILED) {\n                s2 = peg$parseselfClosingTag();\n            }\n        }\n        peg$silentFails--;\n        if (s2 === peg$FAILED) {\n            s1 = undefined;\n        }\n        else {\n            peg$currPos = s1;\n            s1 = peg$FAILED;\n        }\n        if (s1 !== peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 60) {\n                s2 = peg$c3;\n                peg$currPos++;\n            }\n            else {\n                s2 = peg$FAILED;\n                if (peg$silentFails === 0) {\n                    peg$fail(peg$c4);\n                }\n            }\n            if (s2 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c6();\n                s0 = s1;\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        return s0;\n    }\n    function peg$parseliteralElement() {\n        var s0, s1;\n        s0 = peg$currPos;\n        s1 = peg$parsemessageText();\n        if (s1 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c7(s1);\n        }\n        s0 = s1;\n        return s0;\n    }\n    function peg$parsepoundElement() {\n        var s0, s1;\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 35) {\n            s1 = peg$c8;\n            peg$currPos++;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c9);\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c10();\n        }\n        s0 = s1;\n        return s0;\n    }\n    function peg$parsetagElement() {\n        var s0, s1, s2, s3;\n        peg$silentFails++;\n        s0 = peg$parseselfClosingTag();\n        if (s0 === peg$FAILED) {\n            s0 = peg$currPos;\n            s1 = peg$parseopeningTag();\n            if (s1 !== peg$FAILED) {\n                s2 = peg$parsemessage();\n                if (s2 !== peg$FAILED) {\n                    s3 = peg$parseclosingTag();\n                    if (s3 !== peg$FAILED) {\n                        peg$savedPos = s0;\n                        s1 = peg$c12(s1, s2, s3);\n                        s0 = s1;\n                    }\n                    else {\n                        peg$currPos = s0;\n                        s0 = peg$FAILED;\n                    }\n                }\n                else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        peg$silentFails--;\n        if (s0 === peg$FAILED) {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c11);\n            }\n        }\n        return s0;\n    }\n    function peg$parseselfClosingTag() {\n        var s0, s1, s2, s3, s4, s5;\n        s0 = peg$currPos;\n        s1 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 60) {\n            s2 = peg$c3;\n            peg$currPos++;\n        }\n        else {\n            s2 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c4);\n            }\n        }\n        if (s2 !== peg$FAILED) {\n            s3 = peg$parsevalidTag();\n            if (s3 !== peg$FAILED) {\n                s4 = peg$parse_();\n                if (s4 !== peg$FAILED) {\n                    if (input.substr(peg$currPos, 2) === peg$c13) {\n                        s5 = peg$c13;\n                        peg$currPos += 2;\n                    }\n                    else {\n                        s5 = peg$FAILED;\n                        if (peg$silentFails === 0) {\n                            peg$fail(peg$c14);\n                        }\n                    }\n                    if (s5 !== peg$FAILED) {\n                        s2 = [s2, s3, s4, s5];\n                        s1 = s2;\n                    }\n                    else {\n                        peg$currPos = s1;\n                        s1 = peg$FAILED;\n                    }\n                }\n                else {\n                    peg$currPos = s1;\n                    s1 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s1;\n                s1 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s1;\n            s1 = peg$FAILED;\n        }\n        if (s1 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c15(s1);\n        }\n        s0 = s1;\n        return s0;\n    }\n    function peg$parseopeningTag() {\n        var s0, s1, s2, s3;\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 60) {\n            s1 = peg$c3;\n            peg$currPos++;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c4);\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            s2 = peg$parsevalidTag();\n            if (s2 !== peg$FAILED) {\n                if (input.charCodeAt(peg$currPos) === 62) {\n                    s3 = peg$c16;\n                    peg$currPos++;\n                }\n                else {\n                    s3 = peg$FAILED;\n                    if (peg$silentFails === 0) {\n                        peg$fail(peg$c17);\n                    }\n                }\n                if (s3 !== peg$FAILED) {\n                    peg$savedPos = s0;\n                    s1 = peg$c18(s2);\n                    s0 = s1;\n                }\n                else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        return s0;\n    }\n    function peg$parseclosingTag() {\n        var s0, s1, s2, s3;\n        s0 = peg$currPos;\n        if (input.substr(peg$currPos, 2) === peg$c19) {\n            s1 = peg$c19;\n            peg$currPos += 2;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c20);\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            s2 = peg$parsevalidTag();\n            if (s2 !== peg$FAILED) {\n                if (input.charCodeAt(peg$currPos) === 62) {\n                    s3 = peg$c16;\n                    peg$currPos++;\n                }\n                else {\n                    s3 = peg$FAILED;\n                    if (peg$silentFails === 0) {\n                        peg$fail(peg$c17);\n                    }\n                }\n                if (s3 !== peg$FAILED) {\n                    peg$savedPos = s0;\n                    s1 = peg$c18(s2);\n                    s0 = s1;\n                }\n                else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        return s0;\n    }\n    function peg$parseargumentElement() {\n        var s0, s1, s2, s3, s4, s5;\n        peg$silentFails++;\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 123) {\n            s1 = peg$c22;\n            peg$currPos++;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c23);\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            s2 = peg$parse_();\n            if (s2 !== peg$FAILED) {\n                s3 = peg$parseargNameOrNumber();\n                if (s3 !== peg$FAILED) {\n                    s4 = peg$parse_();\n                    if (s4 !== peg$FAILED) {\n                        if (input.charCodeAt(peg$currPos) === 125) {\n                            s5 = peg$c24;\n                            peg$currPos++;\n                        }\n                        else {\n                            s5 = peg$FAILED;\n                            if (peg$silentFails === 0) {\n                                peg$fail(peg$c25);\n                            }\n                        }\n                        if (s5 !== peg$FAILED) {\n                            peg$savedPos = s0;\n                            s1 = peg$c26(s3);\n                            s0 = s1;\n                        }\n                        else {\n                            peg$currPos = s0;\n                            s0 = peg$FAILED;\n                        }\n                    }\n                    else {\n                        peg$currPos = s0;\n                        s0 = peg$FAILED;\n                    }\n                }\n                else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        peg$silentFails--;\n        if (s0 === peg$FAILED) {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c21);\n            }\n        }\n        return s0;\n    }\n    function peg$parsenumberSkeletonId() {\n        var s0, s1, s2, s3, s4;\n        peg$silentFails++;\n        s0 = peg$currPos;\n        s1 = [];\n        s2 = peg$currPos;\n        s3 = peg$currPos;\n        peg$silentFails++;\n        s4 = peg$parsewhiteSpace();\n        if (s4 === peg$FAILED) {\n            if (peg$c28.test(input.charAt(peg$currPos))) {\n                s4 = input.charAt(peg$currPos);\n                peg$currPos++;\n            }\n            else {\n                s4 = peg$FAILED;\n                if (peg$silentFails === 0) {\n                    peg$fail(peg$c29);\n                }\n            }\n        }\n        peg$silentFails--;\n        if (s4 === peg$FAILED) {\n            s3 = undefined;\n        }\n        else {\n            peg$currPos = s3;\n            s3 = peg$FAILED;\n        }\n        if (s3 !== peg$FAILED) {\n            if (input.length > peg$currPos) {\n                s4 = input.charAt(peg$currPos);\n                peg$currPos++;\n            }\n            else {\n                s4 = peg$FAILED;\n                if (peg$silentFails === 0) {\n                    peg$fail(peg$c30);\n                }\n            }\n            if (s4 !== peg$FAILED) {\n                s3 = [s3, s4];\n                s2 = s3;\n            }\n            else {\n                peg$currPos = s2;\n                s2 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s2;\n            s2 = peg$FAILED;\n        }\n        if (s2 !== peg$FAILED) {\n            while (s2 !== peg$FAILED) {\n                s1.push(s2);\n                s2 = peg$currPos;\n                s3 = peg$currPos;\n                peg$silentFails++;\n                s4 = peg$parsewhiteSpace();\n                if (s4 === peg$FAILED) {\n                    if (peg$c28.test(input.charAt(peg$currPos))) {\n                        s4 = input.charAt(peg$currPos);\n                        peg$currPos++;\n                    }\n                    else {\n                        s4 = peg$FAILED;\n                        if (peg$silentFails === 0) {\n                            peg$fail(peg$c29);\n                        }\n                    }\n                }\n                peg$silentFails--;\n                if (s4 === peg$FAILED) {\n                    s3 = undefined;\n                }\n                else {\n                    peg$currPos = s3;\n                    s3 = peg$FAILED;\n                }\n                if (s3 !== peg$FAILED) {\n                    if (input.length > peg$currPos) {\n                        s4 = input.charAt(peg$currPos);\n                        peg$currPos++;\n                    }\n                    else {\n                        s4 = peg$FAILED;\n                        if (peg$silentFails === 0) {\n                            peg$fail(peg$c30);\n                        }\n                    }\n                    if (s4 !== peg$FAILED) {\n                        s3 = [s3, s4];\n                        s2 = s3;\n                    }\n                    else {\n                        peg$currPos = s2;\n                        s2 = peg$FAILED;\n                    }\n                }\n                else {\n                    peg$currPos = s2;\n                    s2 = peg$FAILED;\n                }\n            }\n        }\n        else {\n            s1 = peg$FAILED;\n        }\n        if (s1 !== peg$FAILED) {\n            s0 = input.substring(s0, peg$currPos);\n        }\n        else {\n            s0 = s1;\n        }\n        peg$silentFails--;\n        if (s0 === peg$FAILED) {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c27);\n            }\n        }\n        return s0;\n    }\n    function peg$parsenumberSkeletonTokenOption() {\n        var s0, s1, s2;\n        peg$silentFails++;\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 47) {\n            s1 = peg$c32;\n            peg$currPos++;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c33);\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            s2 = peg$parsenumberSkeletonId();\n            if (s2 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c34(s2);\n                s0 = s1;\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        peg$silentFails--;\n        if (s0 === peg$FAILED) {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c31);\n            }\n        }\n        return s0;\n    }\n    function peg$parsenumberSkeletonToken() {\n        var s0, s1, s2, s3, s4;\n        peg$silentFails++;\n        s0 = peg$currPos;\n        s1 = peg$parse_();\n        if (s1 !== peg$FAILED) {\n            s2 = peg$parsenumberSkeletonId();\n            if (s2 !== peg$FAILED) {\n                s3 = [];\n                s4 = peg$parsenumberSkeletonTokenOption();\n                while (s4 !== peg$FAILED) {\n                    s3.push(s4);\n                    s4 = peg$parsenumberSkeletonTokenOption();\n                }\n                if (s3 !== peg$FAILED) {\n                    peg$savedPos = s0;\n                    s1 = peg$c36(s2, s3);\n                    s0 = s1;\n                }\n                else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        peg$silentFails--;\n        if (s0 === peg$FAILED) {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c35);\n            }\n        }\n        return s0;\n    }\n    function peg$parsenumberSkeleton() {\n        var s0, s1, s2;\n        s0 = peg$currPos;\n        s1 = [];\n        s2 = peg$parsenumberSkeletonToken();\n        if (s2 !== peg$FAILED) {\n            while (s2 !== peg$FAILED) {\n                s1.push(s2);\n                s2 = peg$parsenumberSkeletonToken();\n            }\n        }\n        else {\n            s1 = peg$FAILED;\n        }\n        if (s1 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c37(s1);\n        }\n        s0 = s1;\n        return s0;\n    }\n    function peg$parsenumberArgStyle() {\n        var s0, s1, s2;\n        s0 = peg$currPos;\n        if (input.substr(peg$currPos, 2) === peg$c38) {\n            s1 = peg$c38;\n            peg$currPos += 2;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c39);\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            s2 = peg$parsenumberSkeleton();\n            if (s2 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c40(s2);\n                s0 = s1;\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        if (s0 === peg$FAILED) {\n            s0 = peg$currPos;\n            peg$savedPos = peg$currPos;\n            s1 = peg$c41();\n            if (s1) {\n                s1 = undefined;\n            }\n            else {\n                s1 = peg$FAILED;\n            }\n            if (s1 !== peg$FAILED) {\n                s2 = peg$parsemessageText();\n                if (s2 !== peg$FAILED) {\n                    peg$savedPos = s0;\n                    s1 = peg$c42(s2);\n                    s0 = s1;\n                }\n                else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        return s0;\n    }\n    function peg$parsenumberFormatElement() {\n        var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 123) {\n            s1 = peg$c22;\n            peg$currPos++;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c23);\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            s2 = peg$parse_();\n            if (s2 !== peg$FAILED) {\n                s3 = peg$parseargNameOrNumber();\n                if (s3 !== peg$FAILED) {\n                    s4 = peg$parse_();\n                    if (s4 !== peg$FAILED) {\n                        if (input.charCodeAt(peg$currPos) === 44) {\n                            s5 = peg$c43;\n                            peg$currPos++;\n                        }\n                        else {\n                            s5 = peg$FAILED;\n                            if (peg$silentFails === 0) {\n                                peg$fail(peg$c44);\n                            }\n                        }\n                        if (s5 !== peg$FAILED) {\n                            s6 = peg$parse_();\n                            if (s6 !== peg$FAILED) {\n                                if (input.substr(peg$currPos, 6) === peg$c45) {\n                                    s7 = peg$c45;\n                                    peg$currPos += 6;\n                                }\n                                else {\n                                    s7 = peg$FAILED;\n                                    if (peg$silentFails === 0) {\n                                        peg$fail(peg$c46);\n                                    }\n                                }\n                                if (s7 !== peg$FAILED) {\n                                    s8 = peg$parse_();\n                                    if (s8 !== peg$FAILED) {\n                                        s9 = peg$currPos;\n                                        if (input.charCodeAt(peg$currPos) === 44) {\n                                            s10 = peg$c43;\n                                            peg$currPos++;\n                                        }\n                                        else {\n                                            s10 = peg$FAILED;\n                                            if (peg$silentFails === 0) {\n                                                peg$fail(peg$c44);\n                                            }\n                                        }\n                                        if (s10 !== peg$FAILED) {\n                                            s11 = peg$parse_();\n                                            if (s11 !== peg$FAILED) {\n                                                s12 = peg$parsenumberArgStyle();\n                                                if (s12 !== peg$FAILED) {\n                                                    s10 = [s10, s11, s12];\n                                                    s9 = s10;\n                                                }\n                                                else {\n                                                    peg$currPos = s9;\n                                                    s9 = peg$FAILED;\n                                                }\n                                            }\n                                            else {\n                                                peg$currPos = s9;\n                                                s9 = peg$FAILED;\n                                            }\n                                        }\n                                        else {\n                                            peg$currPos = s9;\n                                            s9 = peg$FAILED;\n                                        }\n                                        if (s9 === peg$FAILED) {\n                                            s9 = null;\n                                        }\n                                        if (s9 !== peg$FAILED) {\n                                            s10 = peg$parse_();\n                                            if (s10 !== peg$FAILED) {\n                                                if (input.charCodeAt(peg$currPos) === 125) {\n                                                    s11 = peg$c24;\n                                                    peg$currPos++;\n                                                }\n                                                else {\n                                                    s11 = peg$FAILED;\n                                                    if (peg$silentFails === 0) {\n                                                        peg$fail(peg$c25);\n                                                    }\n                                                }\n                                                if (s11 !== peg$FAILED) {\n                                                    peg$savedPos = s0;\n                                                    s1 = peg$c47(s3, s7, s9);\n                                                    s0 = s1;\n                                                }\n                                                else {\n                                                    peg$currPos = s0;\n                                                    s0 = peg$FAILED;\n                                                }\n                                            }\n                                            else {\n                                                peg$currPos = s0;\n                                                s0 = peg$FAILED;\n                                            }\n                                        }\n                                        else {\n                                            peg$currPos = s0;\n                                            s0 = peg$FAILED;\n                                        }\n                                    }\n                                    else {\n                                        peg$currPos = s0;\n                                        s0 = peg$FAILED;\n                                    }\n                                }\n                                else {\n                                    peg$currPos = s0;\n                                    s0 = peg$FAILED;\n                                }\n                            }\n                            else {\n                                peg$currPos = s0;\n                                s0 = peg$FAILED;\n                            }\n                        }\n                        else {\n                            peg$currPos = s0;\n                            s0 = peg$FAILED;\n                        }\n                    }\n                    else {\n                        peg$currPos = s0;\n                        s0 = peg$FAILED;\n                    }\n                }\n                else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        return s0;\n    }\n    function peg$parsedateTimeSkeletonLiteral() {\n        var s0, s1, s2, s3;\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 39) {\n            s1 = peg$c48;\n            peg$currPos++;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c49);\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            s2 = [];\n            s3 = peg$parsedoubleApostrophes();\n            if (s3 === peg$FAILED) {\n                if (peg$c50.test(input.charAt(peg$currPos))) {\n                    s3 = input.charAt(peg$currPos);\n                    peg$currPos++;\n                }\n                else {\n                    s3 = peg$FAILED;\n                    if (peg$silentFails === 0) {\n                        peg$fail(peg$c51);\n                    }\n                }\n            }\n            if (s3 !== peg$FAILED) {\n                while (s3 !== peg$FAILED) {\n                    s2.push(s3);\n                    s3 = peg$parsedoubleApostrophes();\n                    if (s3 === peg$FAILED) {\n                        if (peg$c50.test(input.charAt(peg$currPos))) {\n                            s3 = input.charAt(peg$currPos);\n                            peg$currPos++;\n                        }\n                        else {\n                            s3 = peg$FAILED;\n                            if (peg$silentFails === 0) {\n                                peg$fail(peg$c51);\n                            }\n                        }\n                    }\n                }\n            }\n            else {\n                s2 = peg$FAILED;\n            }\n            if (s2 !== peg$FAILED) {\n                if (input.charCodeAt(peg$currPos) === 39) {\n                    s3 = peg$c48;\n                    peg$currPos++;\n                }\n                else {\n                    s3 = peg$FAILED;\n                    if (peg$silentFails === 0) {\n                        peg$fail(peg$c49);\n                    }\n                }\n                if (s3 !== peg$FAILED) {\n                    s1 = [s1, s2, s3];\n                    s0 = s1;\n                }\n                else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        if (s0 === peg$FAILED) {\n            s0 = [];\n            s1 = peg$parsedoubleApostrophes();\n            if (s1 === peg$FAILED) {\n                if (peg$c52.test(input.charAt(peg$currPos))) {\n                    s1 = input.charAt(peg$currPos);\n                    peg$currPos++;\n                }\n                else {\n                    s1 = peg$FAILED;\n                    if (peg$silentFails === 0) {\n                        peg$fail(peg$c53);\n                    }\n                }\n            }\n            if (s1 !== peg$FAILED) {\n                while (s1 !== peg$FAILED) {\n                    s0.push(s1);\n                    s1 = peg$parsedoubleApostrophes();\n                    if (s1 === peg$FAILED) {\n                        if (peg$c52.test(input.charAt(peg$currPos))) {\n                            s1 = input.charAt(peg$currPos);\n                            peg$currPos++;\n                        }\n                        else {\n                            s1 = peg$FAILED;\n                            if (peg$silentFails === 0) {\n                                peg$fail(peg$c53);\n                            }\n                        }\n                    }\n                }\n            }\n            else {\n                s0 = peg$FAILED;\n            }\n        }\n        return s0;\n    }\n    function peg$parsedateTimeSkeletonPattern() {\n        var s0, s1;\n        s0 = [];\n        if (peg$c54.test(input.charAt(peg$currPos))) {\n            s1 = input.charAt(peg$currPos);\n            peg$currPos++;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c55);\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            while (s1 !== peg$FAILED) {\n                s0.push(s1);\n                if (peg$c54.test(input.charAt(peg$currPos))) {\n                    s1 = input.charAt(peg$currPos);\n                    peg$currPos++;\n                }\n                else {\n                    s1 = peg$FAILED;\n                    if (peg$silentFails === 0) {\n                        peg$fail(peg$c55);\n                    }\n                }\n            }\n        }\n        else {\n            s0 = peg$FAILED;\n        }\n        return s0;\n    }\n    function peg$parsedateTimeSkeleton() {\n        var s0, s1, s2, s3;\n        s0 = peg$currPos;\n        s1 = peg$currPos;\n        s2 = [];\n        s3 = peg$parsedateTimeSkeletonLiteral();\n        if (s3 === peg$FAILED) {\n            s3 = peg$parsedateTimeSkeletonPattern();\n        }\n        if (s3 !== peg$FAILED) {\n            while (s3 !== peg$FAILED) {\n                s2.push(s3);\n                s3 = peg$parsedateTimeSkeletonLiteral();\n                if (s3 === peg$FAILED) {\n                    s3 = peg$parsedateTimeSkeletonPattern();\n                }\n            }\n        }\n        else {\n            s2 = peg$FAILED;\n        }\n        if (s2 !== peg$FAILED) {\n            s1 = input.substring(s1, peg$currPos);\n        }\n        else {\n            s1 = s2;\n        }\n        if (s1 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c56(s1);\n        }\n        s0 = s1;\n        return s0;\n    }\n    function peg$parsedateOrTimeArgStyle() {\n        var s0, s1, s2;\n        s0 = peg$currPos;\n        if (input.substr(peg$currPos, 2) === peg$c38) {\n            s1 = peg$c38;\n            peg$currPos += 2;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c39);\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            s2 = peg$parsedateTimeSkeleton();\n            if (s2 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c40(s2);\n                s0 = s1;\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        if (s0 === peg$FAILED) {\n            s0 = peg$currPos;\n            peg$savedPos = peg$currPos;\n            s1 = peg$c57();\n            if (s1) {\n                s1 = undefined;\n            }\n            else {\n                s1 = peg$FAILED;\n            }\n            if (s1 !== peg$FAILED) {\n                s2 = peg$parsemessageText();\n                if (s2 !== peg$FAILED) {\n                    peg$savedPos = s0;\n                    s1 = peg$c42(s2);\n                    s0 = s1;\n                }\n                else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        return s0;\n    }\n    function peg$parsedateOrTimeFormatElement() {\n        var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 123) {\n            s1 = peg$c22;\n            peg$currPos++;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c23);\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            s2 = peg$parse_();\n            if (s2 !== peg$FAILED) {\n                s3 = peg$parseargNameOrNumber();\n                if (s3 !== peg$FAILED) {\n                    s4 = peg$parse_();\n                    if (s4 !== peg$FAILED) {\n                        if (input.charCodeAt(peg$currPos) === 44) {\n                            s5 = peg$c43;\n                            peg$currPos++;\n                        }\n                        else {\n                            s5 = peg$FAILED;\n                            if (peg$silentFails === 0) {\n                                peg$fail(peg$c44);\n                            }\n                        }\n                        if (s5 !== peg$FAILED) {\n                            s6 = peg$parse_();\n                            if (s6 !== peg$FAILED) {\n                                if (input.substr(peg$currPos, 4) === peg$c58) {\n                                    s7 = peg$c58;\n                                    peg$currPos += 4;\n                                }\n                                else {\n                                    s7 = peg$FAILED;\n                                    if (peg$silentFails === 0) {\n                                        peg$fail(peg$c59);\n                                    }\n                                }\n                                if (s7 === peg$FAILED) {\n                                    if (input.substr(peg$currPos, 4) === peg$c60) {\n                                        s7 = peg$c60;\n                                        peg$currPos += 4;\n                                    }\n                                    else {\n                                        s7 = peg$FAILED;\n                                        if (peg$silentFails === 0) {\n                                            peg$fail(peg$c61);\n                                        }\n                                    }\n                                }\n                                if (s7 !== peg$FAILED) {\n                                    s8 = peg$parse_();\n                                    if (s8 !== peg$FAILED) {\n                                        s9 = peg$currPos;\n                                        if (input.charCodeAt(peg$currPos) === 44) {\n                                            s10 = peg$c43;\n                                            peg$currPos++;\n                                        }\n                                        else {\n                                            s10 = peg$FAILED;\n                                            if (peg$silentFails === 0) {\n                                                peg$fail(peg$c44);\n                                            }\n                                        }\n                                        if (s10 !== peg$FAILED) {\n                                            s11 = peg$parse_();\n                                            if (s11 !== peg$FAILED) {\n                                                s12 = peg$parsedateOrTimeArgStyle();\n                                                if (s12 !== peg$FAILED) {\n                                                    s10 = [s10, s11, s12];\n                                                    s9 = s10;\n                                                }\n                                                else {\n                                                    peg$currPos = s9;\n                                                    s9 = peg$FAILED;\n                                                }\n                                            }\n                                            else {\n                                                peg$currPos = s9;\n                                                s9 = peg$FAILED;\n                                            }\n                                        }\n                                        else {\n                                            peg$currPos = s9;\n                                            s9 = peg$FAILED;\n                                        }\n                                        if (s9 === peg$FAILED) {\n                                            s9 = null;\n                                        }\n                                        if (s9 !== peg$FAILED) {\n                                            s10 = peg$parse_();\n                                            if (s10 !== peg$FAILED) {\n                                                if (input.charCodeAt(peg$currPos) === 125) {\n                                                    s11 = peg$c24;\n                                                    peg$currPos++;\n                                                }\n                                                else {\n                                                    s11 = peg$FAILED;\n                                                    if (peg$silentFails === 0) {\n                                                        peg$fail(peg$c25);\n                                                    }\n                                                }\n                                                if (s11 !== peg$FAILED) {\n                                                    peg$savedPos = s0;\n                                                    s1 = peg$c47(s3, s7, s9);\n                                                    s0 = s1;\n                                                }\n                                                else {\n                                                    peg$currPos = s0;\n                                                    s0 = peg$FAILED;\n                                                }\n                                            }\n                                            else {\n                                                peg$currPos = s0;\n                                                s0 = peg$FAILED;\n                                            }\n                                        }\n                                        else {\n                                            peg$currPos = s0;\n                                            s0 = peg$FAILED;\n                                        }\n                                    }\n                                    else {\n                                        peg$currPos = s0;\n                                        s0 = peg$FAILED;\n                                    }\n                                }\n                                else {\n                                    peg$currPos = s0;\n                                    s0 = peg$FAILED;\n                                }\n                            }\n                            else {\n                                peg$currPos = s0;\n                                s0 = peg$FAILED;\n                            }\n                        }\n                        else {\n                            peg$currPos = s0;\n                            s0 = peg$FAILED;\n                        }\n                    }\n                    else {\n                        peg$currPos = s0;\n                        s0 = peg$FAILED;\n                    }\n                }\n                else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        return s0;\n    }\n    function peg$parsesimpleFormatElement() {\n        var s0;\n        s0 = peg$parsenumberFormatElement();\n        if (s0 === peg$FAILED) {\n            s0 = peg$parsedateOrTimeFormatElement();\n        }\n        return s0;\n    }\n    function peg$parsepluralElement() {\n        var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15;\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 123) {\n            s1 = peg$c22;\n            peg$currPos++;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c23);\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            s2 = peg$parse_();\n            if (s2 !== peg$FAILED) {\n                s3 = peg$parseargNameOrNumber();\n                if (s3 !== peg$FAILED) {\n                    s4 = peg$parse_();\n                    if (s4 !== peg$FAILED) {\n                        if (input.charCodeAt(peg$currPos) === 44) {\n                            s5 = peg$c43;\n                            peg$currPos++;\n                        }\n                        else {\n                            s5 = peg$FAILED;\n                            if (peg$silentFails === 0) {\n                                peg$fail(peg$c44);\n                            }\n                        }\n                        if (s5 !== peg$FAILED) {\n                            s6 = peg$parse_();\n                            if (s6 !== peg$FAILED) {\n                                if (input.substr(peg$currPos, 6) === peg$c62) {\n                                    s7 = peg$c62;\n                                    peg$currPos += 6;\n                                }\n                                else {\n                                    s7 = peg$FAILED;\n                                    if (peg$silentFails === 0) {\n                                        peg$fail(peg$c63);\n                                    }\n                                }\n                                if (s7 === peg$FAILED) {\n                                    if (input.substr(peg$currPos, 13) === peg$c64) {\n                                        s7 = peg$c64;\n                                        peg$currPos += 13;\n                                    }\n                                    else {\n                                        s7 = peg$FAILED;\n                                        if (peg$silentFails === 0) {\n                                            peg$fail(peg$c65);\n                                        }\n                                    }\n                                }\n                                if (s7 !== peg$FAILED) {\n                                    s8 = peg$parse_();\n                                    if (s8 !== peg$FAILED) {\n                                        if (input.charCodeAt(peg$currPos) === 44) {\n                                            s9 = peg$c43;\n                                            peg$currPos++;\n                                        }\n                                        else {\n                                            s9 = peg$FAILED;\n                                            if (peg$silentFails === 0) {\n                                                peg$fail(peg$c44);\n                                            }\n                                        }\n                                        if (s9 !== peg$FAILED) {\n                                            s10 = peg$parse_();\n                                            if (s10 !== peg$FAILED) {\n                                                s11 = peg$currPos;\n                                                if (input.substr(peg$currPos, 7) === peg$c66) {\n                                                    s12 = peg$c66;\n                                                    peg$currPos += 7;\n                                                }\n                                                else {\n                                                    s12 = peg$FAILED;\n                                                    if (peg$silentFails === 0) {\n                                                        peg$fail(peg$c67);\n                                                    }\n                                                }\n                                                if (s12 !== peg$FAILED) {\n                                                    s13 = peg$parse_();\n                                                    if (s13 !== peg$FAILED) {\n                                                        s14 = peg$parsenumber();\n                                                        if (s14 !== peg$FAILED) {\n                                                            s12 = [s12, s13, s14];\n                                                            s11 = s12;\n                                                        }\n                                                        else {\n                                                            peg$currPos = s11;\n                                                            s11 = peg$FAILED;\n                                                        }\n                                                    }\n                                                    else {\n                                                        peg$currPos = s11;\n                                                        s11 = peg$FAILED;\n                                                    }\n                                                }\n                                                else {\n                                                    peg$currPos = s11;\n                                                    s11 = peg$FAILED;\n                                                }\n                                                if (s11 === peg$FAILED) {\n                                                    s11 = null;\n                                                }\n                                                if (s11 !== peg$FAILED) {\n                                                    s12 = peg$parse_();\n                                                    if (s12 !== peg$FAILED) {\n                                                        s13 = [];\n                                                        s14 = peg$parsepluralOption();\n                                                        if (s14 !== peg$FAILED) {\n                                                            while (s14 !== peg$FAILED) {\n                                                                s13.push(s14);\n                                                                s14 = peg$parsepluralOption();\n                                                            }\n                                                        }\n                                                        else {\n                                                            s13 = peg$FAILED;\n                                                        }\n                                                        if (s13 !== peg$FAILED) {\n                                                            s14 = peg$parse_();\n                                                            if (s14 !== peg$FAILED) {\n                                                                if (input.charCodeAt(peg$currPos) === 125) {\n                                                                    s15 = peg$c24;\n                                                                    peg$currPos++;\n                                                                }\n                                                                else {\n                                                                    s15 = peg$FAILED;\n                                                                    if (peg$silentFails === 0) {\n                                                                        peg$fail(peg$c25);\n                                                                    }\n                                                                }\n                                                                if (s15 !== peg$FAILED) {\n                                                                    peg$savedPos = s0;\n                                                                    s1 = peg$c68(s3, s7, s11, s13);\n                                                                    s0 = s1;\n                                                                }\n                                                                else {\n                                                                    peg$currPos = s0;\n                                                                    s0 = peg$FAILED;\n                                                                }\n                                                            }\n                                                            else {\n                                                                peg$currPos = s0;\n                                                                s0 = peg$FAILED;\n                                                            }\n                                                        }\n                                                        else {\n                                                            peg$currPos = s0;\n                                                            s0 = peg$FAILED;\n                                                        }\n                                                    }\n                                                    else {\n                                                        peg$currPos = s0;\n                                                        s0 = peg$FAILED;\n                                                    }\n                                                }\n                                                else {\n                                                    peg$currPos = s0;\n                                                    s0 = peg$FAILED;\n                                                }\n                                            }\n                                            else {\n                                                peg$currPos = s0;\n                                                s0 = peg$FAILED;\n                                            }\n                                        }\n                                        else {\n                                            peg$currPos = s0;\n                                            s0 = peg$FAILED;\n                                        }\n                                    }\n                                    else {\n                                        peg$currPos = s0;\n                                        s0 = peg$FAILED;\n                                    }\n                                }\n                                else {\n                                    peg$currPos = s0;\n                                    s0 = peg$FAILED;\n                                }\n                            }\n                            else {\n                                peg$currPos = s0;\n                                s0 = peg$FAILED;\n                            }\n                        }\n                        else {\n                            peg$currPos = s0;\n                            s0 = peg$FAILED;\n                        }\n                    }\n                    else {\n                        peg$currPos = s0;\n                        s0 = peg$FAILED;\n                    }\n                }\n                else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        return s0;\n    }\n    function peg$parseselectElement() {\n        var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 123) {\n            s1 = peg$c22;\n            peg$currPos++;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c23);\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            s2 = peg$parse_();\n            if (s2 !== peg$FAILED) {\n                s3 = peg$parseargNameOrNumber();\n                if (s3 !== peg$FAILED) {\n                    s4 = peg$parse_();\n                    if (s4 !== peg$FAILED) {\n                        if (input.charCodeAt(peg$currPos) === 44) {\n                            s5 = peg$c43;\n                            peg$currPos++;\n                        }\n                        else {\n                            s5 = peg$FAILED;\n                            if (peg$silentFails === 0) {\n                                peg$fail(peg$c44);\n                            }\n                        }\n                        if (s5 !== peg$FAILED) {\n                            s6 = peg$parse_();\n                            if (s6 !== peg$FAILED) {\n                                if (input.substr(peg$currPos, 6) === peg$c69) {\n                                    s7 = peg$c69;\n                                    peg$currPos += 6;\n                                }\n                                else {\n                                    s7 = peg$FAILED;\n                                    if (peg$silentFails === 0) {\n                                        peg$fail(peg$c70);\n                                    }\n                                }\n                                if (s7 !== peg$FAILED) {\n                                    s8 = peg$parse_();\n                                    if (s8 !== peg$FAILED) {\n                                        if (input.charCodeAt(peg$currPos) === 44) {\n                                            s9 = peg$c43;\n                                            peg$currPos++;\n                                        }\n                                        else {\n                                            s9 = peg$FAILED;\n                                            if (peg$silentFails === 0) {\n                                                peg$fail(peg$c44);\n                                            }\n                                        }\n                                        if (s9 !== peg$FAILED) {\n                                            s10 = peg$parse_();\n                                            if (s10 !== peg$FAILED) {\n                                                s11 = [];\n                                                s12 = peg$parseselectOption();\n                                                if (s12 !== peg$FAILED) {\n                                                    while (s12 !== peg$FAILED) {\n                                                        s11.push(s12);\n                                                        s12 = peg$parseselectOption();\n                                                    }\n                                                }\n                                                else {\n                                                    s11 = peg$FAILED;\n                                                }\n                                                if (s11 !== peg$FAILED) {\n                                                    s12 = peg$parse_();\n                                                    if (s12 !== peg$FAILED) {\n                                                        if (input.charCodeAt(peg$currPos) === 125) {\n                                                            s13 = peg$c24;\n                                                            peg$currPos++;\n                                                        }\n                                                        else {\n                                                            s13 = peg$FAILED;\n                                                            if (peg$silentFails === 0) {\n                                                                peg$fail(peg$c25);\n                                                            }\n                                                        }\n                                                        if (s13 !== peg$FAILED) {\n                                                            peg$savedPos = s0;\n                                                            s1 = peg$c71(s3, s11);\n                                                            s0 = s1;\n                                                        }\n                                                        else {\n                                                            peg$currPos = s0;\n                                                            s0 = peg$FAILED;\n                                                        }\n                                                    }\n                                                    else {\n                                                        peg$currPos = s0;\n                                                        s0 = peg$FAILED;\n                                                    }\n                                                }\n                                                else {\n                                                    peg$currPos = s0;\n                                                    s0 = peg$FAILED;\n                                                }\n                                            }\n                                            else {\n                                                peg$currPos = s0;\n                                                s0 = peg$FAILED;\n                                            }\n                                        }\n                                        else {\n                                            peg$currPos = s0;\n                                            s0 = peg$FAILED;\n                                        }\n                                    }\n                                    else {\n                                        peg$currPos = s0;\n                                        s0 = peg$FAILED;\n                                    }\n                                }\n                                else {\n                                    peg$currPos = s0;\n                                    s0 = peg$FAILED;\n                                }\n                            }\n                            else {\n                                peg$currPos = s0;\n                                s0 = peg$FAILED;\n                            }\n                        }\n                        else {\n                            peg$currPos = s0;\n                            s0 = peg$FAILED;\n                        }\n                    }\n                    else {\n                        peg$currPos = s0;\n                        s0 = peg$FAILED;\n                    }\n                }\n                else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        return s0;\n    }\n    function peg$parsepluralRuleSelectValue() {\n        var s0, s1, s2, s3;\n        s0 = peg$currPos;\n        s1 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 61) {\n            s2 = peg$c72;\n            peg$currPos++;\n        }\n        else {\n            s2 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c73);\n            }\n        }\n        if (s2 !== peg$FAILED) {\n            s3 = peg$parsenumber();\n            if (s3 !== peg$FAILED) {\n                s2 = [s2, s3];\n                s1 = s2;\n            }\n            else {\n                peg$currPos = s1;\n                s1 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s1;\n            s1 = peg$FAILED;\n        }\n        if (s1 !== peg$FAILED) {\n            s0 = input.substring(s0, peg$currPos);\n        }\n        else {\n            s0 = s1;\n        }\n        if (s0 === peg$FAILED) {\n            s0 = peg$parseargName();\n        }\n        return s0;\n    }\n    function peg$parseselectOption() {\n        var s0, s1, s2, s3, s4, s5, s6, s7;\n        s0 = peg$currPos;\n        s1 = peg$parse_();\n        if (s1 !== peg$FAILED) {\n            s2 = peg$parseargName();\n            if (s2 !== peg$FAILED) {\n                s3 = peg$parse_();\n                if (s3 !== peg$FAILED) {\n                    if (input.charCodeAt(peg$currPos) === 123) {\n                        s4 = peg$c22;\n                        peg$currPos++;\n                    }\n                    else {\n                        s4 = peg$FAILED;\n                        if (peg$silentFails === 0) {\n                            peg$fail(peg$c23);\n                        }\n                    }\n                    if (s4 !== peg$FAILED) {\n                        peg$savedPos = peg$currPos;\n                        s5 = peg$c74(s2);\n                        if (s5) {\n                            s5 = undefined;\n                        }\n                        else {\n                            s5 = peg$FAILED;\n                        }\n                        if (s5 !== peg$FAILED) {\n                            s6 = peg$parsemessage();\n                            if (s6 !== peg$FAILED) {\n                                if (input.charCodeAt(peg$currPos) === 125) {\n                                    s7 = peg$c24;\n                                    peg$currPos++;\n                                }\n                                else {\n                                    s7 = peg$FAILED;\n                                    if (peg$silentFails === 0) {\n                                        peg$fail(peg$c25);\n                                    }\n                                }\n                                if (s7 !== peg$FAILED) {\n                                    peg$savedPos = s0;\n                                    s1 = peg$c75(s2, s6);\n                                    s0 = s1;\n                                }\n                                else {\n                                    peg$currPos = s0;\n                                    s0 = peg$FAILED;\n                                }\n                            }\n                            else {\n                                peg$currPos = s0;\n                                s0 = peg$FAILED;\n                            }\n                        }\n                        else {\n                            peg$currPos = s0;\n                            s0 = peg$FAILED;\n                        }\n                    }\n                    else {\n                        peg$currPos = s0;\n                        s0 = peg$FAILED;\n                    }\n                }\n                else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        return s0;\n    }\n    function peg$parsepluralOption() {\n        var s0, s1, s2, s3, s4, s5, s6, s7;\n        s0 = peg$currPos;\n        s1 = peg$parse_();\n        if (s1 !== peg$FAILED) {\n            s2 = peg$parsepluralRuleSelectValue();\n            if (s2 !== peg$FAILED) {\n                s3 = peg$parse_();\n                if (s3 !== peg$FAILED) {\n                    if (input.charCodeAt(peg$currPos) === 123) {\n                        s4 = peg$c22;\n                        peg$currPos++;\n                    }\n                    else {\n                        s4 = peg$FAILED;\n                        if (peg$silentFails === 0) {\n                            peg$fail(peg$c23);\n                        }\n                    }\n                    if (s4 !== peg$FAILED) {\n                        peg$savedPos = peg$currPos;\n                        s5 = peg$c76(s2);\n                        if (s5) {\n                            s5 = undefined;\n                        }\n                        else {\n                            s5 = peg$FAILED;\n                        }\n                        if (s5 !== peg$FAILED) {\n                            s6 = peg$parsemessage();\n                            if (s6 !== peg$FAILED) {\n                                if (input.charCodeAt(peg$currPos) === 125) {\n                                    s7 = peg$c24;\n                                    peg$currPos++;\n                                }\n                                else {\n                                    s7 = peg$FAILED;\n                                    if (peg$silentFails === 0) {\n                                        peg$fail(peg$c25);\n                                    }\n                                }\n                                if (s7 !== peg$FAILED) {\n                                    peg$savedPos = s0;\n                                    s1 = peg$c77(s2, s6);\n                                    s0 = s1;\n                                }\n                                else {\n                                    peg$currPos = s0;\n                                    s0 = peg$FAILED;\n                                }\n                            }\n                            else {\n                                peg$currPos = s0;\n                                s0 = peg$FAILED;\n                            }\n                        }\n                        else {\n                            peg$currPos = s0;\n                            s0 = peg$FAILED;\n                        }\n                    }\n                    else {\n                        peg$currPos = s0;\n                        s0 = peg$FAILED;\n                    }\n                }\n                else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        return s0;\n    }\n    function peg$parsewhiteSpace() {\n        var s0, s1;\n        peg$silentFails++;\n        if (peg$c79.test(input.charAt(peg$currPos))) {\n            s0 = input.charAt(peg$currPos);\n            peg$currPos++;\n        }\n        else {\n            s0 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c80);\n            }\n        }\n        peg$silentFails--;\n        if (s0 === peg$FAILED) {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c78);\n            }\n        }\n        return s0;\n    }\n    function peg$parsepatternSyntax() {\n        var s0, s1;\n        peg$silentFails++;\n        if (peg$c82.test(input.charAt(peg$currPos))) {\n            s0 = input.charAt(peg$currPos);\n            peg$currPos++;\n        }\n        else {\n            s0 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c83);\n            }\n        }\n        peg$silentFails--;\n        if (s0 === peg$FAILED) {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c81);\n            }\n        }\n        return s0;\n    }\n    function peg$parse_() {\n        var s0, s1, s2;\n        peg$silentFails++;\n        s0 = peg$currPos;\n        s1 = [];\n        s2 = peg$parsewhiteSpace();\n        while (s2 !== peg$FAILED) {\n            s1.push(s2);\n            s2 = peg$parsewhiteSpace();\n        }\n        if (s1 !== peg$FAILED) {\n            s0 = input.substring(s0, peg$currPos);\n        }\n        else {\n            s0 = s1;\n        }\n        peg$silentFails--;\n        if (s0 === peg$FAILED) {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c84);\n            }\n        }\n        return s0;\n    }\n    function peg$parsenumber() {\n        var s0, s1, s2;\n        peg$silentFails++;\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 45) {\n            s1 = peg$c86;\n            peg$currPos++;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c87);\n            }\n        }\n        if (s1 === peg$FAILED) {\n            s1 = null;\n        }\n        if (s1 !== peg$FAILED) {\n            s2 = peg$parseargNumber();\n            if (s2 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c88(s1, s2);\n                s0 = s1;\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        peg$silentFails--;\n        if (s0 === peg$FAILED) {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c85);\n            }\n        }\n        return s0;\n    }\n    function peg$parseapostrophe() {\n        var s0, s1;\n        peg$silentFails++;\n        if (input.charCodeAt(peg$currPos) === 39) {\n            s0 = peg$c48;\n            peg$currPos++;\n        }\n        else {\n            s0 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c49);\n            }\n        }\n        peg$silentFails--;\n        if (s0 === peg$FAILED) {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c89);\n            }\n        }\n        return s0;\n    }\n    function peg$parsedoubleApostrophes() {\n        var s0, s1;\n        peg$silentFails++;\n        s0 = peg$currPos;\n        if (input.substr(peg$currPos, 2) === peg$c91) {\n            s1 = peg$c91;\n            peg$currPos += 2;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c92);\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c93();\n        }\n        s0 = s1;\n        peg$silentFails--;\n        if (s0 === peg$FAILED) {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c90);\n            }\n        }\n        return s0;\n    }\n    function peg$parsequotedString() {\n        var s0, s1, s2, s3, s4, s5;\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 39) {\n            s1 = peg$c48;\n            peg$currPos++;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c49);\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            s2 = peg$parseescapedChar();\n            if (s2 !== peg$FAILED) {\n                s3 = peg$currPos;\n                s4 = [];\n                if (input.substr(peg$currPos, 2) === peg$c91) {\n                    s5 = peg$c91;\n                    peg$currPos += 2;\n                }\n                else {\n                    s5 = peg$FAILED;\n                    if (peg$silentFails === 0) {\n                        peg$fail(peg$c92);\n                    }\n                }\n                if (s5 === peg$FAILED) {\n                    if (peg$c50.test(input.charAt(peg$currPos))) {\n                        s5 = input.charAt(peg$currPos);\n                        peg$currPos++;\n                    }\n                    else {\n                        s5 = peg$FAILED;\n                        if (peg$silentFails === 0) {\n                            peg$fail(peg$c51);\n                        }\n                    }\n                }\n                while (s5 !== peg$FAILED) {\n                    s4.push(s5);\n                    if (input.substr(peg$currPos, 2) === peg$c91) {\n                        s5 = peg$c91;\n                        peg$currPos += 2;\n                    }\n                    else {\n                        s5 = peg$FAILED;\n                        if (peg$silentFails === 0) {\n                            peg$fail(peg$c92);\n                        }\n                    }\n                    if (s5 === peg$FAILED) {\n                        if (peg$c50.test(input.charAt(peg$currPos))) {\n                            s5 = input.charAt(peg$currPos);\n                            peg$currPos++;\n                        }\n                        else {\n                            s5 = peg$FAILED;\n                            if (peg$silentFails === 0) {\n                                peg$fail(peg$c51);\n                            }\n                        }\n                    }\n                }\n                if (s4 !== peg$FAILED) {\n                    s3 = input.substring(s3, peg$currPos);\n                }\n                else {\n                    s3 = s4;\n                }\n                if (s3 !== peg$FAILED) {\n                    if (input.charCodeAt(peg$currPos) === 39) {\n                        s4 = peg$c48;\n                        peg$currPos++;\n                    }\n                    else {\n                        s4 = peg$FAILED;\n                        if (peg$silentFails === 0) {\n                            peg$fail(peg$c49);\n                        }\n                    }\n                    if (s4 === peg$FAILED) {\n                        s4 = null;\n                    }\n                    if (s4 !== peg$FAILED) {\n                        peg$savedPos = s0;\n                        s1 = peg$c94(s2, s3);\n                        s0 = s1;\n                    }\n                    else {\n                        peg$currPos = s0;\n                        s0 = peg$FAILED;\n                    }\n                }\n                else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        return s0;\n    }\n    function peg$parseunquotedString() {\n        var s0, s1, s2, s3;\n        s0 = peg$currPos;\n        s1 = peg$currPos;\n        if (input.length > peg$currPos) {\n            s2 = input.charAt(peg$currPos);\n            peg$currPos++;\n        }\n        else {\n            s2 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c30);\n            }\n        }\n        if (s2 !== peg$FAILED) {\n            peg$savedPos = peg$currPos;\n            s3 = peg$c95(s2);\n            if (s3) {\n                s3 = undefined;\n            }\n            else {\n                s3 = peg$FAILED;\n            }\n            if (s3 !== peg$FAILED) {\n                s2 = [s2, s3];\n                s1 = s2;\n            }\n            else {\n                peg$currPos = s1;\n                s1 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s1;\n            s1 = peg$FAILED;\n        }\n        if (s1 === peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 10) {\n                s1 = peg$c96;\n                peg$currPos++;\n            }\n            else {\n                s1 = peg$FAILED;\n                if (peg$silentFails === 0) {\n                    peg$fail(peg$c97);\n                }\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            s0 = input.substring(s0, peg$currPos);\n        }\n        else {\n            s0 = s1;\n        }\n        return s0;\n    }\n    function peg$parseescapedChar() {\n        var s0, s1, s2, s3;\n        s0 = peg$currPos;\n        s1 = peg$currPos;\n        if (input.length > peg$currPos) {\n            s2 = input.charAt(peg$currPos);\n            peg$currPos++;\n        }\n        else {\n            s2 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c30);\n            }\n        }\n        if (s2 !== peg$FAILED) {\n            peg$savedPos = peg$currPos;\n            s3 = peg$c98(s2);\n            if (s3) {\n                s3 = undefined;\n            }\n            else {\n                s3 = peg$FAILED;\n            }\n            if (s3 !== peg$FAILED) {\n                s2 = [s2, s3];\n                s1 = s2;\n            }\n            else {\n                peg$currPos = s1;\n                s1 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s1;\n            s1 = peg$FAILED;\n        }\n        if (s1 !== peg$FAILED) {\n            s0 = input.substring(s0, peg$currPos);\n        }\n        else {\n            s0 = s1;\n        }\n        return s0;\n    }\n    function peg$parseargNameOrNumber() {\n        var s0, s1;\n        peg$silentFails++;\n        s0 = peg$currPos;\n        s1 = peg$parseargNumber();\n        if (s1 === peg$FAILED) {\n            s1 = peg$parseargName();\n        }\n        if (s1 !== peg$FAILED) {\n            s0 = input.substring(s0, peg$currPos);\n        }\n        else {\n            s0 = s1;\n        }\n        peg$silentFails--;\n        if (s0 === peg$FAILED) {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c99);\n            }\n        }\n        return s0;\n    }\n    function peg$parsevalidTag() {\n        var s0, s1;\n        peg$silentFails++;\n        s0 = peg$currPos;\n        s1 = peg$parseargNumber();\n        if (s1 === peg$FAILED) {\n            s1 = peg$parsetagName();\n        }\n        if (s1 !== peg$FAILED) {\n            s0 = input.substring(s0, peg$currPos);\n        }\n        else {\n            s0 = s1;\n        }\n        peg$silentFails--;\n        if (s0 === peg$FAILED) {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c100);\n            }\n        }\n        return s0;\n    }\n    function peg$parseargNumber() {\n        var s0, s1, s2, s3, s4;\n        peg$silentFails++;\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 48) {\n            s1 = peg$c102;\n            peg$currPos++;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c103);\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c104();\n        }\n        s0 = s1;\n        if (s0 === peg$FAILED) {\n            s0 = peg$currPos;\n            s1 = peg$currPos;\n            if (peg$c105.test(input.charAt(peg$currPos))) {\n                s2 = input.charAt(peg$currPos);\n                peg$currPos++;\n            }\n            else {\n                s2 = peg$FAILED;\n                if (peg$silentFails === 0) {\n                    peg$fail(peg$c106);\n                }\n            }\n            if (s2 !== peg$FAILED) {\n                s3 = [];\n                if (peg$c107.test(input.charAt(peg$currPos))) {\n                    s4 = input.charAt(peg$currPos);\n                    peg$currPos++;\n                }\n                else {\n                    s4 = peg$FAILED;\n                    if (peg$silentFails === 0) {\n                        peg$fail(peg$c108);\n                    }\n                }\n                while (s4 !== peg$FAILED) {\n                    s3.push(s4);\n                    if (peg$c107.test(input.charAt(peg$currPos))) {\n                        s4 = input.charAt(peg$currPos);\n                        peg$currPos++;\n                    }\n                    else {\n                        s4 = peg$FAILED;\n                        if (peg$silentFails === 0) {\n                            peg$fail(peg$c108);\n                        }\n                    }\n                }\n                if (s3 !== peg$FAILED) {\n                    s2 = [s2, s3];\n                    s1 = s2;\n                }\n                else {\n                    peg$currPos = s1;\n                    s1 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s1;\n                s1 = peg$FAILED;\n            }\n            if (s1 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c109(s1);\n            }\n            s0 = s1;\n        }\n        peg$silentFails--;\n        if (s0 === peg$FAILED) {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c101);\n            }\n        }\n        return s0;\n    }\n    function peg$parseargName() {\n        var s0, s1, s2, s3, s4;\n        peg$silentFails++;\n        s0 = peg$currPos;\n        s1 = [];\n        s2 = peg$currPos;\n        s3 = peg$currPos;\n        peg$silentFails++;\n        s4 = peg$parsewhiteSpace();\n        if (s4 === peg$FAILED) {\n            s4 = peg$parsepatternSyntax();\n        }\n        peg$silentFails--;\n        if (s4 === peg$FAILED) {\n            s3 = undefined;\n        }\n        else {\n            peg$currPos = s3;\n            s3 = peg$FAILED;\n        }\n        if (s3 !== peg$FAILED) {\n            if (input.length > peg$currPos) {\n                s4 = input.charAt(peg$currPos);\n                peg$currPos++;\n            }\n            else {\n                s4 = peg$FAILED;\n                if (peg$silentFails === 0) {\n                    peg$fail(peg$c30);\n                }\n            }\n            if (s4 !== peg$FAILED) {\n                s3 = [s3, s4];\n                s2 = s3;\n            }\n            else {\n                peg$currPos = s2;\n                s2 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s2;\n            s2 = peg$FAILED;\n        }\n        if (s2 !== peg$FAILED) {\n            while (s2 !== peg$FAILED) {\n                s1.push(s2);\n                s2 = peg$currPos;\n                s3 = peg$currPos;\n                peg$silentFails++;\n                s4 = peg$parsewhiteSpace();\n                if (s4 === peg$FAILED) {\n                    s4 = peg$parsepatternSyntax();\n                }\n                peg$silentFails--;\n                if (s4 === peg$FAILED) {\n                    s3 = undefined;\n                }\n                else {\n                    peg$currPos = s3;\n                    s3 = peg$FAILED;\n                }\n                if (s3 !== peg$FAILED) {\n                    if (input.length > peg$currPos) {\n                        s4 = input.charAt(peg$currPos);\n                        peg$currPos++;\n                    }\n                    else {\n                        s4 = peg$FAILED;\n                        if (peg$silentFails === 0) {\n                            peg$fail(peg$c30);\n                        }\n                    }\n                    if (s4 !== peg$FAILED) {\n                        s3 = [s3, s4];\n                        s2 = s3;\n                    }\n                    else {\n                        peg$currPos = s2;\n                        s2 = peg$FAILED;\n                    }\n                }\n                else {\n                    peg$currPos = s2;\n                    s2 = peg$FAILED;\n                }\n            }\n        }\n        else {\n            s1 = peg$FAILED;\n        }\n        if (s1 !== peg$FAILED) {\n            s0 = input.substring(s0, peg$currPos);\n        }\n        else {\n            s0 = s1;\n        }\n        peg$silentFails--;\n        if (s0 === peg$FAILED) {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c110);\n            }\n        }\n        return s0;\n    }\n    function peg$parsetagName() {\n        var s0, s1, s2, s3, s4;\n        peg$silentFails++;\n        s0 = peg$currPos;\n        s1 = [];\n        if (input.charCodeAt(peg$currPos) === 45) {\n            s2 = peg$c86;\n            peg$currPos++;\n        }\n        else {\n            s2 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c87);\n            }\n        }\n        if (s2 === peg$FAILED) {\n            s2 = peg$currPos;\n            s3 = peg$currPos;\n            peg$silentFails++;\n            s4 = peg$parsewhiteSpace();\n            if (s4 === peg$FAILED) {\n                s4 = peg$parsepatternSyntax();\n            }\n            peg$silentFails--;\n            if (s4 === peg$FAILED) {\n                s3 = undefined;\n            }\n            else {\n                peg$currPos = s3;\n                s3 = peg$FAILED;\n            }\n            if (s3 !== peg$FAILED) {\n                if (input.length > peg$currPos) {\n                    s4 = input.charAt(peg$currPos);\n                    peg$currPos++;\n                }\n                else {\n                    s4 = peg$FAILED;\n                    if (peg$silentFails === 0) {\n                        peg$fail(peg$c30);\n                    }\n                }\n                if (s4 !== peg$FAILED) {\n                    s3 = [s3, s4];\n                    s2 = s3;\n                }\n                else {\n                    peg$currPos = s2;\n                    s2 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s2;\n                s2 = peg$FAILED;\n            }\n        }\n        if (s2 !== peg$FAILED) {\n            while (s2 !== peg$FAILED) {\n                s1.push(s2);\n                if (input.charCodeAt(peg$currPos) === 45) {\n                    s2 = peg$c86;\n                    peg$currPos++;\n                }\n                else {\n                    s2 = peg$FAILED;\n                    if (peg$silentFails === 0) {\n                        peg$fail(peg$c87);\n                    }\n                }\n                if (s2 === peg$FAILED) {\n                    s2 = peg$currPos;\n                    s3 = peg$currPos;\n                    peg$silentFails++;\n                    s4 = peg$parsewhiteSpace();\n                    if (s4 === peg$FAILED) {\n                        s4 = peg$parsepatternSyntax();\n                    }\n                    peg$silentFails--;\n                    if (s4 === peg$FAILED) {\n                        s3 = undefined;\n                    }\n                    else {\n                        peg$currPos = s3;\n                        s3 = peg$FAILED;\n                    }\n                    if (s3 !== peg$FAILED) {\n                        if (input.length > peg$currPos) {\n                            s4 = input.charAt(peg$currPos);\n                            peg$currPos++;\n                        }\n                        else {\n                            s4 = peg$FAILED;\n                            if (peg$silentFails === 0) {\n                                peg$fail(peg$c30);\n                            }\n                        }\n                        if (s4 !== peg$FAILED) {\n                            s3 = [s3, s4];\n                            s2 = s3;\n                        }\n                        else {\n                            peg$currPos = s2;\n                            s2 = peg$FAILED;\n                        }\n                    }\n                    else {\n                        peg$currPos = s2;\n                        s2 = peg$FAILED;\n                    }\n                }\n            }\n        }\n        else {\n            s1 = peg$FAILED;\n        }\n        if (s1 !== peg$FAILED) {\n            s0 = input.substring(s0, peg$currPos);\n        }\n        else {\n            s0 = s1;\n        }\n        peg$silentFails--;\n        if (s0 === peg$FAILED) {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$c111);\n            }\n        }\n        return s0;\n    }\n    var messageCtx = ['root'];\n    function isNestedMessageText() {\n        return messageCtx.length > 1;\n    }\n    function isInPluralOption() {\n        return messageCtx[messageCtx.length - 1] === 'plural';\n    }\n    function insertLocation() {\n        return options && options.captureLocation ? {\n            location: location()\n        } : {};\n    }\n    var ignoreTag = options && options.ignoreTag;\n    var shouldParseSkeleton = options && options.shouldParseSkeleton;\n    peg$result = peg$startRuleFunction();\n    if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n        return peg$result;\n    }\n    else {\n        if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n            peg$fail(peg$endExpectation());\n        }\n        throw peg$buildStructuredError(peg$maxFailExpected, peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, peg$maxFailPos < input.length\n            ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)\n            : peg$computeLocation(peg$maxFailPos, peg$maxFailPos));\n    }\n}\nexport var pegParse = peg$parse;\n","import { __spreadArrays } from \"tslib\";\nimport { isPluralElement, isLiteralElement, isSelectElement, } from './types';\nimport { pegParse } from './parser';\nvar PLURAL_HASHTAG_REGEX = /(^|[^\\\\])#/g;\n/**\n * Whether to convert `#` in plural rule options\n * to `{var, number}`\n * @param el AST Element\n * @param pluralStack current plural stack\n */\nexport function normalizeHashtagInPlural(els) {\n    els.forEach(function (el) {\n        // If we're encountering a plural el\n        if (!isPluralElement(el) && !isSelectElement(el)) {\n            return;\n        }\n        // Go down the options and search for # in any literal element\n        Object.keys(el.options).forEach(function (id) {\n            var _a;\n            var opt = el.options[id];\n            // If we got a match, we have to split this\n            // and inject a NumberElement in the middle\n            var matchingLiteralElIndex = -1;\n            var literalEl = undefined;\n            for (var i = 0; i < opt.value.length; i++) {\n                var el_1 = opt.value[i];\n                if (isLiteralElement(el_1) && PLURAL_HASHTAG_REGEX.test(el_1.value)) {\n                    matchingLiteralElIndex = i;\n                    literalEl = el_1;\n                    break;\n                }\n            }\n            if (literalEl) {\n                var newValue = literalEl.value.replace(PLURAL_HASHTAG_REGEX, \"$1{\" + el.value + \", number}\");\n                var newEls = pegParse(newValue);\n                (_a = opt.value).splice.apply(_a, __spreadArrays([matchingLiteralElIndex, 1], newEls));\n            }\n            normalizeHashtagInPlural(opt.value);\n        });\n    });\n}\n","import { __assign } from \"tslib\";\nimport { pegParse } from './src/parser';\nimport { normalizeHashtagInPlural } from './src/normalize';\nexport * from './src/types';\nexport * from './src/parser';\nexport function parse(input, opts) {\n    opts = __assign({ normalizeHashtagInPlural: true, shouldParseSkeleton: true }, (opts || {}));\n    var els = pegParse(input, opts);\n    if (opts.normalizeHashtagInPlural) {\n        normalizeHashtagInPlural(els);\n    }\n    return els;\n}\n","import { __extends } from \"tslib\";\nexport var ErrorCode;\n(function (ErrorCode) {\n    // When we have a placeholder but no value to format\n    ErrorCode[\"MISSING_VALUE\"] = \"MISSING_VALUE\";\n    // When value supplied is invalid\n    ErrorCode[\"INVALID_VALUE\"] = \"INVALID_VALUE\";\n    // When we need specific Intl API but it's not available\n    ErrorCode[\"MISSING_INTL_API\"] = \"MISSING_INTL_API\";\n})(ErrorCode || (ErrorCode = {}));\nvar FormatError = /** @class */ (function (_super) {\n    __extends(FormatError, _super);\n    function FormatError(msg, code, originalMessage) {\n        var _this = _super.call(this, msg) || this;\n        _this.code = code;\n        _this.originalMessage = originalMessage;\n        return _this;\n    }\n    FormatError.prototype.toString = function () {\n        return \"[formatjs Error: \" + this.code + \"] \" + this.message;\n    };\n    return FormatError;\n}(Error));\nexport { FormatError };\nvar InvalidValueError = /** @class */ (function (_super) {\n    __extends(InvalidValueError, _super);\n    function InvalidValueError(variableId, value, options, originalMessage) {\n        return _super.call(this, \"Invalid values for \\\"\" + variableId + \"\\\": \\\"\" + value + \"\\\". Options are \\\"\" + Object.keys(options).join('\", \"') + \"\\\"\", \"INVALID_VALUE\" /* INVALID_VALUE */, originalMessage) || this;\n    }\n    return InvalidValueError;\n}(FormatError));\nexport { InvalidValueError };\nvar InvalidValueTypeError = /** @class */ (function (_super) {\n    __extends(InvalidValueTypeError, _super);\n    function InvalidValueTypeError(value, type, originalMessage) {\n        return _super.call(this, \"Value for \\\"\" + value + \"\\\" must be of type \" + type, \"INVALID_VALUE\" /* INVALID_VALUE */, originalMessage) || this;\n    }\n    return InvalidValueTypeError;\n}(FormatError));\nexport { InvalidValueTypeError };\nvar MissingValueError = /** @class */ (function (_super) {\n    __extends(MissingValueError, _super);\n    function MissingValueError(variableId, originalMessage) {\n        return _super.call(this, \"The intl string context variable \\\"\" + variableId + \"\\\" was not provided to the string \\\"\" + originalMessage + \"\\\"\", \"MISSING_VALUE\" /* MISSING_VALUE */, originalMessage) || this;\n    }\n    return MissingValueError;\n}(FormatError));\nexport { MissingValueError };\n","import { isArgumentElement, isDateElement, isDateTimeSkeleton, isLiteralElement, isNumberElement, isNumberSkeleton, isPluralElement, isPoundElement, isSelectElement, isTimeElement, isTagElement, } from 'intl-messageformat-parser';\nimport { MissingValueError, InvalidValueError, FormatError, InvalidValueTypeError, } from './error';\nexport var PART_TYPE;\n(function (PART_TYPE) {\n    PART_TYPE[PART_TYPE[\"literal\"] = 0] = \"literal\";\n    PART_TYPE[PART_TYPE[\"object\"] = 1] = \"object\";\n})(PART_TYPE || (PART_TYPE = {}));\nfunction mergeLiteral(parts) {\n    if (parts.length < 2) {\n        return parts;\n    }\n    return parts.reduce(function (all, part) {\n        var lastPart = all[all.length - 1];\n        if (!lastPart ||\n            lastPart.type !== 0 /* literal */ ||\n            part.type !== 0 /* literal */) {\n            all.push(part);\n        }\n        else {\n            lastPart.value += part.value;\n        }\n        return all;\n    }, []);\n}\nexport function isFormatXMLElementFn(el) {\n    return typeof el === 'function';\n}\n// TODO(skeleton): add skeleton support\nexport function formatToParts(els, locales, formatters, formats, values, currentPluralValue, \n// For debugging\noriginalMessage) {\n    // Hot path for straight simple msg translations\n    if (els.length === 1 && isLiteralElement(els[0])) {\n        return [\n            {\n                type: 0 /* literal */,\n                value: els[0].value,\n            },\n        ];\n    }\n    var result = [];\n    for (var _i = 0, els_1 = els; _i < els_1.length; _i++) {\n        var el = els_1[_i];\n        // Exit early for string parts.\n        if (isLiteralElement(el)) {\n            result.push({\n                type: 0 /* literal */,\n                value: el.value,\n            });\n            continue;\n        }\n        // TODO: should this part be literal type?\n        // Replace `#` in plural rules with the actual numeric value.\n        if (isPoundElement(el)) {\n            if (typeof currentPluralValue === 'number') {\n                result.push({\n                    type: 0 /* literal */,\n                    value: formatters.getNumberFormat(locales).format(currentPluralValue),\n                });\n            }\n            continue;\n        }\n        var varName = el.value;\n        // Enforce that all required values are provided by the caller.\n        if (!(values && varName in values)) {\n            throw new MissingValueError(varName, originalMessage);\n        }\n        var value = values[varName];\n        if (isArgumentElement(el)) {\n            if (!value || typeof value === 'string' || typeof value === 'number') {\n                value =\n                    typeof value === 'string' || typeof value === 'number'\n                        ? String(value)\n                        : '';\n            }\n            result.push({\n                type: typeof value === 'string' ? 0 /* literal */ : 1 /* object */,\n                value: value,\n            });\n            continue;\n        }\n        // Recursively format plural and select parts' option — which can be a\n        // nested pattern structure. The choosing of the option to use is\n        // abstracted-by and delegated-to the part helper object.\n        if (isDateElement(el)) {\n            var style = typeof el.style === 'string'\n                ? formats.date[el.style]\n                : isDateTimeSkeleton(el.style)\n                    ? el.style.parsedOptions\n                    : undefined;\n            result.push({\n                type: 0 /* literal */,\n                value: formatters\n                    .getDateTimeFormat(locales, style)\n                    .format(value),\n            });\n            continue;\n        }\n        if (isTimeElement(el)) {\n            var style = typeof el.style === 'string'\n                ? formats.time[el.style]\n                : isDateTimeSkeleton(el.style)\n                    ? el.style.parsedOptions\n                    : undefined;\n            result.push({\n                type: 0 /* literal */,\n                value: formatters\n                    .getDateTimeFormat(locales, style)\n                    .format(value),\n            });\n            continue;\n        }\n        if (isNumberElement(el)) {\n            var style = typeof el.style === 'string'\n                ? formats.number[el.style]\n                : isNumberSkeleton(el.style)\n                    ? el.style.parsedOptions\n                    : undefined;\n            if (style && style.scale) {\n                value =\n                    value *\n                        (style.scale || 1);\n            }\n            result.push({\n                type: 0 /* literal */,\n                value: formatters\n                    .getNumberFormat(locales, style)\n                    .format(value),\n            });\n            continue;\n        }\n        if (isTagElement(el)) {\n            var children = el.children, value_1 = el.value;\n            var formatFn = values[value_1];\n            if (!isFormatXMLElementFn(formatFn)) {\n                throw new InvalidValueTypeError(value_1, 'function', originalMessage);\n            }\n            var parts = formatToParts(children, locales, formatters, formats, values, currentPluralValue);\n            var chunks = formatFn(parts.map(function (p) { return p.value; }));\n            if (!Array.isArray(chunks)) {\n                chunks = [chunks];\n            }\n            result.push.apply(result, chunks.map(function (c) {\n                return {\n                    type: typeof c === 'string' ? 0 /* literal */ : 1 /* object */,\n                    value: c,\n                };\n            }));\n        }\n        if (isSelectElement(el)) {\n            var opt = el.options[value] || el.options.other;\n            if (!opt) {\n                throw new InvalidValueError(el.value, value, Object.keys(el.options), originalMessage);\n            }\n            result.push.apply(result, formatToParts(opt.value, locales, formatters, formats, values));\n            continue;\n        }\n        if (isPluralElement(el)) {\n            var opt = el.options[\"=\" + value];\n            if (!opt) {\n                if (!Intl.PluralRules) {\n                    throw new FormatError(\"Intl.PluralRules is not available in this environment.\\nTry polyfilling it using \\\"@formatjs/intl-pluralrules\\\"\\n\", \"MISSING_INTL_API\" /* MISSING_INTL_API */, originalMessage);\n                }\n                var rule = formatters\n                    .getPluralRules(locales, { type: el.pluralType })\n                    .select(value - (el.offset || 0));\n                opt = el.options[rule] || el.options.other;\n            }\n            if (!opt) {\n                throw new InvalidValueError(el.value, value, Object.keys(el.options), originalMessage);\n            }\n            result.push.apply(result, formatToParts(opt.value, locales, formatters, formats, values, value - (el.offset || 0)));\n            continue;\n        }\n    }\n    return mergeLiteral(result);\n}\n","/*\nCopyright (c) 2014, Yahoo! Inc. All rights reserved.\nCopyrights licensed under the New BSD License.\nSee the accompanying LICENSE file for terms.\n*/\nimport { __assign, __spreadArrays } from \"tslib\";\nimport { parse } from 'intl-messageformat-parser';\nimport * as memoize from 'fast-memoize';\nimport { formatToParts, } from './formatters';\n// -- MessageFormat --------------------------------------------------------\nfunction mergeConfig(c1, c2) {\n    if (!c2) {\n        return c1;\n    }\n    return __assign(__assign(__assign({}, (c1 || {})), (c2 || {})), Object.keys(c1).reduce(function (all, k) {\n        all[k] = __assign(__assign({}, c1[k]), (c2[k] || {}));\n        return all;\n    }, {}));\n}\nfunction mergeConfigs(defaultConfig, configs) {\n    if (!configs) {\n        return defaultConfig;\n    }\n    return Object.keys(defaultConfig).reduce(function (all, k) {\n        all[k] = mergeConfig(defaultConfig[k], configs[k]);\n        return all;\n    }, __assign({}, defaultConfig));\n}\nfunction createFastMemoizeCache(store) {\n    return {\n        create: function () {\n            return {\n                has: function (key) {\n                    return key in store;\n                },\n                get: function (key) {\n                    return store[key];\n                },\n                set: function (key, value) {\n                    store[key] = value;\n                },\n            };\n        },\n    };\n}\n// @ts-ignore this is to deal with rollup's default import shenanigans\nvar _memoizeIntl = memoize.default || memoize;\nvar memoizeIntl = _memoizeIntl;\nfunction createDefaultFormatters(cache) {\n    if (cache === void 0) { cache = {\n        number: {},\n        dateTime: {},\n        pluralRules: {},\n    }; }\n    return {\n        getNumberFormat: memoizeIntl(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, __spreadArrays([void 0], args)))();\n        }, {\n            cache: createFastMemoizeCache(cache.number),\n            strategy: memoizeIntl.strategies.variadic,\n        }),\n        getDateTimeFormat: memoizeIntl(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, __spreadArrays([void 0], args)))();\n        }, {\n            cache: createFastMemoizeCache(cache.dateTime),\n            strategy: memoizeIntl.strategies.variadic,\n        }),\n        getPluralRules: memoizeIntl(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, __spreadArrays([void 0], args)))();\n        }, {\n            cache: createFastMemoizeCache(cache.pluralRules),\n            strategy: memoizeIntl.strategies.variadic,\n        }),\n    };\n}\nvar IntlMessageFormat = /** @class */ (function () {\n    function IntlMessageFormat(message, locales, overrideFormats, opts) {\n        var _this = this;\n        if (locales === void 0) { locales = IntlMessageFormat.defaultLocale; }\n        this.formatterCache = {\n            number: {},\n            dateTime: {},\n            pluralRules: {},\n        };\n        this.format = function (values) {\n            var parts = _this.formatToParts(values);\n            // Hot path for straight simple msg translations\n            if (parts.length === 1) {\n                return parts[0].value;\n            }\n            var result = parts.reduce(function (all, part) {\n                if (!all.length ||\n                    part.type !== 0 /* literal */ ||\n                    typeof all[all.length - 1] !== 'string') {\n                    all.push(part.value);\n                }\n                else {\n                    all[all.length - 1] += part.value;\n                }\n                return all;\n            }, []);\n            if (result.length <= 1) {\n                return result[0] || '';\n            }\n            return result;\n        };\n        this.formatToParts = function (values) {\n            return formatToParts(_this.ast, _this.locales, _this.formatters, _this.formats, values, undefined, _this.message);\n        };\n        this.resolvedOptions = function () { return ({\n            locale: Intl.NumberFormat.supportedLocalesOf(_this.locales)[0],\n        }); };\n        this.getAst = function () { return _this.ast; };\n        if (typeof message === 'string') {\n            this.message = message;\n            if (!IntlMessageFormat.__parse) {\n                throw new TypeError('IntlMessageFormat.__parse must be set to process `message` of type `string`');\n            }\n            // Parse string messages into an AST.\n            this.ast = IntlMessageFormat.__parse(message, {\n                normalizeHashtagInPlural: false,\n                ignoreTag: opts === null || opts === void 0 ? void 0 : opts.ignoreTag,\n            });\n        }\n        else {\n            this.ast = message;\n        }\n        if (!Array.isArray(this.ast)) {\n            throw new TypeError('A message must be provided as a String or AST.');\n        }\n        // Creates a new object with the specified `formats` merged with the default\n        // formats.\n        this.formats = mergeConfigs(IntlMessageFormat.formats, overrideFormats);\n        // Defined first because it's used to build the format pattern.\n        this.locales = locales;\n        this.formatters =\n            (opts && opts.formatters) || createDefaultFormatters(this.formatterCache);\n    }\n    Object.defineProperty(IntlMessageFormat, \"defaultLocale\", {\n        get: function () {\n            if (!IntlMessageFormat.memoizedDefaultLocale) {\n                IntlMessageFormat.memoizedDefaultLocale = new Intl.NumberFormat().resolvedOptions().locale;\n            }\n            return IntlMessageFormat.memoizedDefaultLocale;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    IntlMessageFormat.memoizedDefaultLocale = null;\n    IntlMessageFormat.__parse = parse;\n    // Default format options used as the prototype of the `formats` provided to the\n    // constructor. These are used when constructing the internal Intl.NumberFormat\n    // and Intl.DateTimeFormat instances.\n    IntlMessageFormat.formats = {\n        number: {\n            currency: {\n                style: 'currency',\n            },\n            percent: {\n                style: 'percent',\n            },\n        },\n        date: {\n            short: {\n                month: 'numeric',\n                day: 'numeric',\n                year: '2-digit',\n            },\n            medium: {\n                month: 'short',\n                day: 'numeric',\n                year: 'numeric',\n            },\n            long: {\n                month: 'long',\n                day: 'numeric',\n                year: 'numeric',\n            },\n            full: {\n                weekday: 'long',\n                month: 'long',\n                day: 'numeric',\n                year: 'numeric',\n            },\n        },\n        time: {\n            short: {\n                hour: 'numeric',\n                minute: 'numeric',\n            },\n            medium: {\n                hour: 'numeric',\n                minute: 'numeric',\n                second: 'numeric',\n            },\n            long: {\n                hour: 'numeric',\n                minute: 'numeric',\n                second: 'numeric',\n                timeZoneName: 'short',\n            },\n            full: {\n                hour: 'numeric',\n                minute: 'numeric',\n                second: 'numeric',\n                timeZoneName: 'short',\n            },\n        },\n    };\n    return IntlMessageFormat;\n}());\nexport { IntlMessageFormat };\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 = _super.call(this, \"[@formatjs/intl Error \" + code + \"] \" + message + \" \\n\" + (exception ? \"\\n\" + exception.message + \"\\n\" + exception.stack : '')) || this;\n        _this.code = code;\n        if (typeof Error.captureStackTrace === 'function') {\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 MessageFormatError = /** @class */ (function (_super) {\n    __extends(MessageFormatError, _super);\n    function MessageFormatError(message, locale, descriptor, exception) {\n        var _this = _super.call(this, IntlErrorCode.FORMAT_ERROR, message + \" \\nLocale: \" + locale + \"\\nMessageID: \" + (descriptor === null || descriptor === void 0 ? void 0 : descriptor.id) + \"\\nDefault Message: \" + (descriptor === null || descriptor === void 0 ? void 0 : descriptor.defaultMessage) + \"\\nDescription: \" + (descriptor === null || descriptor === void 0 ? void 0 : descriptor.description) + \" \\n\", exception) || this;\n        _this.descriptor = descriptor;\n        return _this;\n    }\n    return MessageFormatError;\n}(IntlError));\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: \\\"\" + descriptor.id + \"\\\" for locale \\\"\" + locale + \"\\\", using \" + (descriptor.defaultMessage ? 'default message' : 'id') + \" as fallback.\") || this;\n        _this.descriptor = descriptor;\n        return _this;\n    }\n    return MissingTranslationError;\n}(IntlError));\nexport { MissingTranslationError };\n","import { __assign, __spreadArrays } from \"tslib\";\nimport { IntlMessageFormat } from 'intl-messageformat';\nimport * as memoize from 'fast-memoize';\nimport { UnsupportedFormatterError } from './error';\nexport function filterProps(props, whitelist, defaults) {\n    if (defaults === void 0) { defaults = {}; }\n    return whitelist.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    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    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                has: function (key) {\n                    return key in store;\n                },\n                get: function (key) {\n                    return store[key];\n                },\n                set: function (key, value) {\n                    store[key] = value;\n                },\n            };\n        },\n    };\n}\n// @ts-ignore this is to deal with rollup's default import shenanigans\nvar _memoizeIntl = memoize.default || memoize;\nvar memoizeIntl = _memoizeIntl;\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 = memoizeIntl(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, __spreadArrays([void 0], args)))();\n    }, {\n        cache: createFastMemoizeCache(cache.dateTime),\n        strategy: memoizeIntl.strategies.variadic,\n    });\n    var getNumberFormat = memoizeIntl(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, __spreadArrays([void 0], args)))();\n    }, {\n        cache: createFastMemoizeCache(cache.number),\n        strategy: memoizeIntl.strategies.variadic,\n    });\n    var getPluralRules = memoizeIntl(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, __spreadArrays([void 0], args)))();\n    }, {\n        cache: createFastMemoizeCache(cache.pluralRules),\n        strategy: memoizeIntl.strategies.variadic,\n    });\n    return {\n        getDateTimeFormat: getDateTimeFormat,\n        getNumberFormat: getNumberFormat,\n        getMessageFormat: memoizeIntl(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: memoizeIntl.strategies.variadic,\n        }),\n        getRelativeTimeFormat: memoizeIntl(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, __spreadArrays([void 0], args)))();\n        }, {\n            cache: createFastMemoizeCache(cache.relativeTime),\n            strategy: memoizeIntl.strategies.variadic,\n        }),\n        getPluralRules: getPluralRules,\n        getListFormat: memoizeIntl(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, __spreadArrays([void 0], args)))();\n        }, {\n            cache: createFastMemoizeCache(cache.list),\n            strategy: memoizeIntl.strategies.variadic,\n        }),\n        getDisplayNames: memoizeIntl(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, __spreadArrays([void 0], args)))();\n        }, {\n            cache: createFastMemoizeCache(cache.displayNames),\n            strategy: memoizeIntl.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 \" + type + \" format named: \" + name));\n}\n","import { __assign } from \"tslib\";\nimport * as React from 'react';\nimport { invariant } from '@formatjs/ecma402-abstract';\nimport { DEFAULT_INTL_CONFIG as CORE_DEFAULT_INTL_CONFIG } from '@formatjs/intl';\nexport function invariantIntlContext(intl) {\n    invariant(intl, '[React Intl] Could not find required `intl` object. ' +\n        '<IntlProvider> needs to exist in the component ancestry.');\n}\nexport var DEFAULT_INTL_CONFIG = __assign(__assign({}, CORE_DEFAULT_INTL_CONFIG), { textComponent: React.Fragment });\n/**\n * Takes a `formatXMLElementFn`, and composes it in function, which passes\n * argument `parts` through, assigning unique key to each part, to prevent\n * \"Each child in a list should have a unique \"key\"\" React error.\n * @param formatXMLElementFn\n */\nexport function assignUniqueKeysToParts(formatXMLElementFn) {\n    return function (parts) {\n        // eslint-disable-next-line prefer-rest-params\n        return formatXMLElementFn(React.Children.toArray(parts));\n    };\n}\n","import { __assign } from \"tslib\";\nimport { invariant } from '@formatjs/ecma402-abstract';\nimport { IntlMessageFormat, } from 'intl-messageformat';\nimport { MissingTranslationError, MessageFormatError } from './error';\nimport { TYPE } from 'intl-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, 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.');\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 (!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: \\\"\" + 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: \\\"\" + id + \"\\\", using \" + (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: \\\"\" + 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","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];\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 { getNamedFormat, filterProps } from './utils';\nimport { FormatError } from 'intl-messageformat';\nimport { MessageFormatError } 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\", \"MISSING_INTL_API\" /* MISSING_INTL_API */));\n    }\n    try {\n        return getFormatter(config, getRelativeTimeFormat, options).format(value, unit);\n    }\n    catch (e) {\n        config.onError(new MessageFormatError('Error formatting relative time.', e));\n    }\n    return String(value);\n}\n","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    'fractionalSecondDigits',\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","import { filterProps } from './utils';\nimport { MessageFormatError } from './error';\nimport { 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\", \"MISSING_INTL_API\" /* 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 MessageFormatError('Error formatting plural.', e));\n    }\n    return 'other';\n}\n","import { filterProps } from './utils';\nimport { FormatError } 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 now + \"_\" + i + \"_\" + now;\n}\nexport function formatList(_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\", \"MISSING_INTL_API\" /* 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        if (!Object.keys(richValues_1).length) {\n            return getListFormat(locale, filteredOptions).format(serializedValues);\n        }\n        var parts = getListFormat(locale, filteredOptions).formatToParts(serializedValues);\n        return parts.reduce(function (all, el) {\n            var val = el.value;\n            if (richValues_1[val]) {\n                all.push(richValues_1[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    }\n    catch (e) {\n        onError(new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting list.', e));\n    }\n    // @ts-ignore\n    return values;\n}\n","import { filterProps } from './utils';\nimport { FormatError } 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\", \"MISSING_INTL_API\" /* 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 { __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 } from './list';\nimport { formatDisplayName } from './displayName';\nfunction messagesContainString(messages) {\n    var firstMessage = messages\n        ? messages[Object.keys(messages)[0]]\n        : 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 \\\"\" + 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: \\\"\" + locale + \"\\\" in Intl.NumberFormat. Using default locale: \\\"\" + 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: \\\"\" + locale + \"\\\" in Intl.DateTimeFormat. Using default locale: \\\"\" + 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), formatList: formatList.bind(null, resolvedConfig, formatters.getListFormat), formatDisplayName: formatDisplayName.bind(null, resolvedConfig, formatters.getDisplayNames) });\n}\n","/*\n * Copyright 2015, Yahoo Inc.\n * Copyrights licensed under the New BSD License.\n * See the accompanying LICENSE file for terms.\n */\nimport { __assign, __extends, __rest, __spreadArrays } from \"tslib\";\nimport * as React from 'react';\nimport { Provider } from './injectIntl';\nimport { DEFAULT_INTL_CONFIG, invariantIntlContext, assignUniqueKeysToParts, } from '../utils';\nimport { formatMessage as coreFormatMessage, createIntl as coreCreateIntl, createIntlCache, } from '@formatjs/intl';\nimport * as shallowEquals_ from 'shallow-equal/objects';\nimport { isFormatXMLElementFn, } from 'intl-messageformat';\nvar shallowEquals = shallowEquals_.default || shallowEquals_;\nfunction processIntlConfig(config) {\n    return {\n        locale: config.locale,\n        timeZone: config.timeZone,\n        formats: config.formats,\n        textComponent: config.textComponent,\n        messages: config.messages,\n        defaultLocale: config.defaultLocale,\n        defaultFormats: config.defaultFormats,\n        onError: config.onError,\n        wrapRichTextChunksInFragment: config.wrapRichTextChunksInFragment,\n        defaultRichTextElements: config.defaultRichTextElements,\n    };\n}\nfunction assignUniqueKeysToFormatXMLElementFnArgument(values) {\n    if (!values) {\n        return values;\n    }\n    return Object.keys(values).reduce(function (acc, k) {\n        var v = values[k];\n        acc[k] = isFormatXMLElementFn(v)\n            ? assignUniqueKeysToParts(v)\n            : v;\n        return acc;\n    }, {});\n}\nvar formatMessage = function (config, formatters, descriptor, rawValues) {\n    var rest = [];\n    for (var _i = 4; _i < arguments.length; _i++) {\n        rest[_i - 4] = arguments[_i];\n    }\n    var values = assignUniqueKeysToFormatXMLElementFnArgument(rawValues);\n    var chunks = coreFormatMessage.apply(void 0, __spreadArrays([config,\n        formatters,\n        descriptor, values], rest));\n    if (Array.isArray(chunks)) {\n        return React.Children.toArray(chunks);\n    }\n    return chunks;\n};\n/**\n * Create intl object\n * @param config intl config\n * @param cache cache for formatter instances to prevent memory leak\n */\nexport var createIntl = function (_a, cache) {\n    var rawDefaultRichTextElements = _a.defaultRichTextElements, config = __rest(_a, [\"defaultRichTextElements\"]);\n    var defaultRichTextElements = assignUniqueKeysToFormatXMLElementFnArgument(rawDefaultRichTextElements);\n    var coreIntl = coreCreateIntl(__assign(__assign(__assign({}, DEFAULT_INTL_CONFIG), config), { defaultRichTextElements: defaultRichTextElements }), cache);\n    return __assign(__assign({}, coreIntl), { formatMessage: formatMessage.bind(null, {\n            locale: coreIntl.locale,\n            timeZone: coreIntl.timeZone,\n            formats: coreIntl.formats,\n            defaultLocale: coreIntl.defaultLocale,\n            defaultFormats: coreIntl.defaultFormats,\n            messages: coreIntl.messages,\n            onError: coreIntl.onError,\n            defaultRichTextElements: defaultRichTextElements,\n        }, coreIntl.formatters) });\n};\nvar IntlProvider = /** @class */ (function (_super) {\n    __extends(IntlProvider, _super);\n    function IntlProvider() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.cache = createIntlCache();\n        _this.state = {\n            cache: _this.cache,\n            intl: createIntl(processIntlConfig(_this.props), _this.cache),\n            prevConfig: processIntlConfig(_this.props),\n        };\n        return _this;\n    }\n    IntlProvider.getDerivedStateFromProps = function (props, _a) {\n        var prevConfig = _a.prevConfig, cache = _a.cache;\n        var config = processIntlConfig(props);\n        if (!shallowEquals(prevConfig, config)) {\n            return {\n                intl: createIntl(config, cache),\n                prevConfig: config,\n            };\n        }\n        return null;\n    };\n    IntlProvider.prototype.render = function () {\n        invariantIntlContext(this.state.intl);\n        return React.createElement(Provider, { value: this.state.intl }, this.props.children);\n    };\n    IntlProvider.displayName = 'IntlProvider';\n    IntlProvider.defaultProps = DEFAULT_INTL_CONFIG;\n    return IntlProvider;\n}(React.PureComponent));\nexport default IntlProvider;\n","import { __rest } from \"tslib\";\nimport * as React from 'react';\nimport { invariantIntlContext } from '../utils';\nimport { Context } from './injectIntl';\nvar DisplayName;\n(function (DisplayName) {\n    DisplayName[\"formatDate\"] = \"FormattedDate\";\n    DisplayName[\"formatTime\"] = \"FormattedTime\";\n    DisplayName[\"formatNumber\"] = \"FormattedNumber\";\n    DisplayName[\"formatList\"] = \"FormattedList\";\n    // Note that this DisplayName is the locale display name, not to be confused with\n    // the name of the enum, which is for React component display name in dev tools.\n    DisplayName[\"formatDisplayName\"] = \"FormattedDisplayName\";\n})(DisplayName || (DisplayName = {}));\nvar DisplayNameParts;\n(function (DisplayNameParts) {\n    DisplayNameParts[\"formatDate\"] = \"FormattedDateParts\";\n    DisplayNameParts[\"formatTime\"] = \"FormattedTimeParts\";\n    DisplayNameParts[\"formatNumber\"] = \"FormattedNumberParts\";\n    DisplayNameParts[\"formatList\"] = \"FormattedListParts\";\n})(DisplayNameParts || (DisplayNameParts = {}));\nexport var FormattedNumberParts = function (props) { return (React.createElement(Context.Consumer, null, function (intl) {\n    invariantIntlContext(intl);\n    var value = props.value, children = props.children, formatProps = __rest(props, [\"value\", \"children\"]);\n    return children(intl.formatNumberToParts(value, formatProps));\n})); };\nFormattedNumberParts.displayName = 'FormattedNumberParts';\nexport function createFormattedDateTimePartsComponent(name) {\n    var ComponentParts = function (props) { return (React.createElement(Context.Consumer, null, function (intl) {\n        invariantIntlContext(intl);\n        var value = props.value, children = props.children, formatProps = __rest(props, [\"value\", \"children\"]);\n        var date = typeof value === 'string' ? new Date(value || 0) : value;\n        var formattedParts = name === 'formatDate'\n            ? intl.formatDateToParts(date, formatProps)\n            : intl.formatTimeToParts(date, formatProps);\n        return children(formattedParts);\n    })); };\n    ComponentParts.displayName = DisplayNameParts[name];\n    return ComponentParts;\n}\nexport function createFormattedComponent(name) {\n    var Component = function (props) { return (React.createElement(Context.Consumer, null, function (intl) {\n        invariantIntlContext(intl);\n        var value = props.value, children = props.children, formatProps = __rest(props, [\"value\", \"children\"]);\n        // TODO: fix TS type definition for localeMatcher upstream\n        var formattedValue = intl[name](value, formatProps);\n        if (typeof children === 'function') {\n            return children(formattedValue);\n        }\n        var Text = intl.textComponent || React.Fragment;\n        return React.createElement(Text, null, formattedValue);\n    })); };\n    Component.displayName = DisplayName[name];\n    return Component;\n}\n","import { createFormattedComponent, createFormattedDateTimePartsComponent, } from './src/components/createFormattedComponent';\nexport { createIntlCache, UnsupportedFormatterError, InvalidConfigError, MissingDataError, MessageFormatError, MissingTranslationError, IntlErrorCode as ReactIntlErrorCode, IntlError as ReactIntlError, } from '@formatjs/intl';\nexport function defineMessages(msgs) {\n    return msgs;\n}\nexport function defineMessage(msg) {\n    return msg;\n}\nexport { default as injectIntl, Provider as RawIntlProvider, Context as IntlContext, } from './src/components/injectIntl';\nexport { default as useIntl } from './src/components/useIntl';\nexport { default as IntlProvider, createIntl } from './src/components/provider';\n// IMPORTANT: Explicit here to prevent api-extractor from outputing `import('./src/types').CustomFormatConfig`\nexport var FormattedDate = createFormattedComponent('formatDate');\nexport var FormattedTime = createFormattedComponent('formatTime');\nexport var FormattedNumber = createFormattedComponent('formatNumber');\nexport var FormattedList = createFormattedComponent('formatList');\nexport var FormattedDisplayName = createFormattedComponent('formatDisplayName');\nexport var FormattedDateParts = createFormattedDateTimePartsComponent('formatDate');\nexport var FormattedTimeParts = createFormattedDateTimePartsComponent('formatTime');\nexport { FormattedNumberParts } from './src/components/createFormattedComponent';\nexport { default as FormattedRelativeTime } from './src/components/relative';\nexport { default as FormattedPlural } from './src/components/plural';\nexport { default as FormattedMessage } from './src/components/message';\nexport { default as FormattedDateTimeRange } from './src/components/dateTimeRange';\n","import { IntlShape, defineMessages, MessageDescriptor } from 'react-intl';\n\nconst messages = defineMessages({\n  failedFetch: {\n    id: 'errors.failed-fetch',\n    defaultMessage: 'Failed to fetch. Please check your internet connection or try again a bit later',\n    description: {\n      code: -2,\n    },\n  },\n  0: {\n    id: 'errors.0',\n    defaultMessage: 'Something went wrong. Please try again a bit later.',\n    description: {\n      code: 0,\n    },\n  },\n  1: {\n    id: 'errors.1',\n    defaultMessage: 'Comment cannot be found. Please refresh the page and try again.',\n    description: {\n      code: 1,\n    },\n  },\n  2: {\n    id: 'errors.2',\n    defaultMessage: 'Failed to unmarshal incoming request.',\n    description: {\n      code: 2,\n    },\n  },\n  3: {\n    id: 'errors.3',\n    defaultMessage: `You don't have permission for this operation.`,\n    description: {\n      code: 3,\n    },\n  },\n  4: {\n    id: 'errors.4',\n    defaultMessage: `Invalid comment data.`,\n    description: {\n      code: 4,\n    },\n  },\n  5: {\n    id: 'errors.5',\n    defaultMessage: `Comment cannot be found.  Please refresh the page and try again.`,\n    description: {\n      code: 5,\n    },\n  },\n  6: {\n    id: 'errors.6',\n    defaultMessage: `Site cannot be found.  Please refresh the page and try again.`,\n    description: {\n      code: 6,\n    },\n  },\n  7: {\n    id: 'errors.7',\n    defaultMessage: `User has been blocked.`,\n    description: {\n      code: 7,\n    },\n  },\n  8: {\n    id: 'errors.8',\n    defaultMessage: `User has been blocked.`,\n    description: {\n      code: 8,\n    },\n  },\n  9: {\n    id: 'errors.9',\n    defaultMessage: `Comment changing failed. Please try again a bit later.`,\n    description: {\n      code: 9,\n    },\n  },\n  10: {\n    id: 'errors.10',\n    defaultMessage: `It is too late to edit the comment.`,\n    description: {\n      code: 10,\n    },\n  },\n  11: {\n    id: 'errors.11',\n    defaultMessage: `Comment already has reply, editing is not possible.`,\n    description: {\n      code: 11,\n    },\n  },\n  12: {\n    id: 'errors.12',\n    defaultMessage: `Cannot save voting result. Please try again a bit later.`,\n    description: {\n      code: 12,\n    },\n  },\n  13: {\n    id: 'errors.13',\n    defaultMessage: `You cannot vote for your own comment.`,\n    description: {\n      code: 13,\n    },\n  },\n  14: {\n    id: 'errors.14',\n    defaultMessage: `You have already voted for the comment.`,\n    description: {\n      code: 14,\n    },\n  },\n  15: {\n    id: 'errors.15',\n    defaultMessage: `Too many votes for the comment.`,\n    description: {\n      code: 15,\n    },\n  },\n  16: {\n    id: 'errors.16',\n    defaultMessage: `Min score reached for the comment.`,\n    description: {\n      code: 16,\n    },\n  },\n  17: {\n    id: 'errors.17',\n    defaultMessage: `Action rejected. Please try again a bit later.`,\n    description: {\n      code: 17,\n    },\n  },\n  18: {\n    id: 'errors.18',\n    defaultMessage: `Requested file cannot be found.`,\n    description: {\n      code: 18,\n    },\n  },\n});\n\n/**\n * map of codes that server returns in its response in case of error\n * to client readable version\n */\nconst errorMessageForCodes = new Map<number, MessageDescriptor>();\n\nObject.entries(messages).forEach(([, messageDescriptor]) => {\n  errorMessageForCodes.set(messageDescriptor.description.code, messageDescriptor);\n});\n\nexport const httpMessages = defineMessages({\n  notAuthorized: {\n    id: 'errors.not-authorized',\n    defaultMessage: 'Not authorized.',\n  },\n  forbidden: {\n    id: 'errors.forbidden',\n    defaultMessage: 'Forbidden.',\n  },\n  toManyRequest: {\n    id: 'errors.to-many-request',\n    defaultMessage: 'You have reached maximum request limit.',\n  },\n  unexpectedError: {\n    id: 'errors.unexpected-error',\n    defaultMessage: 'Something went wrong.',\n  },\n});\n\n/**\n * map of http rest codes to ui label, used by fetcher to generate error with `-1` code\n */\nexport const httpErrorMap = new Map([\n  [401, httpMessages.notAuthorized],\n  [403, httpMessages.forbidden],\n  [429, httpMessages.toManyRequest],\n]);\n\nexport type FetcherError =\n  | string\n  | {\n      /**\n       * Error code, that is part of server error response.\n       *\n       * Note that -1 is reserved for error where `error` field shall be used directly\n       */\n      code?: number;\n      details?: string;\n      error: string;\n    };\n\nexport function extractErrorMessageFromResponse(response: FetcherError, intl: IntlShape): string {\n  const defaultErrorMessage = intl.formatMessage(errorMessageForCodes.get(0) || messages['0']);\n  if (!response) {\n    return defaultErrorMessage;\n  }\n\n  if (typeof response === 'string') {\n    return response;\n  }\n\n  if (\n    typeof response.code === 'number' &&\n    (errorMessageForCodes.has(response.code) || httpErrorMap.has(response.code))\n  ) {\n    const messageDescriptor =\n      errorMessageForCodes.get(response.code) || httpErrorMap.get(response.code) || messages['0'];\n    return intl.formatMessage(messageDescriptor);\n  }\n\n  return defaultErrorMessage;\n}\n\nexport class RequestError extends Error {\n  code: number;\n  error: string;\n\n  constructor(message: string, code: number) {\n    super(message);\n\n    this.code = code;\n    this.error = message;\n  }\n}\n","export const BASE_URL = window.remark_config.host || process.env.REMARK_URL!;\nexport const NODE_ID = process.env.REMARK_NODE!;\nexport const API_BASE = '/api/v1';\nexport const COMMENT_NODE_CLASSNAME_PREFIX = 'remark42__comment-';\nexport const COUNTER_NODE_CLASSNAME = 'remark42__counter';\n","import { Sorting, Theme } from './types';\n\nexport { BASE_URL, API_BASE, NODE_ID, COMMENT_NODE_CLASSNAME_PREFIX } from './constants.config';\nexport const LAST_COMMENTS_NODE_CLASSNAME = 'remark42__last-comments';\nexport const MAX_SHOWN_ROOT_COMMENTS = 10;\n\nexport const DEFAULT_SORT: Sorting = '-active';\n\n/** locastorage key for collapsed comments */\nexport const LS_COLLAPSE_KEY = '__remarkCollapsed';\n\n/** locastorage key for comment form value */\nexport const LS_SAVED_COMMENT_VALUE = '__remark_comment_value';\n\n/** locastorage key for hidden users */\nexport const LS_HIDDEN_USERS_KEY = '__remarkHiddenUsers';\n\n/** localstorage key under which sort preference resides */\nexport const LS_SORT_KEY = '__remarkSort';\n\n/** localstorage key for email of logged in user */\nexport const LS_EMAIL_KEY = '__remarkEmail';\n\nexport const THEMES: Theme[] = ['light', 'dark'];\nexport const IS_MOBILE = /Android|webOS|iPhone|iPad|iPod|Opera Mini|Windows Phone/i.test(navigator.userAgent);\n\n/**\n * Defines if browser storage features (cookies, localsrotage)\n * are available or blocked via browser preferences\n */\nexport const IS_STORAGE_AVAILABLE: boolean = (() => {\n  try {\n    localStorage.setItem('localstorage_availability_test', '');\n    localStorage.removeItem('localstorage_availability_test');\n  } catch (e) {\n    return false;\n  }\n  return true;\n})();\n\n/**\n * Defines whether iframe loaded in cross origin environment\n * Usefull for checking if some privacy restriction may be applied\n */\nexport const IS_THIRD_PARTY: boolean = (() => {\n  try {\n    return window.parent.location.host !== window.location.host;\n  } catch (e) {\n    return true;\n  }\n})();\n","import parseQuery from 'utils/parseQuery';\n\nimport type { Theme } from './types';\nimport { THEMES, MAX_SHOWN_ROOT_COMMENTS } from './constants';\n\nexport interface QuerySettingsType {\n  site_id?: string;\n  page_title?: string;\n  url?: string;\n  max_shown_comments?: number;\n  theme: Theme;\n  /* used in delete users data page */\n  token?: string;\n  show_email_subscription?: boolean;\n}\n\nexport const querySettings: Partial<QuerySettingsType> = parseQuery();\n\nif (querySettings.max_shown_comments) {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  querySettings.max_shown_comments = parseInt((querySettings.max_shown_comments as any) as string, 10);\n} else {\n  querySettings.max_shown_comments = MAX_SHOWN_ROOT_COMMENTS;\n}\n\nif (!querySettings.theme || THEMES.indexOf(querySettings.theme) === -1) {\n  querySettings.theme = THEMES[0];\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nquerySettings.show_email_subscription = (querySettings.show_email_subscription as any) !== 'false';\n\nexport const siteId = querySettings.site_id!;\nexport const pageTitle = querySettings.page_title;\nexport const url = querySettings.url;\nexport const maxShownComments = querySettings.max_shown_comments;\nexport const token = querySettings.token!;\nexport const theme = querySettings.theme;\n","/** converts widnow.location.search into object */\n\nexport default function parseQuery<T extends {}>(search: string = window.location.search): T {\n  const params: { [key: string]: string } = {};\n  new URLSearchParams(search).forEach((value: string, key: string) => {\n    params[key] = value;\n  });\n  return params as T;\n}\n","import { Config } from './types';\nimport { QuerySettingsType, querySettings } from './settings';\n\ninterface StaticStoreType {\n  config: Config;\n  query: QuerySettingsType;\n  /** used in fetcher, fer example to set comment edit temiout */\n  serverClientTimeDiff?: number;\n}\n\n/**\n * Represent store of values that and will not change, or doesn't need reactivity\n *\n * Initialized once at webpack's entry points (i.e remark.tsx)\n */\nexport const StaticStore: StaticStoreType = {\n  config: {\n    version: '',\n    edit_duration: 5000,\n    max_comment_size: 5000,\n    admins: [],\n    admin_email: '',\n    auth_providers: [],\n    critical_score: 0,\n    low_score: 0,\n    positive_score: false,\n    readonly_age: 0,\n    max_image_size: 0,\n    simple_view: false,\n    anon_vote: false,\n    email_notifications: false,\n    emoji_enabled: false,\n  },\n  query: querySettings as QuerySettingsType,\n};\n","import { httpErrorMap, httpMessages, RequestError } from 'utils/errorUtils';\n\nimport { siteId } from './settings';\nimport { getCookie } from './cookies';\nimport { StaticStore } from './static-store';\nimport { BASE_URL, API_BASE } from './constants';\n\n/** Header name for JWT token */\nexport const JWT_HEADER = 'X-JWT';\n/** Header name for XSRF token */\nexport const XSRF_HEADER = 'X-XSRF-TOKEN';\n/** Cookie field with XSRF token */\nexport const XSRF_COOKIE = 'XSRF-TOKEN';\n\ntype QueryParams = Record<string, string | number | undefined>;\ntype Payload = BodyInit | Record<string, unknown> | null;\ntype BodylessMethod = <T>(url: string, query?: QueryParams) => Promise<T>;\ntype BodyMethod = <T>(url: string, query?: QueryParams, body?: Payload) => Promise<T>;\ntype Methods = {\n  get: BodylessMethod;\n  put: BodyMethod;\n  post: BodyMethod;\n  delete: BodylessMethod;\n};\n\n/** JWT token received from server and will be send by each request, if it present */\nlet activeJwtToken: string | undefined;\n\nconst createFetcher = (baseUrl: string = ''): Methods => {\n  /**\n   * Fetcher is abstraction on top of fetch\n   *\n   * @method - a string to set http method\n   * @uri – uri to API endpoint\n   * @query - collection of query params. They will be concatenated to URL. `siteId` will be added automatically.\n   * @body - data for sending to the server. If you pass object it will be stringified. If you pass form data it will be sent as is. Content type headers will be added automatically.\n   */\n  const request = async (method: string, uri: string, query: QueryParams = {}, body?: Payload) => {\n    const queryString = new URLSearchParams({ site: siteId, ...query });\n    const url = `${baseUrl}${uri}?${queryString}`;\n    const headers: Record<string, string> = {};\n    const params: RequestInit = { method };\n\n    // Save token in memory and pass it into headers in case if storing cookies is disabled\n    if (activeJwtToken) {\n      headers[JWT_HEADER] = activeJwtToken;\n    }\n    headers[XSRF_HEADER] = getCookie(XSRF_COOKIE) || '';\n\n    if (body instanceof FormData) {\n      // Shouldn't add any kind of `Content-Type` if we send `FormData`\n      // Now FormData is sent only in case of uploading file\n      params.body = body;\n    } else if (typeof body === 'object' && body !== null) {\n      headers['Content-Type'] = 'application/json';\n      params.body = JSON.stringify(body);\n    } else {\n      params.body = body;\n    }\n\n    try {\n      const res = await fetch(url, { ...params, headers });\n      // TODO: it should be clarified when frontend gets this header and what could be in it to simplify this logic and cover by tests\n      const date = (res.headers.has('date') && res.headers.get('date')) || '';\n      const timestamp = isNaN(Date.parse(date)) ? 0 : Date.parse(date);\n      const timeDiff = (new Date().getTime() - timestamp) / 1000;\n\n      StaticStore.serverClientTimeDiff = timeDiff;\n\n      // backend could update jwt in any time. so, we should handle it\n      if (res.headers.has(JWT_HEADER)) {\n        activeJwtToken = res.headers.get(JWT_HEADER) as string;\n      }\n\n      if ([401, 403].includes(res.status)) {\n        activeJwtToken = undefined;\n      }\n\n      if (res.status >= 400) {\n        if (httpErrorMap.has(res.status)) {\n          const descriptor = httpErrorMap.get(res.status) || httpMessages.unexpectedError;\n\n          throw new RequestError(descriptor.defaultMessage, res.status);\n        }\n\n        return res.text().then((text) => {\n          let err;\n          try {\n            err = JSON.parse(text);\n          } catch (e) {\n            throw new RequestError(httpMessages.unexpectedError.defaultMessage, 0);\n          }\n          throw err;\n        });\n      }\n\n      if (res.headers.get('Content-Type')?.indexOf('application/json') === 0) {\n        return res.json();\n      }\n\n      return res.text();\n    } catch (e) {\n      if (e?.message === 'Failed to fetch') {\n        throw new RequestError(e.message, -2);\n      }\n\n      throw e;\n    }\n  };\n\n  return {\n    get: (uri: string, query: QueryParams, body: Payload) => request('get', uri, query, body),\n    put: (uri: string, query: QueryParams, body: Payload) => request('put', uri, query, body),\n    post: (uri: string, query: QueryParams, body: Payload) => request('post', uri, query, body),\n    delete: (uri: string, query: QueryParams, body: Payload) => request('delete', uri, query, body),\n  } as Methods;\n};\n\nexport const apiFetcher = createFetcher(`${BASE_URL}${API_BASE}`);\nexport const authFetcher = createFetcher(`${BASE_URL}/auth`);\nexport const adminFetcher = createFetcher(`${BASE_URL}${API_BASE}/admin`);\n","interface CookieOptions {\n  /**\n   * Either time in seconds,\n   * RFC-1123 formatted date string,\n   * or Date object\n   */\n  expires?: number | string | Date;\n  path?: string;\n  domain?: string;\n  secure?: boolean;\n}\n\nexport function setCookie(name: string, value: string, options: CookieOptions = {}) {\n  if (options.expires) {\n    if (typeof options.expires === 'number') {\n      const d = new Date();\n      d.setTime(d.getTime() + options.expires * 1000);\n      options.expires = d;\n      options.expires = options.expires.toUTCString();\n    } else if (options.expires instanceof Date) {\n      options.expires = options.expires.toUTCString();\n    }\n  }\n\n  value = encodeURIComponent(value);\n\n  let updatedCookie = `${name}=${value}`;\n\n  for (const [key, value] of Object.entries(options)) {\n    updatedCookie += `; ${key}`;\n    if (value !== true) {\n      updatedCookie += `=${value}`;\n    }\n  }\n\n  document.cookie = updatedCookie;\n}\n\nexport function getCookie(name: string) {\n  const matches = document.cookie.match(\n    new RegExp(`(?:^|; )${name.replace(/([.$?*|{}()[\\]\\\\/+^])/g, '\\\\$1')}=([^;]*)`)\n  );\n\n  return matches ? decodeURIComponent(matches[1]) : undefined;\n}\n\nexport function deleteCookie(name: string) {\n  setCookie(name, '', { expires: -1 });\n}\n","import { Comment } from './types';\nimport { apiFetcher } from './fetcher';\n\nexport default function getLastComments(siteId: string, max: number): Promise<Comment[]> {\n  return apiFetcher.get(`/last/${max}`, { site: siteId });\n}\n","/** this is generated file by \"npm run translation:generate\" **/\n// it is ok that is empty. Default messages from code will be used.\nconst enMessages = {};\n\nexport async function loadLocale(locale: string): Promise<Record<string, string>> {\n  if (locale === 'ru') {\n    return import(/* webpackChunkName: \"ru\" */ '../locales/ru.json').then((res) => res.default).catch(() => enMessages);\n  }\n  if (locale === 'de') {\n    return import(/* webpackChunkName: \"de\" */ '../locales/de.json').then((res) => res.default).catch(() => enMessages);\n  }\n  if (locale === 'fi') {\n    return import(/* webpackChunkName: \"fi\" */ '../locales/fi.json').then((res) => res.default).catch(() => enMessages);\n  }\n  if (locale === 'es') {\n    return import(/* webpackChunkName: \"es\" */ '../locales/es.json').then((res) => res.default).catch(() => enMessages);\n  }\n  if (locale === 'zh') {\n    return import(/* webpackChunkName: \"zh\" */ '../locales/zh.json').then((res) => res.default).catch(() => enMessages);\n  }\n  if (locale === 'tr') {\n    return import(/* webpackChunkName: \"tr\" */ '../locales/tr.json').then((res) => res.default).catch(() => enMessages);\n  }\n  if (locale === 'bg') {\n    return import(/* webpackChunkName: \"bg\" */ '../locales/bg.json').then((res) => res.default).catch(() => enMessages);\n  }\n  if (locale === 'ua') {\n    return import(/* webpackChunkName: \"ua\" */ '../locales/ua.json').then((res) => res.default).catch(() => enMessages);\n  }\n  if (locale === 'pl') {\n    return import(/* webpackChunkName: \"pl\" */ '../locales/pl.json').then((res) => res.default).catch(() => enMessages);\n  }\n  if (locale === 'vi') {\n    return import(/* webpackChunkName: \"vi\" */ '../locales/vi.json').then((res) => res.default).catch(() => enMessages);\n  }\n  if (locale === 'be') {\n    return import(/* webpackChunkName: \"be\" */ '../locales/be.json').then((res) => res.default).catch(() => enMessages);\n  }\n  if (locale === 'fr') {\n    return import(/* webpackChunkName: \"fr\" */ '../locales/fr.json').then((res) => res.default).catch(() => enMessages);\n  }\n  if (locale === 'ja') {\n    return import(/* webpackChunkName: \"ja\" */ '../locales/ja.json').then((res) => res.default).catch(() => enMessages);\n  }\n  if (locale === 'ko') {\n    return import(/* webpackChunkName: \"ko\" */ '../locales/ko.json').then((res) => res.default).catch(() => enMessages);\n  }\n  if (locale === 'bp') {\n    return import(/* webpackChunkName: \"bp\" */ '../locales/bp.json').then((res) => res.default).catch(() => enMessages);\n  }\n\n  return enMessages;\n}\n","import * as React from 'react';\nimport { Context } from './injectIntl';\nimport { invariantIntlContext } from '../utils';\nexport default function useIntl() {\n    var intl = React.useContext(Context);\n    invariantIntlContext(intl);\n    return intl;\n}\n","const handleBtnKeyPress = (event: KeyboardEvent, handler?: (e: KeyboardEvent | MouseEvent) => void) => {\n  if (event.key === ' ' || event.key === 'Enter') {\n    event.preventDefault();\n    handler && handler(event);\n  }\n};\n\nexport const getHandleClickProps = (handler?: (e: KeyboardEvent | MouseEvent) => void) => ({\n  role: 'button',\n  onClick: handler,\n  onKeyPress: (event: KeyboardEvent) => handleBtnKeyPress(event, handler),\n  ...(handler ? { tabIndex: 0 } : {}),\n});\n","export interface User {\n  name: string;\n  id: string;\n  picture: string;\n  ip: string;\n  admin: boolean;\n  block: boolean;\n  verified: boolean;\n  email_subscription?: boolean;\n}\n\n/** data which is used on user-info page */\nexport interface UserInfo {\n  id: User['id'];\n  name: string | '';\n  isDefaultPicture: boolean;\n  picture: string;\n}\n\nexport interface BlockedUser {\n  id: string;\n  name: string;\n  time: string;\n}\n\nexport interface Locator {\n  /** site id */\n  site: string;\n  /** post url */\n  url: string;\n}\n\nexport interface Comment {\n  /** comment ID, read only */\n  id: string;\n  /** parent ID */\n  pid: string;\n  /** comment text, after md processing */\n  text: string;\n  /** original comment text */\n  orig?: string;\n  /** user info, read only */\n  user: User;\n  /** post locator */\n  locator: Locator;\n  /** comment score, read only */\n  score: number;\n  voted_ips: { Timestamp: string; Value: boolean }[];\n  /**\n   * vote delta,\n   * if user hasn't voted delta will be 0,\n   * -1/+1 for downvote/upvote\n   */\n  vote: number;\n  /** comment controversy, read only */\n  controversy?: number;\n  /** pointer to have empty default in json response */\n  edit?: {\n    time: string;\n    summary: string;\n  };\n  /** time stamp, read only */\n  time: string;\n  /** pinned status, read only */\n  pin?: boolean;\n  /** delete status, read only */\n  delete?: boolean;\n  /** post title */\n  title?: string;\n  /**\n   * @ClientOnly defines whether comments was hidden (deleted)\n   *\n   * Situatuon may occure for example if user decided to hide someone,\n   * in this case we don't use `delete` field because comment with `delete`\n   * still renders, and comment with `hidden` flag completely removed from DOM\n   */\n  hidden?: boolean;\n}\n\nexport interface CommentsResponse {\n  comments: Comment[];\n  count: number;\n}\n\nexport interface Node {\n  comment: Comment;\n  replies?: Node[];\n}\n\nexport interface PostInfo {\n  url: string;\n  count: number;\n  read_only?: boolean;\n  first_time?: string;\n  last_time?: string;\n}\n\nexport interface Tree {\n  comments: Node[];\n  info: PostInfo;\n}\n\nexport type OAuthProvider = 'facebook' | 'twitter' | 'google' | 'yandex' | 'github' | 'microsoft' | 'dev';\nexport type FormProvider = 'email' | 'anonymous';\nexport type Provider = OAuthProvider | FormProvider;\n\nexport interface Config {\n  version: string;\n  auth_providers: Provider[];\n  edit_duration: number;\n  max_comment_size: number;\n  admins: string[];\n  admin_email: string;\n  low_score: number;\n  critical_score: number;\n  positive_score: boolean;\n  readonly_age: number;\n  max_image_size: number;\n  simple_view: boolean;\n  anon_vote: boolean;\n  email_notifications: boolean;\n  emoji_enabled: boolean;\n}\n\nexport type Sorting = '-time' | '+time' | '-active' | '+active' | '-score' | '+score' | '-controversy' | '+controversy';\n\nexport type BlockTTL = 'permanently' | '43200m' | '10080m' | '1440m';\n\nexport interface BlockingDuration {\n  label: string;\n  value: BlockTTL;\n}\n\nexport type Theme = 'light' | 'dark';\n\n/**\n * Comment component's edit mode:\n * whether it should have reply or edit Input shown\n */\nexport enum CommentMode {\n  None,\n  Reply,\n  Edit,\n}\n\n/**\n * Used as api.uploadImage response type\n */\nexport interface Image {\n  name: string;\n  size: number;\n  /** mime type of an image */\n  type: string;\n  url: string;\n}\n\n/** error struct returned in case of api call error */\nexport interface ApiError {\n  code: number;\n  /** simple explanation */\n  details: string;\n  /** in-depth explanation */\n  error: string;\n}\n","import { h, JSX } from 'preact';\nimport b from 'bem-react-helper';\nimport { Theme } from 'common/types';\n\ntype Props = JSX.HTMLAttributes<HTMLImageElement> & {\n  picture?: string;\n  mix?: string;\n  theme?: Theme;\n};\n\nexport function AvatarIcon({ mix, theme, picture, ...props }: Props) {\n  return (\n    <img\n      className={b('avatar-icon', { mix }, { theme, default: !picture })}\n      src={picture || require('./avatar-icon.svg').default}\n      alt=\"\"\n      {...props}\n    />\n  );\n}\n","import { h, JSX } from 'preact';\nimport { forwardRef } from 'preact/compat';\nimport b, { Mods, Mix } from 'bem-react-helper';\n\nimport type { Theme } from 'common/types';\n\nexport type ButtonProps = Omit<JSX.HTMLAttributes, 'size' | 'className'> & {\n  kind?: 'primary' | 'secondary' | 'link';\n  size?: 'middle' | 'large';\n  theme?: Theme;\n  mods?: Mods;\n  mix?: Mix;\n  type?: string;\n};\n\nexport const Button = forwardRef<HTMLButtonElement, ButtonProps>(\n  ({ children, theme, mods, mix, kind, type = 'button', size, ...props }, ref) => (\n    <button className={b('button', { mods: { kind, size, theme }, mix }, { ...mods })} type={type} {...props} ref={ref}>\n      {children}\n    </button>\n  )\n);\n","import { h, JSX, Component, createRef } from 'preact';\nimport { exclude } from 'utils/exclude';\n\ntype Props = {\n  time: Date;\n  onTimePassed?: () => void;\n} & JSX.HTMLAttributes;\n\ninterface State {\n  /** props.time converted to timestamp */\n  time: number;\n}\n\n/** Component which uses plain DOM mutation instead of rerendering react reactive reactivity */\nexport default class Countdown extends Component<Props, State> {\n  elemRef = createRef<HTMLSpanElement>();\n  intervalID?: number;\n  constructor(props: Props) {\n    super(props);\n    this.state = {\n      time: props.time.getTime(),\n    };\n  }\n  componentDidMount() {\n    this.start();\n  }\n  componentWillReceiveProps(nextProps: Props) {\n    if (nextProps.time === this.props.time) return;\n    this.setState({\n      time: nextProps.time.getTime(),\n    });\n    this.start();\n  }\n  componentWillUnmount() {\n    window.clearInterval(this.intervalID);\n  }\n  shouldComponentUpdate() {\n    return false;\n  }\n  tick() {\n    if (this.elemRef) {\n      const value = Math.max(0, (this.state.time - new Date().getTime()) / 1000).toFixed(0);\n      this.elemRef.current!.innerText = value;\n      if (value === '0') {\n        this.props.onTimePassed && this.props.onTimePassed();\n        window.clearInterval(this.intervalID);\n        this.intervalID = undefined;\n      }\n    }\n  }\n  start() {\n    if (this.intervalID) clearInterval(this.intervalID);\n    this.tick();\n    this.intervalID = window.setInterval(() => {\n      this.tick();\n    }, 1000);\n  }\n  render(props: Props) {\n    return <span {...exclude(props, 'time', 'onTimePassed')} ref={this.elemRef} />;\n  }\n}\n","/** return shallow clone of object without given props */\nexport function exclude<T extends object, K extends keyof T>(o: T, ...exclude: K[]): Pick<T, Exclude<keyof T, K>> {\n  const clone = { ...o };\n  for (const item of exclude) {\n    delete clone[item];\n  }\n  return clone;\n}\n","/*\n * Copyright 2015, Yahoo Inc.\n * Copyrights licensed under the New BSD License.\n * See the accompanying LICENSE file for terms.\n */\nimport { __extends, __rest, __spreadArrays } from \"tslib\";\nimport * as React from 'react';\nimport { Context } from './injectIntl';\nimport { invariantIntlContext } from '../utils';\nimport * as shallowEquals_ from 'shallow-equal/objects';\nvar shallowEquals = shallowEquals_.default || shallowEquals_;\nvar FormattedMessage = /** @class */ (function (_super) {\n    __extends(FormattedMessage, _super);\n    function FormattedMessage() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    FormattedMessage.prototype.shouldComponentUpdate = function (nextProps) {\n        var _a = this.props, values = _a.values, otherProps = __rest(_a, [\"values\"]);\n        var nextValues = nextProps.values, nextOtherProps = __rest(nextProps, [\"values\"]);\n        return (!shallowEquals(nextValues, values) ||\n            !shallowEquals(otherProps, nextOtherProps));\n    };\n    FormattedMessage.prototype.render = function () {\n        var _this = this;\n        return (React.createElement(Context.Consumer, null, function (intl) {\n            invariantIntlContext(intl);\n            var formatMessage = intl.formatMessage, _a = intl.textComponent, Text = _a === void 0 ? React.Fragment : _a;\n            var _b = _this.props, id = _b.id, description = _b.description, defaultMessage = _b.defaultMessage, values = _b.values, children = _b.children, _c = _b.tagName, Component = _c === void 0 ? Text : _c, ignoreTag = _b.ignoreTag;\n            var descriptor = { id: id, description: description, defaultMessage: defaultMessage };\n            var nodes = formatMessage(descriptor, values, {\n                ignoreTag: ignoreTag,\n            });\n            if (!Array.isArray(nodes)) {\n                nodes = [nodes];\n            }\n            if (typeof children === 'function') {\n                return children(nodes);\n            }\n            if (Component) {\n                // Needs to use `createElement()` instead of JSX, otherwise React will\n                // warn about a missing `key` prop with rich-text message formatting.\n                return React.createElement.apply(React, __spreadArrays([Component, null], nodes));\n            }\n            return nodes;\n        }));\n    };\n    FormattedMessage.displayName = 'FormattedMessage';\n    return FormattedMessage;\n}(React.Component));\nexport default FormattedMessage;\n","import { IntlShape, defineMessages } from 'react-intl';\n\nconst voteMessages = defineMessages({\n  ownComment: {\n    id: 'vote.own-comment',\n    defaultMessage: `Can't vote for your own comment`,\n  },\n  guest: {\n    id: 'vote.guest',\n    defaultMessage: 'Sign in to vote',\n  },\n  onlyPostPage: {\n    id: 'vote.only-post-page',\n    defaultMessage: `Voting allowed only on post's page`,\n  },\n  readonly: {\n    id: 'vote.readonly',\n    defaultMessage: `Can't vote on read-only topics`,\n  },\n  deleted: {\n    id: 'vote.deleted',\n    defaultMessage: `Can't vote for deleted comment`,\n  },\n  anonymous: {\n    id: 'vote.anonymous',\n    defaultMessage: `Anonymous users can't vote`,\n  },\n  onlyPositive: {\n    id: 'vote.only-positive',\n    defaultMessage: `Only positive score allowed`,\n  },\n});\n\nexport enum VoteMessagesTypes {\n  OWN_COMMENT,\n  GUEST,\n  ONLY_POST_PAGE,\n  READONLY,\n  DELETED,\n  ANONYMOUS,\n  ONLY_POSITIVE,\n}\n\nexport function getVoteMessage(type: VoteMessagesTypes, intl: IntlShape) {\n  const messages = {\n    [VoteMessagesTypes.OWN_COMMENT]: intl.formatMessage(voteMessages.ownComment),\n    [VoteMessagesTypes.GUEST]: intl.formatMessage(voteMessages.guest),\n    [VoteMessagesTypes.ONLY_POST_PAGE]: intl.formatMessage(voteMessages.onlyPostPage),\n    [VoteMessagesTypes.READONLY]: intl.formatMessage(voteMessages.readonly),\n    [VoteMessagesTypes.DELETED]: intl.formatMessage(voteMessages.deleted),\n    [VoteMessagesTypes.ANONYMOUS]: intl.formatMessage(voteMessages.anonymous),\n    [VoteMessagesTypes.ONLY_POSITIVE]: intl.formatMessage(voteMessages.onlyPositive),\n  };\n  return messages[type];\n}\n","import { BlockingDuration } from 'common/types';\nimport { IntlShape, defineMessages } from 'react-intl';\n\nconst blockingMessages = defineMessages({\n  permanently: {\n    id: 'blockingDuration.permanently',\n    defaultMessage: 'Permanently',\n  },\n  month: {\n    id: 'blockingDuration.month',\n    defaultMessage: 'For a month',\n  },\n  week: {\n    id: 'blockingDuration.week',\n    defaultMessage: 'For a week',\n  },\n  day: {\n    id: 'blockingDuration.day',\n    defaultMessage: 'For a day',\n  },\n});\n\nexport function getBlockingDurations(intl: IntlShape): BlockingDuration[] {\n  return [\n    {\n      label: intl.formatMessage(blockingMessages.permanently),\n      value: 'permanently',\n    },\n    {\n      label: intl.formatMessage(blockingMessages.month),\n      value: '43200m',\n    },\n    {\n      label: intl.formatMessage(blockingMessages.week),\n      value: '10080m',\n    },\n    {\n      label: intl.formatMessage(blockingMessages.day),\n      value: '1440m',\n    },\n  ];\n}\n","import { h, JSX, Component, createRef, ComponentType } from 'preact';\nimport b from 'bem-react-helper';\n\nimport { getHandleClickProps } from 'common/accessibility';\nimport { API_BASE, BASE_URL, COMMENT_NODE_CLASSNAME_PREFIX } from 'common/constants';\n\nimport { StaticStore } from 'common/static-store';\nimport debounce from 'utils/debounce';\nimport copy from 'common/copy';\nimport { Theme, BlockTTL, Comment as CommentType, PostInfo, User, CommentMode } from 'common/types';\nimport { extractErrorMessageFromResponse, FetcherError } from 'utils/errorUtils';\nimport { isUserAnonymous } from 'utils/isUserAnonymous';\n\nimport { CommentFormProps } from 'components/comment-form';\nimport { AvatarIcon } from 'components/avatar-icon';\nimport { Button } from 'components/button';\nimport Countdown from 'components/countdown';\nimport { getPreview, uploadImage } from 'common/api';\nimport postMessage from 'utils/postMessage';\nimport { FormattedMessage, useIntl, IntlShape, defineMessages } from 'react-intl';\nimport { getVoteMessage, VoteMessagesTypes } from './getVoteMessage';\nimport { getBlockingDurations } from './getBlockingDurations';\nimport { boundActions } from './connected-comment';\n\nimport './styles';\n\nconst messages = defineMessages({\n  deleteMessage: {\n    id: 'comment.delete-message',\n    defaultMessage: 'Do you want to delete this comment?',\n  },\n  hideUserComments: {\n    id: 'comment.hide-user-comment',\n    defaultMessage: 'Do you want to hide comments of {userName}?',\n  },\n  pinComment: {\n    id: 'comment.pin-comment',\n    defaultMessage: 'Do you want to pin this comment?',\n  },\n  unpinComment: {\n    id: 'comment.unpin-comment',\n    defaultMessage: 'Do you want to unpin this comment?',\n  },\n  verifyUser: {\n    id: 'comment.verify-user',\n    defaultMessage: 'Do you want to verify {userName}?',\n  },\n  unverifyUser: {\n    id: 'comment.unverify-user',\n    defaultMessage: 'Do you want to unverify {userName}?',\n  },\n  blockUser: {\n    id: 'comment.block-user',\n    defaultMessage: 'Do you want to block {userName} {duration}?',\n  },\n  unblockUser: {\n    id: 'comment.unblock-user',\n    defaultMessage: 'Do you want to unblock this user?',\n  },\n  deletedComment: {\n    id: 'comment.deleted-comment',\n    defaultMessage: 'This comment was deleted',\n  },\n  controversy: {\n    id: 'comment.controversy',\n    defaultMessage: 'Controversy: {value}',\n  },\n  toggleVerification: {\n    id: 'comment.toggle-verification',\n    defaultMessage: 'Toggle verification',\n  },\n  verifiedUser: {\n    id: 'comment.verified-user',\n    defaultMessage: 'Verified user',\n  },\n  unverifiedUser: {\n    id: 'comment.unverified-user',\n    defaultMessage: 'Unverified user',\n  },\n  goToParent: {\n    id: 'comment.go-to-parent',\n    defaultMessage: 'Go to parent comment',\n  },\n  expiredTime: {\n    id: 'comment.expired-time',\n    defaultMessage: 'Editing time has expired.',\n  },\n});\n\nexport type CommentProps = {\n  user: User | null;\n  CommentForm: ComponentType<CommentFormProps> | null;\n  data: CommentType;\n  repliesCount?: number;\n  post_info: PostInfo | null;\n  /** whether comment's user is banned */\n  isUserBanned?: boolean;\n  isCommentsDisabled: boolean;\n  /** edit mode: is comment should have reply, or edit Input */\n  editMode?: CommentMode;\n  /**\n   * \"main\" view used in main case,\n   * \"pinned\" view used in pinned block,\n   * \"user\" is for user comments widget,\n   * \"preview\" is for last comments page\n   */\n  view: 'main' | 'pinned' | 'user' | 'preview';\n  /** defines whether comment should have reply/edit actions */\n  disabled?: boolean;\n  collapsed?: boolean;\n  theme: Theme;\n  inView?: boolean;\n  level?: number;\n  mix?: string;\n  getPreview?: typeof getPreview;\n  uploadImage?: typeof uploadImage;\n  intl: IntlShape;\n} & Partial<typeof boundActions>;\n\nexport interface State {\n  renderDummy: boolean;\n  isCopied: boolean;\n  editDeadline: Date | null;\n  voteErrorMessage: string | null;\n  /**\n   * delta of the score:\n   * default is 0.\n   * if user upvoted delta will be incremented\n   * if downvoted delta will be decremented\n   */\n  scoreDelta: number;\n  /**\n   * score copied from props, that updates instantly,\n   * without server response\n   */\n  cachedScore: number;\n  initial: boolean;\n}\n\nclass Comment extends Component<CommentProps, State> {\n  votingPromise: Promise<unknown> = Promise.resolve();\n  /** comment text node. Used in comment text copying */\n  textNode = createRef<HTMLDivElement>();\n\n  updateState = (props: CommentProps) => {\n    const newState: Partial<State> = {\n      scoreDelta: props.data.vote,\n      cachedScore: props.data.score,\n    };\n\n    if (props.inView) {\n      newState.renderDummy = false;\n    }\n\n    // set comment edit timer\n    if (props.user && props.user.id === props.data.user.id) {\n      const editDuration = StaticStore.config.edit_duration;\n      const timeDiff = StaticStore.serverClientTimeDiff || 0;\n      const editDeadline = new Date(new Date(props.data.time).getTime() + timeDiff + editDuration * 1000);\n\n      if (editDeadline < new Date()) {\n        newState.editDeadline = null;\n      } else {\n        newState.editDeadline = editDeadline;\n      }\n    }\n\n    return newState;\n  };\n\n  state = {\n    renderDummy: typeof this.props.inView === 'boolean' ? !this.props.inView : false,\n    isCopied: false,\n    editDeadline: null,\n    voteErrorMessage: null,\n    scoreDelta: 0,\n    cachedScore: this.props.data.score,\n    initial: true,\n    ...this.updateState(this.props),\n  };\n\n  // getHandleClickProps = (handler?: (e: KeyboardEvent | MouseEvent) => void) => {\n  //   if (this.state.initial) return null;\n  //   if (this.props.inView === false) return null;\n  //   return getHandleClickProps(handler);\n  // };\n\n  componentWillReceiveProps(nextProps: CommentProps) {\n    this.setState(this.updateState(nextProps));\n  }\n\n  componentDidMount() {\n    // eslint-disable-next-line react/no-did-mount-set-state\n    this.setState({ initial: false });\n  }\n\n  toggleReplying = () => {\n    const { editMode, setReplyEditState, data } = this.props;\n\n    setReplyEditState?.({ id: data.id, state: editMode === CommentMode.Reply ? CommentMode.None : CommentMode.Reply });\n  };\n\n  toggleEditing = () => {\n    const { editMode, setReplyEditState, data } = this.props;\n\n    setReplyEditState?.({ id: data.id, state: editMode === CommentMode.Edit ? CommentMode.None : CommentMode.Edit });\n  };\n\n  toggleUserInfoVisibility = () => {\n    if (!window.parent) {\n      return;\n    }\n\n    const { user } = this.props.data;\n    const data = JSON.stringify({ isUserInfoShown: true, user });\n\n    window.parent.postMessage(data, '*');\n  };\n\n  togglePin = () => {\n    const value = !this.props.data.pin;\n    const intl = this.props.intl;\n    const promptMessage = value ? intl.formatMessage(messages.pinComment) : intl.formatMessage(messages.unpinComment);\n\n    if (window.confirm(promptMessage)) {\n      this.props.setPinState!(this.props.data.id, value);\n    }\n  };\n\n  toggleVerify = () => {\n    const value = !this.props.data.user.verified;\n    const userId = this.props.data.user.id;\n    const intl = this.props.intl;\n    const userName = this.props.data.user.name;\n    const promptMessage = value\n      ? intl.formatMessage(messages.verifyUser, { userName })\n      : intl.formatMessage(messages.unverifyUser, { userName });\n\n    if (window.confirm(promptMessage)) {\n      this.props.setVerifiedStatus!(userId, value);\n    }\n  };\n\n  onBlockUserClick = (e: Event) => {\n    const target = e.target as HTMLOptionElement;\n    // blur event will be triggered by the confirm pop-up which will start\n    // infinite loop of blur -> confirm -> blur -> ...\n    // so we trigger the blur event manually and have debounce mechanism to prevent it\n    if (e.type === 'change') {\n      target.blur();\n    }\n    // we have to debounce the blockUser function calls otherwise it will be\n    // called 2 times (by change event and by blur event)\n    this.blockUser(target.value as BlockTTL);\n  };\n\n  blockUser = debounce((ttl: BlockTTL): void => {\n    const { user } = this.props.data;\n    const blockingDurations = getBlockingDurations(this.props.intl);\n    const blockDuration = blockingDurations.find((el) => el.value === ttl);\n    // blocking duration may be undefined if user hasn't selected anything\n    // and ttl equals \"Blocking period\"\n    if (!blockDuration) return;\n\n    const duration = blockDuration.label;\n    const blockUser = this.props.intl.formatMessage(messages.blockUser, {\n      userName: user.name,\n      duration: duration.toLowerCase(),\n    });\n    if (window.confirm(blockUser)) {\n      this.props.blockUser!(user.id, user.name, ttl);\n    }\n  }, 100);\n\n  onUnblockUserClick = () => {\n    const { user } = this.props.data;\n    const unblockUser = this.props.intl.formatMessage(messages.unblockUser);\n\n    if (window.confirm(unblockUser)) {\n      this.props.unblockUser!(user.id);\n    }\n  };\n\n  deleteComment = () => {\n    const deleteComment = this.props.intl.formatMessage(messages.deleteMessage);\n\n    if (window.confirm(deleteComment)) {\n      this.props.setReplyEditState!({ id: this.props.data.id, state: CommentMode.None });\n\n      this.props.removeComment!(this.props.data.id);\n    }\n  };\n\n  hideUser = () => {\n    const hideUserComment = this.props.intl.formatMessage(messages.hideUserComments, {\n      userName: this.props.data.user.name,\n    });\n    if (!window.confirm(hideUserComment)) return;\n    this.props.hideUser!(this.props.data.user);\n  };\n\n  handleVoteError = (e: FetcherError, originalScore: number, originalDelta: number) => {\n    this.setState({\n      scoreDelta: originalDelta,\n      cachedScore: originalScore,\n      voteErrorMessage: extractErrorMessageFromResponse(e, this.props.intl),\n    });\n  };\n\n  sendVotingRequest = (votingValue: number, originalScore: number, originalDelta: number) => {\n    this.votingPromise = this.votingPromise\n      .then(() => this.props.putCommentVote!(this.props.data.id, votingValue))\n      .catch((e) => this.handleVoteError(e, originalScore, originalDelta));\n  };\n\n  increaseScore = () => {\n    const { cachedScore, scoreDelta } = this.state;\n\n    if (scoreDelta === 1) return;\n\n    this.setState({\n      scoreDelta: scoreDelta + 1,\n      cachedScore: cachedScore + 1,\n      voteErrorMessage: null,\n    });\n\n    this.sendVotingRequest(1, cachedScore, scoreDelta);\n  };\n\n  decreaseScore = () => {\n    const { cachedScore, scoreDelta } = this.state;\n\n    if (scoreDelta === -1) return;\n\n    this.setState({\n      scoreDelta: scoreDelta - 1,\n      cachedScore: cachedScore - 1,\n      voteErrorMessage: null,\n    });\n\n    this.sendVotingRequest(-1, cachedScore, scoreDelta);\n  };\n\n  addComment = async (text: string, title: string, pid?: CommentType['id']) => {\n    await this.props.addComment!(text, title, pid);\n\n    this.props.setReplyEditState!({ id: this.props.data.id, state: CommentMode.None });\n  };\n\n  updateComment = async (id: CommentType['id'], text: string) => {\n    await this.props.updateComment!(id, text);\n\n    this.props.setReplyEditState!({ id: this.props.data.id, state: CommentMode.None });\n  };\n\n  scrollToParent = (e: Event) => {\n    const {\n      data: { pid },\n    } = this.props;\n\n    e.preventDefault();\n\n    const parentCommentNode = document.getElementById(`${COMMENT_NODE_CLASSNAME_PREFIX}${pid}`);\n\n    if (parentCommentNode) {\n      const top = parentCommentNode.getBoundingClientRect().top;\n      if (!postMessage({ scrollTo: top })) {\n        parentCommentNode.scrollIntoView();\n      }\n    }\n  };\n\n  copyComment = () => {\n    const username = this.props.data.user.name;\n    const time = this.props.data.time;\n    const text = this.textNode.current!.textContent || '';\n\n    copy(`<b>${username}</b>&nbsp;${time}<br>${text.replace(/\\n+/g, '<br>')}`);\n\n    this.setState({ isCopied: true }, () => {\n      setTimeout(() => this.setState({ isCopied: false }), 3000);\n    });\n  };\n\n  /**\n   * Defines whether current client is admin\n   */\n  isAdmin = (): boolean => {\n    return !!this.props.user && this.props.user.admin;\n  };\n\n  /**\n   * Defines whether current client is not logged in\n   */\n  isGuest = (): boolean => {\n    return !this.props.user;\n  };\n\n  /**\n   * Defines whether current client is logged in via `Anonymous provider`\n   */\n  isAnonymous = (): boolean => {\n    return isUserAnonymous(this.props.user);\n  };\n\n  /**\n   * Defines whether comment made by logged in user\n   */\n  isCurrentUser = (): boolean => {\n    if (this.isGuest()) return false;\n\n    return this.props.data.user.id === this.props.user!.id;\n  };\n\n  /**\n   * returns reason for disabled downvoting\n   */\n  getDownvoteDisabledReason = (): string | null => {\n    const intl = this.props.intl;\n    if (!(this.props.view === 'main' || this.props.view === 'pinned'))\n      return getVoteMessage(VoteMessagesTypes.ONLY_POST_PAGE, intl);\n    if (this.props.post_info!.read_only) return getVoteMessage(VoteMessagesTypes.READONLY, intl);\n    if (this.props.data.delete) return getVoteMessage(VoteMessagesTypes.DELETED, intl);\n    if (this.isCurrentUser()) return getVoteMessage(VoteMessagesTypes.OWN_COMMENT, intl);\n    if (StaticStore.config.positive_score && this.props.data.score < 1)\n      return getVoteMessage(VoteMessagesTypes.ONLY_POSITIVE, intl);\n    if (this.isGuest()) return getVoteMessage(VoteMessagesTypes.GUEST, intl);\n    if (this.isAnonymous() && !StaticStore.config.anon_vote) return getVoteMessage(VoteMessagesTypes.ANONYMOUS, intl);\n    return null;\n  };\n\n  /**\n   * returns reason for disabled upvoting\n   */\n  getUpvoteDisabledReason = (): string | null => {\n    const intl = this.props.intl;\n    if (!(this.props.view === 'main' || this.props.view === 'pinned'))\n      return getVoteMessage(VoteMessagesTypes.ONLY_POST_PAGE, intl);\n    if (this.props.post_info!.read_only) return getVoteMessage(VoteMessagesTypes.READONLY, intl);\n    if (this.props.data.delete) return getVoteMessage(VoteMessagesTypes.DELETED, intl);\n    if (this.isCurrentUser()) return getVoteMessage(VoteMessagesTypes.OWN_COMMENT, intl);\n    if (this.isGuest()) return getVoteMessage(VoteMessagesTypes.GUEST, intl);\n    if (this.isAnonymous() && !StaticStore.config.anon_vote) return getVoteMessage(VoteMessagesTypes.ANONYMOUS, intl);\n    return null;\n  };\n\n  getCommentControls = (): JSX.Element[] => {\n    const isAdmin = this.isAdmin();\n    const isCurrentUser = this.isCurrentUser();\n    const controls: JSX.Element[] = [];\n\n    if (this.props.data.delete) {\n      return controls;\n    }\n\n    if (!(this.props.view === 'main' || this.props.view === 'pinned')) {\n      return controls;\n    }\n\n    if (isAdmin) {\n      controls.push(\n        this.state.isCopied ? (\n          <span className=\"comment__control comment__control_view_inactive\">\n            <FormattedMessage id=\"comment.copied\" defaultMessage=\"Copied!\" />\n          </span>\n        ) : (\n          <Button kind=\"link\" {...getHandleClickProps(this.copyComment)} mix=\"comment__control\">\n            <FormattedMessage id=\"comment.copy\" defaultMessage=\"Copy\" />\n          </Button>\n        )\n      );\n\n      controls.push(\n        <Button kind=\"link\" {...getHandleClickProps(this.togglePin)} mix=\"comment__control\">\n          {this.props.data.pin ? (\n            <FormattedMessage id=\"comment.unpin\" defaultMessage=\"Unpin\" />\n          ) : (\n            <FormattedMessage id=\"comment.pin\" defaultMessage=\"Pin\" />\n          )}\n        </Button>\n      );\n    }\n\n    if (!isCurrentUser) {\n      controls.push(\n        <Button kind=\"link\" {...getHandleClickProps(this.hideUser)} mix=\"comment__control\">\n          <FormattedMessage id=\"comment.hide\" defaultMessage=\"Hide\" />\n        </Button>\n      );\n    }\n\n    if (isAdmin) {\n      if (this.props.isUserBanned) {\n        controls.push(\n          <Button kind=\"link\" {...getHandleClickProps(this.onUnblockUserClick)} mix=\"comment__control\">\n            <FormattedMessage id=\"comment.unblock\" defaultMessage=\"Unblock\" />\n          </Button>\n        );\n      }\n      const blockingDurations = getBlockingDurations(this.props.intl);\n      if (this.props.user!.id !== this.props.data.user.id && !this.props.isUserBanned) {\n        controls.push(\n          <span className=\"comment__control comment__control_select-label\">\n            <FormattedMessage id=\"comment.block\" defaultMessage=\"Block\" />\n            <select className=\"comment__control_select\" onBlur={this.onBlockUserClick} onChange={this.onBlockUserClick}>\n              <option disabled selected value={undefined}>\n                <FormattedMessage id=\"comment.blocking-period\" defaultMessage=\"Blocking period\" />\n              </option>\n              {blockingDurations.map((block) => (\n                <option value={block.value}>{block.label}</option>\n              ))}\n            </select>\n          </span>\n        );\n      }\n\n      if (!this.props.data.delete) {\n        controls.push(\n          <Button kind=\"link\" {...getHandleClickProps(this.deleteComment)} mix=\"comment__control\">\n            <FormattedMessage id=\"comment.delete\" defaultMessage=\"Delete\" />\n          </Button>\n        );\n      }\n    }\n    return controls;\n  };\n\n  render(props: CommentProps, state: State) {\n    const isAdmin = this.isAdmin();\n    const isGuest = this.isGuest();\n    const isCurrentUser = this.isCurrentUser();\n\n    const isReplying = props.editMode === CommentMode.Reply;\n    const isEditing = props.editMode === CommentMode.Edit;\n    const lowCommentScore = StaticStore.config.low_score;\n    const downvotingDisabledReason = this.getDownvoteDisabledReason();\n    const isDownvotingDisabled = downvotingDisabledReason !== null;\n    const upvotingDisabledReason = this.getUpvoteDisabledReason();\n    const isUpvotingDisabled = upvotingDisabledReason !== null;\n    const editable = props.repliesCount === 0 && state.editDeadline;\n    const scoreSignEnabled = !StaticStore.config.positive_score;\n    const uploadImageHandler = this.isAnonymous() ? undefined : this.props.uploadImage;\n    const commentControls = this.getCommentControls();\n    const intl = props.intl;\n    const CommentForm = this.props.CommentForm;\n\n    /**\n     * CommentType adapted for rendering\n     */\n\n    const o = {\n      ...props.data,\n      controversyText: intl.formatMessage(messages.controversy, {\n        value: (props.data.controversy || 0).toFixed(2),\n      }),\n      text:\n        props.view === 'preview'\n          ? getTextSnippet(props.data.text)\n          : props.data.delete\n          ? intl.formatMessage(messages.deletedComment)\n          : props.data.text,\n      time: new Date(props.data.time),\n      orig: isEditing\n        ? props.data.orig &&\n          props.data.orig.replace(/&[#A-Za-z0-9]+;/gi, (entity) => {\n            const span = document.createElement('span');\n            span.innerHTML = entity;\n            return span.innerText;\n          })\n        : props.data.orig,\n      score: {\n        value: Math.abs(state.cachedScore),\n        sign: !scoreSignEnabled ? '' : state.cachedScore > 0 ? '+' : state.cachedScore < 0 ? '−' : null,\n        view: state.cachedScore > 0 ? 'positive' : state.cachedScore < 0 ? 'negative' : undefined,\n      },\n      user: {\n        ...props.data.user,\n        picture:\n          props.data.user.picture.indexOf(API_BASE) === 0\n            ? `${BASE_URL}${props.data.user.picture}`\n            : props.data.user.picture,\n      },\n    };\n\n    const defaultMods = {\n      disabled: props.disabled,\n      pinned: props.data.pin,\n      // TODO: we also have critical_score, so we need to collapse comments with it in future\n      useless:\n        !!props.isUserBanned ||\n        !!props.data.delete ||\n        (props.view !== 'preview' && props.data.score < lowCommentScore && !props.data.pin && !props.disabled),\n      // TODO: add default view mod or don't?\n      guest: isGuest,\n      view: props.view === 'main' || props.view === 'pinned' ? props.data.user.admin && 'admin' : props.view,\n      replying: props.view === 'main' && isReplying,\n      editing: props.view === 'main' && isEditing,\n      theme: props.view === 'preview' ? undefined : props.theme,\n      level: props.level,\n      collapsed: props.collapsed,\n    };\n\n    if (props.view === 'preview') {\n      return (\n        <article className={b('comment', { mix: props.mix }, defaultMods)}>\n          <div className=\"comment__body\">\n            {!!o.title && (\n              <div className=\"comment__title\">\n                <a className=\"comment__title-link\" href={`${o.locator.url}#${COMMENT_NODE_CLASSNAME_PREFIX}${o.id}`}>\n                  {o.title}\n                </a>\n              </div>\n            )}\n            <div className=\"comment__info\">\n              {!!o.title && o.user.name}\n\n              {!o.title && (\n                <a href={`${o.locator.url}#${COMMENT_NODE_CLASSNAME_PREFIX}${o.id}`} className=\"comment__username\">\n                  {o.user.name}\n                </a>\n              )}\n            </div>{' '}\n            <div\n              className={b('comment__text', { mix: b('raw-content', {}, { theme: props.theme }) })}\n              // eslint-disable-next-line react/no-danger\n              dangerouslySetInnerHTML={{ __html: o.text }}\n            />\n          </div>\n        </article>\n      );\n    }\n\n    if (this.state.renderDummy && !props.editMode) {\n      const [width, height] = this.base\n        ? [(this.base as Element).scrollWidth, (this.base as Element).scrollHeight]\n        : [100, 100];\n      return (\n        <article\n          id={props.disabled ? undefined : `${COMMENT_NODE_CLASSNAME_PREFIX}${o.id}`}\n          style={{\n            width: `${width}px`,\n            height: `${height}px`,\n          }}\n        />\n      );\n    }\n    const goToParentMessage = intl.formatMessage(messages.goToParent);\n    return (\n      <article\n        className={b('comment', { mix: this.props.mix }, defaultMods)}\n        id={props.disabled ? undefined : `${COMMENT_NODE_CLASSNAME_PREFIX}${o.id}`}\n      >\n        {props.view === 'user' && o.title && (\n          <div className=\"comment__title\">\n            <a className=\"comment__title-link\" href={`${o.locator.url}#${COMMENT_NODE_CLASSNAME_PREFIX}${o.id}`}>\n              {o.title}\n            </a>\n          </div>\n        )}\n        <div className=\"comment__info\">\n          {props.view !== 'user' && !props.collapsed && (\n            <AvatarIcon mix=\"comment__avatar\" theme={this.props.theme} picture={o.user.picture} />\n          )}\n\n          {props.view !== 'user' && (\n            <span\n              {...getHandleClickProps(this.toggleUserInfoVisibility)}\n              className=\"comment__username\"\n              title={o.user.id}\n            >\n              {o.user.name}\n            </span>\n          )}\n\n          {isAdmin && props.view !== 'user' && (\n            <span\n              {...getHandleClickProps(this.toggleVerify)}\n              aria-label={intl.formatMessage(messages.toggleVerification)}\n              title={\n                o.user.verified\n                  ? intl.formatMessage(messages.verifiedUser)\n                  : intl.formatMessage(messages.unverifiedUser)\n              }\n              className={b('comment__verification', {}, { active: o.user.verified, clickable: true })}\n            />\n          )}\n\n          {!isAdmin && !!o.user.verified && props.view !== 'user' && (\n            <span\n              title={intl.formatMessage(messages.verifiedUser)}\n              className={b('comment__verification', {}, { active: true })}\n            />\n          )}\n\n          <a href={`${o.locator.url}#${COMMENT_NODE_CLASSNAME_PREFIX}${o.id}`} className=\"comment__time\">\n            <FormatTime time={o.time} />\n          </a>\n\n          {!!props.level && props.level > 0 && props.view === 'main' && (\n            <a\n              className=\"comment__link-to-parent\"\n              href={`${o.locator.url}#${COMMENT_NODE_CLASSNAME_PREFIX}${o.pid}`}\n              aria-label={goToParentMessage}\n              title={goToParentMessage}\n              onClick={(e) => this.scrollToParent(e)}\n            >\n              {' '}\n            </a>\n          )}\n\n          {props.isUserBanned && props.view !== 'user' && (\n            <span className=\"comment__status\">\n              <FormattedMessage id=\"comment.blocked-user\" defaultMessage=\"Blocked\" />\n            </span>\n          )}\n\n          {isAdmin && !props.isUserBanned && props.data.delete && (\n            <span className=\"comment__status\">\n              <FormattedMessage id=\"comment.deleted-user\" defaultMessage=\"Deleted\" />\n            </span>\n          )}\n\n          <span className={b('comment__score', {}, { view: o.score.view })}>\n            <span\n              className={b(\n                'comment__vote',\n                {},\n                { type: 'up', selected: state.scoreDelta === 1, disabled: isUpvotingDisabled }\n              )}\n              aria-disabled={state.scoreDelta === 1 || isUpvotingDisabled ? 'true' : 'false'}\n              {...getHandleClickProps(isUpvotingDisabled ? undefined : this.increaseScore)}\n              title={upvotingDisabledReason || undefined}\n            >\n              Vote up\n            </span>\n\n            <span className=\"comment__score-value\" title={o.controversyText}>\n              {o.score.sign}\n              {o.score.value}\n            </span>\n\n            <span\n              className={b(\n                'comment__vote',\n                {},\n                { type: 'down', selected: state.scoreDelta === -1, disabled: isDownvotingDisabled }\n              )}\n              aria-disabled={state.scoreDelta === -1 || isUpvotingDisabled ? 'true' : 'false'}\n              {...getHandleClickProps(isDownvotingDisabled ? undefined : this.decreaseScore)}\n              title={downvotingDisabledReason || undefined}\n            >\n              Vote down\n            </span>\n          </span>\n        </div>\n        <div className=\"comment__body\">\n          {!!state.voteErrorMessage && (\n            <div className=\"voting__error\" role=\"alert\">\n              <FormattedMessage\n                id=\"comment.vote-error\"\n                defaultMessage=\"Voting error: {voteErrorMessage}\"\n                values={{ voteErrorMessage: state.voteErrorMessage }}\n              />\n            </div>\n          )}\n\n          {(!props.collapsed || props.view === 'pinned') && (\n            <div\n              className={b('comment__text', { mix: b('raw-content', {}, { theme: props.theme }) })}\n              ref={this.textNode}\n              // eslint-disable-next-line react/no-danger\n              dangerouslySetInnerHTML={{ __html: o.text }}\n            />\n          )}\n\n          {(!props.collapsed || props.view === 'pinned') && (\n            <div className=\"comment__actions\">\n              {!props.data.delete && !props.isCommentsDisabled && !props.disabled && props.view === 'main' && (\n                <Button kind=\"link\" {...getHandleClickProps(this.toggleReplying)} mix=\"comment__action\">\n                  {isReplying ? (\n                    <FormattedMessage id=\"comment.cancel\" defaultMessage=\"Cancel\" />\n                  ) : (\n                    <FormattedMessage id=\"comment.reply\" defaultMessage=\"Reply\" />\n                  )}\n                </Button>\n              )}\n              {!props.data.delete &&\n                !props.disabled &&\n                !!o.orig &&\n                isCurrentUser &&\n                (editable || isEditing) &&\n                props.view === 'main' && [\n                  <Button\n                    kind=\"link\"\n                    {...getHandleClickProps(this.toggleEditing)}\n                    mix={['comment__action', 'comment__action_type_edit']}\n                  >\n                    {isEditing ? (\n                      <FormattedMessage id=\"comment.cancel\" defaultMessage=\"Cancel\" />\n                    ) : (\n                      <FormattedMessage id=\"comment.edit\" defaultMessage=\"Edit\" />\n                    )}\n                  </Button>,\n                  !isAdmin && (\n                    <Button\n                      kind=\"link\"\n                      {...getHandleClickProps(this.deleteComment)}\n                      mix={['comment__action', 'comment__action_type_delete']}\n                    >\n                      <FormattedMessage id=\"comment.delete\" defaultMessage=\"Delete\" />\n                    </Button>\n                  ),\n                  state.editDeadline && (\n                    <Countdown\n                      className=\"comment__edit-timer\"\n                      time={state.editDeadline}\n                      onTimePassed={() =>\n                        this.setState({\n                          editDeadline: null,\n                        })\n                      }\n                    />\n                  ),\n                ]}\n\n              {commentControls.length > 0 && <span className=\"comment__controls\">{commentControls}</span>}\n            </div>\n          )}\n        </div>\n\n        {CommentForm && isReplying && props.view === 'main' && (\n          <CommentForm\n            id={o.id}\n            intl={this.props.intl}\n            user={props.user}\n            theme={props.theme}\n            mode=\"reply\"\n            mix=\"comment__input\"\n            onSubmit={(text: string, title: string) => this.addComment(text, title, o.id)}\n            onCancel={this.toggleReplying}\n            getPreview={this.props.getPreview!}\n            autofocus={true}\n            uploadImage={uploadImageHandler}\n            simpleView={StaticStore.config.simple_view}\n          />\n        )}\n\n        {CommentForm && isEditing && props.view === 'main' && (\n          <CommentForm\n            id={o.id}\n            intl={this.props.intl}\n            user={props.user}\n            theme={props.theme}\n            value={o.orig}\n            mode=\"edit\"\n            mix=\"comment__input\"\n            onSubmit={(text: string) => this.updateComment(props.data.id, text)}\n            onCancel={this.toggleEditing}\n            getPreview={this.props.getPreview!}\n            errorMessage={state.editDeadline === null ? intl.formatMessage(messages.expiredTime) : undefined}\n            autofocus={true}\n            uploadImage={uploadImageHandler}\n            simpleView={StaticStore.config.simple_view}\n          />\n        )}\n      </article>\n    );\n  }\n}\n\nfunction getTextSnippet(html: string) {\n  const LENGTH = 100;\n  const tmp = document.createElement('div');\n  tmp.innerHTML = html.replace('</p><p>', ' ');\n\n  const result = tmp.innerText || '';\n  const snippet = result.substr(0, LENGTH);\n\n  return snippet.length === LENGTH && result.length !== LENGTH ? `${snippet}...` : snippet;\n}\n\nfunction FormatTime({ time }: { time: Date }) {\n  const intl = useIntl();\n\n  return (\n    <FormattedMessage\n      id=\"comment.time\"\n      defaultMessage=\"{day} at {time}\"\n      values={{\n        day: intl.formatDate(time),\n        time: intl.formatTime(time),\n      }}\n    />\n  );\n}\n\nexport default Comment;\n","type FnType<T extends unknown[]> = (...args: T) => unknown;\n\nexport default function debounce<T extends unknown[]>(\n  fn: FnType<T>,\n  wait = 1000\n): (...args: Parameters<FnType<T>>) => void {\n  let timeout: number | undefined;\n\n  return function (this: unknown, ...args): void {\n    const laterCall = (): unknown => fn.apply(this, args);\n    window.clearTimeout(timeout);\n    timeout = window.setTimeout(laterCall, wait);\n  };\n}\n","import { User } from 'common/types';\n\nexport type Message =\n  | { inited: true }\n  | {\n      isUserInfoShown: true;\n      user: User;\n    }\n  | { isUserInfoShown: false }\n  | { scrollTo: number }\n  | { remarkIframeHeight: number };\n\n/**\n * Sends message to parent window\n *\n * @returns request success of fail\n */\nexport default function postMessage(data: Message): boolean {\n  if (!window.parent || window.parent === window) return false;\n  window.parent.postMessage(JSON.stringify(data), '*');\n  return true;\n}\n","// based on https://github.com/sindresorhus/copy-text-to-clipboard, but improved to copy text styles too\nexport default function copy(input: string): boolean {\n  const element = document.createElement('textarea') as HTMLTextAreaElement;\n  const previouslyFocusedElement = document.activeElement as HTMLElement;\n\n  element.value = input;\n\n  // Prevent keyboard from showing on mobile\n  element.setAttribute('readonly', '');\n\n  Object.assign(element.style, {\n    contain: 'strict',\n    position: 'absolute',\n    left: '-9999px',\n    fontSize: '12pt', // Prevent zooming on iOS\n  });\n\n  const selection = document.getSelection();\n  let originalRange: boolean | Range = false;\n\n  if (selection && selection.rangeCount > 0) {\n    originalRange = selection.getRangeAt(0);\n  }\n\n  document.body.append(element);\n  element.select();\n\n  // Explicit selection workaround for iOS\n  element.selectionStart = 0;\n  element.selectionEnd = input.length;\n\n  let isSuccess = false;\n  try {\n    isSuccess = document.execCommand('copy');\n  } catch (_) {}\n\n  element.remove();\n\n  if (selection && originalRange) {\n    selection.removeAllRanges();\n    selection.addRange(originalRange);\n  }\n\n  // Get the focus back on the previously focused element, if any\n  if (previouslyFocusedElement) {\n    previouslyFocusedElement.focus();\n  }\n\n  return isSuccess;\n}\n","import { User } from 'common/types';\n\n/**\n * Defines whether current client is logged in via `Anonymous provider`\n */\nexport function isUserAnonymous(user: User | null) {\n  return user === null || user.id.substr(0, 10) === 'anonymous_';\n}\n","import { h, FunctionComponent } from 'preact';\nimport { useIntl } from 'react-intl';\nimport classnames from 'classnames';\n\nimport type { Comment as CommentType } from 'common/types';\nimport Comment from 'components/comment';\n\nimport styles from './list-comments.module.css';\n\nexport type ListCommentsProps = {\n  comments: CommentType[];\n};\n\nconst ListComments: FunctionComponent<ListCommentsProps> = ({ comments = [] }) => {\n  const intl = useIntl();\n\n  return (\n    <div className={classnames('comments-list', styles.root)}>\n      {comments.map((comment) => (\n        <Comment\n          intl={intl}\n          key={comment.id}\n          CommentForm={null}\n          data={comment}\n          level={0}\n          view=\"preview\"\n          mix=\"list-comments__item\"\n          user={null}\n          theme=\"light\"\n          isCommentsDisabled={false}\n          post_info={null}\n        />\n      ))}\n    </div>\n  );\n};\n\nexport default ListComments;\n","// extracted by mini-css-extract-plugin\nexport default {\"root\":\"list-comments-module__root_93c8f\"};","import { h, render } from 'preact';\nimport { IntlProvider } from 'react-intl';\n\nimport getLastComments from 'common/api.getLastComments';\nimport { BASE_URL } from 'common/constants.config';\nimport { loadLocale } from 'utils/loadLocale';\nimport { getLocale } from 'utils/getLocale';\nimport ListComments from 'components/list-comments';\n\nconst LAST_COMMENTS_NODE_CLASSNAME = 'remark42__last-comments';\nconst DEFAULT_LAST_COMMENTS_MAX = 15;\n\nif (document.readyState === 'loading') {\n  document.addEventListener('DOMContentLoaded', init);\n} else {\n  init();\n}\n\nasync function init(): Promise<void> {\n  __webpack_public_path__ = `${BASE_URL}/web/`;\n\n  const nodes = document.getElementsByClassName(LAST_COMMENTS_NODE_CLASSNAME);\n\n  if (!nodes) {\n    throw new Error(\"Remark42: Can't find last comments nodes.\");\n  }\n\n  if (!window.remark_config) {\n    throw new Error('Remark42: Config object is undefined');\n  }\n\n  const { site_id, max_last_comments } = window.remark_config;\n\n  if (!site_id) {\n    throw new Error('Remark42: Site ID is undefined.');\n  }\n\n  const styles = document.createElement('link');\n  styles.href = `${BASE_URL}/web/last-comments.css`;\n  styles.rel = 'stylesheet';\n  (document.head || document.body).appendChild(styles);\n\n  (Array.from(nodes) as HTMLElement[]).forEach((node) => {\n    const max = (node.dataset.max && parseInt(node.dataset.max, 10)) || max_last_comments || DEFAULT_LAST_COMMENTS_MAX;\n    const locale = getLocale(window.remark_config);\n\n    Promise.all([getLastComments(site_id, max), loadLocale(locale)]).then(([comments, messages]) => {\n      try {\n        render(\n          <IntlProvider locale={locale} messages={messages}>\n            <ListComments comments={comments} />\n          </IntlProvider>,\n          node\n        );\n      } catch (e) {\n        console.error('Remark42: Something went wrong with last comments rendering');\n        console.error(e);\n      }\n    });\n  });\n}\n","export function getLocale(params: { locale?: string; [key: string]: unknown }): string {\n  return params.locale || 'en';\n}\n"],"sourceRoot":""}