{"version":3,"file":"setup-cpp.js","names":["e","t","r","n","i","o","a","s","l","u","d","Promise","TypeError","r7","code","ignoreErrors","f","options","env","process","cwd","chdir","disabled","r8","sync","command","path","ne","pathExt","iE","delimiter","resolve","h","Object","assign","Error","errno","syscall","spawnargs","args","m","ou","file","original","g","r5","rS","spawn","na","hookChildProcess","v","charCodeAt","length","slice","E","platform","keys","reverse","find","toUpperCase","y","p","rO","execPath","URL","rA","fileURLToPath","rR","push","join","w","pipe","b","writable","_write","_writableState","x","maxBuffer","nf","getBufferedLength","np","MAX_LENGTH","bufferedData","getBufferedValue","o9","on","o7","S","aR","am","ag","aN","o2","rI","ChildProcess","ap","reject","oA","error","stdout","stderr","all","escapedCommand","parsed","timedOut","isCanceled","killed","ad","o3","o4","c","kill","oK","bind","cancel","o0","ns","exitCode","signal","al","aI","aborted","failed","ai","ao","o8","D","ar","spawnSync","input","status","N","getuid","CI","rJ","nothrow","T","aC","av","I","O","R","map","A","SUDO_USER","iy","statSync","isDirectory","C","iv","homedir","replace","a_","_","next","throw","done","value","then","apply","L","return","call","label","ops","pop","trys","sent","Symbol","iterator","$","nv","pkg","nP","rX","warning","message","stack","P","Array","isArray","k","sf","sr","sn","sp","aX","a9","a$","a7","aV","az","aM","aG","a5","sh","a1","a3","aW","U","stdio","M","sw","nU","nM","shouldEscapeSpace","rV","GITHUB_ACTIONS","shouldAddOnlyIfNotDefined","nk","info","exportVariable","j","setFailed","F","sb","some","test","PATH","split","includes","addPath","q","B","appendFileSync","sx","sS","nF","pathExists","readFileSync","G","Set","writeFileSync","H","z","name","version","DEBIAN_FRONTEND","sN","Y","sT","K","flatMap","repositories","X","sR","binDir","V","nj","default","trim","J","W","Q","Z","toString","sD","ee","startsWith","et","nB","dirname","tmpdir","nG","mkdirP","NONINTERACTIVE","er","en","sI","arch","ei","SystemRoot","ALLUSERSPROFILE","ChocolateyInstall","eo","sO","TMP","TEMP","Path","extendEnv","ea","es","el","eu","ec","ep","ed","sA","sC","ef","matchAll","s_","eh","sU","sM","ew","sP","existsSync","readdirSync","eE","em","eb","sG","s$","eg","sj","clean","sL","debug","rmRF","ev","valid","ey","sort","gt","satisfies","RUNNER_TOOL_CACHE","rw","ok","RUNNER_TEMP","ex","rj","eS","$current","max","timeout","match","backoffBase","backoffExponent","report","Date","toLocaleTimeString","setTimeout","clearTimeout","sY","current","catch","RegExp","Math","pow","eD","url","binRelativeDir","binFileName","extractedFolderName","extractFunction","nH","installDir","n5","downloadTool","sK","cacheDir","eN","eT","eR","eI","eO","eA","eC","n4","n2","addExeExt","extractTar","e_","eL","n8","e$","eP","ek","isMemoized","fn","isEqual","isMatchingKey","isPromise","maxSize","onCacheAdd","onCacheChange","onCacheHit","transformKey","n6","n9","values","canTransformKey","shouldCloneArguments","shouldUpdateOnAdd","shouldUpdateOnChange","shouldUpdateOnHit","arguments","getKeyIndex","orderByLru","updateAsyncCache","cache","eU","ix","request","method","statusCode","end","eM","from","filter","it","localeCompare","eF","ie","has","JSON","stringify","ej","sW","nJ","getExecOutput","console","eq","eB","eG","eX","bin","eW","eH","eV","e7","e9","upgrade","usePipx","to","isLibrary","eY","setupActionsPython","rG","ez","eK","sQ","python","eJ","eZ","eQ","pip","e0","e1","e3","e2","sZ","parseInt","sJ","e4","execFile","encoding","shell","e5","e6","ii","getUbuntuVersion","e8","lu","user","tn","PIPX_HOME","ls","PIPX_BIN_DIR","ll","s0","ti","te","la","tt","tr","s1","findIndex","ta","ts","tl","tu","tc","io","locator","errorHandler","fatalError","parseFromString","childNodes","documentElement","declaration","doctype","tp","nodeValue","tagName","td","tf","th","lf","ld","tm","Number","isInteger","tg","tv","tE","rM","pipeline","rU","Writable","write","Buffer","concat","ty","lA","i$","lI","lO","chmod","close","tw","iV","tb","lC","utimes","tx","iU","tS","iB","tD","iN","tN","iP","tT","iC","tR","tI","ignoreUnreadableDirectories","tO","lM","read","extract","tA","tC","t_","lp","notice","tL","t$","lF","releaseName","fileSuffix","tP","tU","tM","tk","is","tF","il","tj","tq","tB","tG","tH","tV","iu","tX","tz","lH","tY","execSync","entries","lG","lq","lB","lj","tK","id","tW","lW","startGroup","milliseconds","fallback","customTimers","sign","lK","addEventListener","POSITIVE_INFINITY","lX","finally","clear","tJ","endGroup","ue","rd","tQ","tZ","lZ","lJ","NODE_DEBUG","t0","lQ","rF","t1","t3","t2","l1","t4","l3","l2","get","l0","l4","l5","t5","t6","l6","rt","t8","t9","l9","rr","ih","All","ir","l8","t7","re","LD_LIBRARY_PATH","DYLD_LIBRARY_PATH","im","rn","ri","ic","ip","ro","ig","ra","rs","rl","ru","rc","rp","l7","addShExt","addShRelativePrefix","rf","compiler","rh","ACTIONS_ALLOW_UNSECURE_COMMANDS","alias","unknown","string","boolean","splice","substring","indexOf","repeat","shift","ur","fromEntries","getInput","toLowerCase","help","table","tools","documentation","coverage","other","architecture","SETUP_CPP_DIR","rK","create","autoloadLocales","addLocale","rW","rz","rY","forEach","cppcheck","gcovr","ut","isCI","now","parseFloat","format","success","rm","rg","rv","r0","r1","r3","r2","nt","nr","nu","nd","nh","ng","ny","nw","nb","nx","nS","nD","nN","nT","nR","nI","nO","nA","nC","n_","nL","n$","n7","any","every","defineProperty","exports","constant","isPR","pr","BUILD_ID","BUILD_NUMBER","CI_APP_ID","CI_BUILD_ID","CI_BUILD_NUMBER","CI_NAME","CONTINUOUS_INTEGRATION","RUN_ID","parse","log","required","trimWhitespace","issueCommand","toCommandProperties","issue","ExitCode","Success","Failure","toCommandValue","GITHUB_ENV","issueFileCommand","prepareKeyValueMessage","setSecret","GITHUB_PATH","getMultilineInput","getBooleanInput","setOutput","GITHUB_OUTPUT","EOL","setCommandEcho","isDebug","RUNNER_DEBUG","group","saveState","GITHUB_STATE","getState","getIDToken","OidcClient","enumerable","summary","markdownSummary","toPosixPath","toWin32Path","toPlatformPath","constructor","properties","hasOwnProperty","String","title","line","startLine","endLine","col","startColumn","endColumn","random","rng","iw","randomFillSync","Uint8Array","substr","createHttpClient","HttpClient","BearerCredentialHandler","getRequestToken","allowRetries","maxRetries","ACTIONS_ID_TOKEN_REQUEST_TOKEN","getIDTokenUrl","ACTIONS_ID_TOKEN_REQUEST_URL","getCall","getJson","result","encodeURIComponent","ib","HttpCodes","OK","MultipleChoices","MovedPermanently","ResourceMoved","SeeOther","NotModified","UseProxy","SwitchProxy","TemporaryRedirect","PermanentRedirect","BadRequest","Unauthorized","PaymentRequired","Forbidden","NotFound","MethodNotAllowed","NotAcceptable","ProxyAuthenticationRequired","RequestTimeout","Conflict","Gone","TooManyRequests","InternalServerError","NotImplemented","BadGateway","ServiceUnavailable","GatewayTimeout","Headers","Accept","ContentType","MediaTypes","ApplicationJson","getProxyUrl","href","setPrototypeOf","prototype","HttpClientError","readBody","alloc","HttpClientResponse","isHttps","protocol","_ignoreSslError","_allowRedirects","_allowRedirectDowngrade","_maxRedirects","_allowRetries","_maxRetries","_keepAlive","_disposed","userAgent","handlers","requestOptions","ignoreSslError","_socketTimeout","socketTimeout","allowRedirects","allowRedirectDowngrade","maxRedirects","keepAlive","del","post","patch","put","head","sendStream","_getExistingOrDefaultHeader","_processResponse","postJson","putJson","patchJson","_prepareRequest","requestRaw","canHandleAuthentication","handleAuthentication","headers","location","hostname","_performExponentialBackoff","dispose","_agent","destroy","requestRawWithCallback","byteLength","httpModule","getAgent","_getAgent","parsedUrl","host","port","pathname","search","_mergeHeaders","agent","prepareRequest","_proxyAgent","maxSockets","globalAgent","proxy","username","password","proxyAuth","httpsOverHttps","httpsOverHttp","httpOverHttps","httpOverHttp","Agent","rejectUnauthorized","min","deserializeDates","isNaN","valueOf","reduce","no_proxy","NO_PROXY","endsWith","https_proxy","HTTPS_PROXY","http_proxy","HTTP_PROXY","checkBypass","proxyOptions","defaultMaxSockets","requests","sockets","onSocket","removeSocket","createSocket","getHeader","socket","servername","rE","connect","localAddress","defaultPort","rb","inherits","ry","EventEmitter","addRequest","emit","removeListener","removeAllListeners","useChunkedEncodingByDefault","once","nextTick","unshift","BasicCredentialHandler","Authorization","token","PersonalAccessTokenCredentialHandler","access","appendFile","writeFile","promises","SUMMARY_ENV_VAR","SUMMARY_DOCS_URL","_buffer","filePath","_filePath","constants","R_OK","W_OK","wrap","overwrite","emptyBuffer","isEmptyBuffer","addRaw","addEOL","addCodeBlock","lang","addList","addTable","header","data","colspan","rowspan","addDetails","addImage","width","height","src","alt","addHeading","addSeparator","addBreak","addQuote","cite","addLink","sep","require","pluralize","numerous","locale","span","unitType","unitTypeLookupOrder","autoload","floor","defaultConfig","versions","node","isSymbolicLink","isFile","PATHEXT","stat","mode","uid","gid","getgid","inc","diff","major","minor","prerelease","compare","rcompare","compareLoose","compareBuild","rsort","lt","neq","gte","lte","cmp","coerce","Comparator","Range","toComparators","maxSatisfying","minSatisfying","minVersion","validRange","outside","gtr","ltr","intersects","simplifyRange","subset","SemVer","tokens","SEMVER_SPEC_VERSION","RELEASE_TYPES","compareIdentifiers","rcompareIdentifiers","MAX_SAFE_COMPONENT_LENGTH","MAX_SAFE_BUILD_LENGTH","safeRe","NUMERICIDENTIFIER","NUMERICIDENTIFIERLOOSE","NONNUMERICIDENTIFIER","PRERELEASEIDENTIFIER","PRERELEASEIDENTIFIERLOOSE","BUILDIDENTIFIER","MAINVERSION","PRERELEASE","BUILD","FULLPLAIN","MAINVERSIONLOOSE","PRERELEASELOOSE","LOOSEPLAIN","XRANGEIDENTIFIER","XRANGEIDENTIFIERLOOSE","GTLT","XRANGEPLAIN","XRANGEPLAINLOOSE","COERCEPLAIN","COERCE","COERCEFULL","LONETILDE","tildeTrimReplace","LONECARET","caretTrimReplace","comparatorTrimReplace","MAX_SAFE_INTEGER","FLAG_INCLUDE_PRERELEASE","FLAG_LOOSE","loose","includePrerelease","LOOSE","FULL","raw","build","compareMain","comparePre","freeze","rtl","COERCERTLFULL","COERCERTL","exec","index","lastIndex","ANY","semver","operator","COMPARATORLOOSE","COMPARATOR","set","parseRange","range","HYPHENRANGELOOSE","HYPHENRANGE","COMPARATORTRIM","TILDETRIM","CARETTRIM","Map","size","delete","TILDELOOSE","TILDE","CARETLOOSE","CARET","XRANGELOOSE","XRANGE","STAR","GTE0PRE","GTE0","unshiftNode","maxAge","tail","prev","key","removeNode","stale","noDisposeOnSet","updateAgeOnGet","reset","allowStale","lengthCalculator","itemCount","rforEach","toArray","dump","dumpLru","peek","load","prune","list","Node","pushNode","forEachReverse","getReverse","mapReverse","reduceReverse","toArrayReverse","sliceReverse","add","rx","configurable","basename","extname","normalize","relative","IS_WINDOWS","force","recursive","retryDelay","mkdir","isRooted","tryGetExecutablePath","lstat","unlink","readlink","symlink","exists","copyFile","cp","copySourceDirectory","readdir","mv","rename","which","findInPath","open","rmdir","UV_FS_O_EXLOCK","READONLY","O_RDONLY","getCmdPath","COMSPEC","_findMatch","stable","files","platform_version","_getOsVersion","_readLinuxVersionFile","randomBytes","argStringToArray","ToolRunner","rD","StringDecoder","listeners","toolPath","_debug","_getCommandString","_getSpawnFileName","_getSpawnArgs","_isCmdFile","windowsVerbatimArguments","_windowsQuoteCmdArg","_processLineBuffer","_endsWith","_uvQuoteCmdArg","_cloneExecOptions","silent","failOnStdErr","ignoreReturnCode","delay","outStream","errStream","_getSpawnOptions","argv0","stdline","processStderr","errline","processError","processExited","processClosed","CheckComplete","processExitCode","stdin","charAt","_setResult","rN","HandleTimeout","rH","cdata","lineNumber","columnNumber","systemId","java","currentElement","appendChild","doc","NAMESPACE","ParseError","XMLReader","domBuilder","xmlns","HTML_ENTITIES","XML_ENTITIES","setDocumentLocator","Function","HTML","xml","XML","normalizeLineEndings","startDocument","createDocument","documentURI","startElement","createElementNS","getURI","getValue","getQName","createAttributeNS","getLocator","setAttributeNode","endElement","parentNode","startPrefixMapping","endPrefixMapping","processingInstruction","createProcessingInstruction","ignorableWhitespace","characters","createCDATASection","createTextNode","skippedEntity","endDocument","comment","createComment","startCDATA","endCDATA","startDTD","implementation","createDocumentType","warn","isHTML","XML_APPLICATION","XML_TEXT","XML_XHTML_APPLICATION","XML_SVG_IMAGE","SVG","XMLNS","captureStackTrace","_node","_refresh","_inc","ownerDocument","$$length","ownerElement","namespaceURI","_nsMap","prefix","localName","firstChild","nextSibling","previousSibling","lastChild","nodeType","DOCUMENT_TYPE_NODE","ELEMENT_NODE","TEXT_NODE","DOCUMENT_FRAGMENT_NODE","DOCUMENT_NODE","COMMENT_NODE","PROCESSING_INSTRUCTION_NODE","removeChild","lookupPrefix","namespace","attributes","item","nodeName","publicId","internalSubset","target","ATTRIBUTE_NODE","CDATA_SECTION_NODE","ENTITY_REFERENCE_NODE","ENTITY_NODE","NOTATION_NODE","INDEX_SIZE_ERR","DOMSTRING_SIZE_ERR","HIERARCHY_REQUEST_ERR","WRONG_DOCUMENT_ERR","INVALID_CHARACTER_ERR","NO_DATA_ALLOWED_ERR","NO_MODIFICATION_ALLOWED_ERR","NOT_FOUND_ERR","NOT_SUPPORTED_ERR","INUSE_ATTRIBUTE_ERR","INVALID_STATE_ERR","SYNTAX_ERR","INVALID_MODIFICATION_ERR","NAMESPACE_ERR","INVALID_ACCESS_ERR","getNamedItem","setNamedItem","_ownerElement","setNamedItemNS","getNamedItemNS","removeNamedItem","removeNamedItemNS","hasFeature","insertBefore","replaceChild","hasChildNodes","cloneNode","appendData","isSupported","hasAttributes","lookupNamespaceURI","isDefaultNamespace","importNode","getElementById","getAttribute","getElementsByClassName","createElement","createDocumentFragment","createAttribute","specified","createEntityReference","hasAttribute","getAttributeNode","setAttribute","removeAttribute","removeAttributeNode","setAttributeNodeNS","removeAttributeNS","getAttributeNodeNS","hasAttributeNS","getAttributeNS","setAttributeNS","getElementsByTagName","getElementsByTagNameNS","substringData","insertData","replaceData","deleteData","splitText","serializeToString","apos","quot","Aacute","aacute","Abreve","abreve","ac","acd","acE","Acirc","acirc","acute","Acy","acy","AElig","aelig","af","Afr","afr","Agrave","agrave","alefsym","aleph","Alpha","alpha","Amacr","amacr","amalg","AMP","amp","And","and","andand","andd","andslope","andv","ang","ange","angle","angmsd","angmsdaa","angmsdab","angmsdac","angmsdad","angmsdae","angmsdaf","angmsdag","angmsdah","angrt","angrtvb","angrtvbd","angsph","angst","angzarr","Aogon","aogon","Aopf","aopf","apacir","apE","ape","apid","ApplyFunction","approx","approxeq","Aring","aring","Ascr","ascr","Assign","ast","asymp","asympeq","Atilde","atilde","Auml","auml","awconint","awint","backcong","backepsilon","backprime","backsim","backsimeq","Backslash","Barv","barvee","Barwed","barwed","barwedge","bbrk","bbrktbrk","bcong","Bcy","bcy","bdquo","becaus","Because","because","bemptyv","bepsi","bernou","Bernoullis","Beta","beta","beth","between","Bfr","bfr","bigcap","bigcirc","bigcup","bigodot","bigoplus","bigotimes","bigsqcup","bigstar","bigtriangledown","bigtriangleup","biguplus","bigvee","bigwedge","bkarow","blacklozenge","blacksquare","blacktriangle","blacktriangledown","blacktriangleleft","blacktriangleright","blank","blk12","blk14","blk34","block","bne","bnequiv","bNot","bnot","Bopf","bopf","bot","bottom","bowtie","boxbox","boxDL","boxDl","boxdL","boxdl","boxDR","boxDr","boxdR","boxdr","boxH","boxh","boxHD","boxHd","boxhD","boxhd","boxHU","boxHu","boxhU","boxhu","boxminus","boxplus","boxtimes","boxUL","boxUl","boxuL","boxul","boxUR","boxUr","boxuR","boxur","boxV","boxv","boxVH","boxVh","boxvH","boxvh","boxVL","boxVl","boxvL","boxvl","boxVR","boxVr","boxvR","boxvr","bprime","Breve","breve","brvbar","Bscr","bscr","bsemi","bsim","bsime","bsol","bsolb","bsolhsub","bull","bullet","bump","bumpE","bumpe","Bumpeq","bumpeq","Cacute","cacute","Cap","cap","capand","capbrcup","capcap","capcup","capdot","CapitalDifferentialD","caps","caret","caron","Cayleys","ccaps","Ccaron","ccaron","Ccedil","ccedil","Ccirc","ccirc","Cconint","ccups","ccupssm","Cdot","cdot","cedil","Cedilla","cemptyv","cent","CenterDot","centerdot","Cfr","cfr","CHcy","chcy","check","checkmark","Chi","chi","cir","circ","circeq","circlearrowleft","circlearrowright","circledast","circledcirc","circleddash","CircleDot","circledR","circledS","CircleMinus","CirclePlus","CircleTimes","cirE","cire","cirfnint","cirmid","cirscir","ClockwiseContourIntegral","CloseCurlyDoubleQuote","CloseCurlyQuote","clubs","clubsuit","Colon","colon","Colone","colone","coloneq","comma","commat","comp","compfn","complement","complexes","cong","congdot","Congruent","Conint","conint","ContourIntegral","Copf","copf","coprod","Coproduct","COPY","copy","copysr","CounterClockwiseContourIntegral","crarr","Cross","cross","Cscr","cscr","csub","csube","csup","csupe","ctdot","cudarrl","cudarrr","cuepr","cuesc","cularr","cularrp","Cup","cup","cupbrcap","CupCap","cupcap","cupcup","cupdot","cupor","cups","curarr","curarrm","curlyeqprec","curlyeqsucc","curlyvee","curlywedge","curren","curvearrowleft","curvearrowright","cuvee","cuwed","cwconint","cwint","cylcty","Dagger","dagger","daleth","Darr","dArr","darr","dash","Dashv","dashv","dbkarow","dblac","Dcaron","dcaron","Dcy","dcy","DD","dd","ddagger","ddarr","DDotrahd","ddotseq","deg","Del","Delta","delta","demptyv","dfisht","Dfr","dfr","dHar","dharl","dharr","DiacriticalAcute","DiacriticalDot","DiacriticalDoubleAcute","DiacriticalGrave","DiacriticalTilde","diam","Diamond","diamond","diamondsuit","diams","die","DifferentialD","digamma","disin","div","divide","divideontimes","divonx","DJcy","djcy","dlcorn","dlcrop","dollar","Dopf","dopf","Dot","dot","DotDot","doteq","doteqdot","DotEqual","dotminus","dotplus","dotsquare","doublebarwedge","DoubleContourIntegral","DoubleDot","DoubleDownArrow","DoubleLeftArrow","DoubleLeftRightArrow","DoubleLeftTee","DoubleLongLeftArrow","DoubleLongLeftRightArrow","DoubleLongRightArrow","DoubleRightArrow","DoubleRightTee","DoubleUpArrow","DoubleUpDownArrow","DoubleVerticalBar","DownArrow","Downarrow","downarrow","DownArrowBar","DownArrowUpArrow","DownBreve","downdownarrows","downharpoonleft","downharpoonright","DownLeftRightVector","DownLeftTeeVector","DownLeftVector","DownLeftVectorBar","DownRightTeeVector","DownRightVector","DownRightVectorBar","DownTee","DownTeeArrow","drbkarow","drcorn","drcrop","Dscr","dscr","DScy","dscy","dsol","Dstrok","dstrok","dtdot","dtri","dtrif","duarr","duhar","dwangle","DZcy","dzcy","dzigrarr","Eacute","eacute","easter","Ecaron","ecaron","ecir","Ecirc","ecirc","ecolon","Ecy","ecy","eDDot","Edot","eDot","edot","efDot","Efr","efr","Egrave","egrave","egs","egsdot","Element","elinters","ell","els","elsdot","Emacr","emacr","empty","emptyset","EmptySmallSquare","emptyv","EmptyVerySmallSquare","emsp","emsp13","emsp14","ENG","eng","ensp","Eogon","eogon","Eopf","eopf","epar","eparsl","eplus","epsi","Epsilon","epsilon","epsiv","eqcirc","eqcolon","eqsim","eqslantgtr","eqslantless","Equal","equals","EqualTilde","equest","Equilibrium","equiv","equivDD","eqvparsl","erarr","erDot","Escr","escr","esdot","Esim","esim","Eta","eta","ETH","eth","Euml","euml","euro","excl","exist","Exists","expectation","ExponentialE","exponentiale","fallingdotseq","Fcy","fcy","female","ffilig","fflig","ffllig","Ffr","ffr","filig","FilledSmallSquare","FilledVerySmallSquare","fjlig","flat","fllig","fltns","fnof","Fopf","fopf","ForAll","forall","fork","forkv","Fouriertrf","fpartint","frac12","frac13","frac14","frac15","frac16","frac18","frac23","frac25","frac34","frac35","frac38","frac45","frac56","frac58","frac78","frasl","frown","Fscr","fscr","gacute","Gamma","gamma","Gammad","gammad","gap","Gbreve","gbreve","Gcedil","Gcirc","gcirc","Gcy","gcy","Gdot","gdot","gE","ge","gEl","gel","geq","geqq","geqslant","ges","gescc","gesdot","gesdoto","gesdotol","gesl","gesles","Gfr","gfr","Gg","gg","ggg","gimel","GJcy","gjcy","gl","gla","glE","glj","gnap","gnapprox","gnE","gne","gneq","gneqq","gnsim","Gopf","gopf","grave","GreaterEqual","GreaterEqualLess","GreaterFullEqual","GreaterGreater","GreaterLess","GreaterSlantEqual","GreaterTilde","Gscr","gscr","gsim","gsime","gsiml","Gt","GT","gtcc","gtcir","gtdot","gtlPar","gtquest","gtrapprox","gtrarr","gtrdot","gtreqless","gtreqqless","gtrless","gtrsim","gvertneqq","gvnE","Hacek","hairsp","half","hamilt","HARDcy","hardcy","hArr","harr","harrcir","harrw","Hat","hbar","Hcirc","hcirc","hearts","heartsuit","hellip","hercon","Hfr","hfr","HilbertSpace","hksearow","hkswarow","hoarr","homtht","hookleftarrow","hookrightarrow","Hopf","hopf","horbar","HorizontalLine","Hscr","hscr","hslash","Hstrok","hstrok","HumpDownHump","HumpEqual","hybull","hyphen","Iacute","iacute","Icirc","icirc","Icy","icy","Idot","IEcy","iecy","iexcl","iff","Ifr","ifr","Igrave","igrave","iiiint","iiint","iinfin","iiota","IJlig","ijlig","Im","Imacr","imacr","image","ImaginaryI","imagline","imagpart","imath","imof","imped","Implies","in","incare","infin","infintie","inodot","Int","int","intcal","integers","Integral","intercal","Intersection","intlarhk","intprod","InvisibleComma","InvisibleTimes","IOcy","iocy","Iogon","iogon","Iopf","iopf","Iota","iota","iprod","iquest","Iscr","iscr","isin","isindot","isinE","isins","isinsv","isinv","Itilde","itilde","Iukcy","iukcy","Iuml","iuml","Jcirc","jcirc","Jcy","jcy","Jfr","jfr","jmath","Jopf","jopf","Jscr","jscr","Jsercy","jsercy","Jukcy","jukcy","Kappa","kappa","kappav","Kcedil","kcedil","Kcy","kcy","Kfr","kfr","kgreen","KHcy","khcy","KJcy","kjcy","Kopf","kopf","Kscr","kscr","lAarr","Lacute","lacute","laemptyv","lagran","Lambda","lambda","Lang","langd","langle","lap","Laplacetrf","laquo","Larr","lArr","larr","larrb","larrbfs","larrfs","larrhk","larrlp","larrpl","larrsim","larrtl","lat","lAtail","latail","late","lates","lBarr","lbarr","lbbrk","lbrace","lbrack","lbrke","lbrksld","lbrkslu","Lcaron","lcaron","Lcedil","lcedil","lceil","lcub","Lcy","lcy","ldca","ldquo","ldquor","ldrdhar","ldrushar","ldsh","lE","le","LeftAngleBracket","LeftArrow","Leftarrow","leftarrow","LeftArrowBar","LeftArrowRightArrow","leftarrowtail","LeftCeiling","LeftDoubleBracket","LeftDownTeeVector","LeftDownVector","LeftDownVectorBar","LeftFloor","leftharpoondown","leftharpoonup","leftleftarrows","LeftRightArrow","Leftrightarrow","leftrightarrow","leftrightarrows","leftrightharpoons","leftrightsquigarrow","LeftRightVector","LeftTee","LeftTeeArrow","LeftTeeVector","leftthreetimes","LeftTriangle","LeftTriangleBar","LeftTriangleEqual","LeftUpDownVector","LeftUpTeeVector","LeftUpVector","LeftUpVectorBar","LeftVector","LeftVectorBar","lEg","leg","leq","leqq","leqslant","les","lescc","lesdot","lesdoto","lesdotor","lesg","lesges","lessapprox","lessdot","lesseqgtr","lesseqqgtr","LessEqualGreater","LessFullEqual","LessGreater","lessgtr","LessLess","lesssim","LessSlantEqual","LessTilde","lfisht","lfloor","Lfr","lfr","lg","lgE","lHar","lhard","lharu","lharul","lhblk","LJcy","ljcy","Ll","llarr","llcorner","Lleftarrow","llhard","lltri","Lmidot","lmidot","lmoust","lmoustache","lnap","lnapprox","lnE","lne","lneq","lneqq","lnsim","loang","loarr","lobrk","LongLeftArrow","Longleftarrow","longleftarrow","LongLeftRightArrow","Longleftrightarrow","longleftrightarrow","longmapsto","LongRightArrow","Longrightarrow","longrightarrow","looparrowleft","looparrowright","lopar","Lopf","lopf","loplus","lotimes","lowast","lowbar","LowerLeftArrow","LowerRightArrow","loz","lozenge","lozf","lpar","lparlt","lrarr","lrcorner","lrhar","lrhard","lrm","lrtri","lsaquo","Lscr","lscr","Lsh","lsh","lsim","lsime","lsimg","lsqb","lsquo","lsquor","Lstrok","lstrok","Lt","LT","ltcc","ltcir","ltdot","lthree","ltimes","ltlarr","ltquest","ltri","ltrie","ltrif","ltrPar","lurdshar","luruhar","lvertneqq","lvnE","macr","male","malt","maltese","mapsto","mapstodown","mapstoleft","mapstoup","marker","mcomma","Mcy","mcy","mdash","mDDot","measuredangle","MediumSpace","Mellintrf","Mfr","mfr","mho","micro","mid","midast","midcir","middot","minus","minusb","minusd","minusdu","MinusPlus","mlcp","mldr","mnplus","models","Mopf","mopf","mp","Mscr","mscr","mstpos","Mu","mu","multimap","mumap","nabla","Nacute","nacute","nang","nap","napE","napid","napos","napprox","natur","natural","naturals","nbsp","nbump","nbumpe","ncap","Ncaron","ncaron","Ncedil","ncedil","ncong","ncongdot","ncup","Ncy","ncy","ndash","nearhk","neArr","nearr","nearrow","nedot","NegativeMediumSpace","NegativeThickSpace","NegativeThinSpace","NegativeVeryThinSpace","nequiv","nesear","nesim","NestedGreaterGreater","NestedLessLess","NewLine","nexist","nexists","Nfr","nfr","ngE","nge","ngeq","ngeqq","ngeqslant","nges","nGg","ngsim","nGt","ngt","ngtr","nGtv","nhArr","nharr","nhpar","ni","nis","nisd","niv","NJcy","njcy","nlArr","nlarr","nldr","nlE","nle","nLeftarrow","nleftarrow","nLeftrightarrow","nleftrightarrow","nleq","nleqq","nleqslant","nles","nless","nLl","nlsim","nLt","nlt","nltri","nltrie","nLtv","nmid","NoBreak","NonBreakingSpace","Nopf","nopf","Not","not","NotCongruent","NotCupCap","NotDoubleVerticalBar","NotElement","NotEqual","NotEqualTilde","NotExists","NotGreater","NotGreaterEqual","NotGreaterFullEqual","NotGreaterGreater","NotGreaterLess","NotGreaterSlantEqual","NotGreaterTilde","NotHumpDownHump","NotHumpEqual","notin","notindot","notinE","notinva","notinvb","notinvc","NotLeftTriangle","NotLeftTriangleBar","NotLeftTriangleEqual","NotLess","NotLessEqual","NotLessGreater","NotLessLess","NotLessSlantEqual","NotLessTilde","NotNestedGreaterGreater","NotNestedLessLess","notni","notniva","notnivb","notnivc","NotPrecedes","NotPrecedesEqual","NotPrecedesSlantEqual","NotReverseElement","NotRightTriangle","NotRightTriangleBar","NotRightTriangleEqual","NotSquareSubset","NotSquareSubsetEqual","NotSquareSuperset","NotSquareSupersetEqual","NotSubset","NotSubsetEqual","NotSucceeds","NotSucceedsEqual","NotSucceedsSlantEqual","NotSucceedsTilde","NotSuperset","NotSupersetEqual","NotTilde","NotTildeEqual","NotTildeFullEqual","NotTildeTilde","NotVerticalBar","npar","nparallel","nparsl","npart","npolint","npr","nprcue","npre","nprec","npreceq","nrArr","nrarr","nrarrc","nrarrw","nRightarrow","nrightarrow","nrtri","nrtrie","nsc","nsccue","nsce","Nscr","nscr","nshortmid","nshortparallel","nsim","nsime","nsimeq","nsmid","nspar","nsqsube","nsqsupe","nsub","nsubE","nsube","nsubset","nsubseteq","nsubseteqq","nsucc","nsucceq","nsup","nsupE","nsupe","nsupset","nsupseteq","nsupseteqq","ntgl","Ntilde","ntilde","ntlg","ntriangleleft","ntrianglelefteq","ntriangleright","ntrianglerighteq","Nu","num","numero","numsp","nvap","nVDash","nVdash","nvDash","nvdash","nvge","nvgt","nvHarr","nvinfin","nvlArr","nvle","nvlt","nvltrie","nvrArr","nvrtrie","nvsim","nwarhk","nwArr","nwarr","nwarrow","nwnear","Oacute","oacute","oast","ocir","Ocirc","ocirc","Ocy","ocy","odash","Odblac","odblac","odiv","odot","odsold","OElig","oelig","ofcir","Ofr","ofr","ogon","Ograve","ograve","ogt","ohbar","ohm","oint","olarr","olcir","olcross","oline","olt","Omacr","omacr","Omega","omega","Omicron","omicron","omid","ominus","Oopf","oopf","opar","OpenCurlyDoubleQuote","OpenCurlyQuote","operp","oplus","Or","or","orarr","ord","order","orderof","ordf","ordm","origof","oror","orslope","orv","oS","Oscr","oscr","Oslash","oslash","osol","Otilde","otilde","Otimes","otimes","otimesas","Ouml","ouml","ovbar","OverBar","OverBrace","OverBracket","OverParenthesis","par","para","parallel","parsim","parsl","part","PartialD","Pcy","pcy","percnt","period","permil","perp","pertenk","Pfr","pfr","Phi","phi","phiv","phmmat","phone","Pi","pi","pitchfork","piv","planck","planckh","plankv","plus","plusacir","plusb","pluscir","plusdo","plusdu","pluse","PlusMinus","plusmn","plussim","plustwo","pm","Poincareplane","pointint","Popf","popf","pound","Pr","prap","prcue","prE","pre","prec","precapprox","preccurlyeq","Precedes","PrecedesEqual","PrecedesSlantEqual","PrecedesTilde","preceq","precnapprox","precneqq","precnsim","precsim","Prime","prime","primes","prnap","prnE","prnsim","prod","Product","profalar","profline","profsurf","prop","Proportion","Proportional","propto","prsim","prurel","Pscr","pscr","Psi","psi","puncsp","Qfr","qfr","qint","Qopf","qopf","qprime","Qscr","qscr","quaternions","quatint","quest","questeq","QUOT","rAarr","race","Racute","racute","radic","raemptyv","Rang","rang","rangd","rangle","raquo","Rarr","rArr","rarr","rarrap","rarrb","rarrbfs","rarrc","rarrfs","rarrhk","rarrlp","rarrpl","rarrsim","Rarrtl","rarrtl","rarrw","rAtail","ratail","ratio","rationals","RBarr","rBarr","rbarr","rbbrk","rbrace","rbrack","rbrke","rbrksld","rbrkslu","Rcaron","rcaron","Rcedil","rcedil","rceil","rcub","Rcy","rcy","rdca","rdldhar","rdquo","rdquor","rdsh","Re","real","realine","realpart","reals","rect","REG","reg","ReverseElement","ReverseEquilibrium","ReverseUpEquilibrium","rfisht","rfloor","Rfr","rfr","rHar","rhard","rharu","rharul","Rho","rho","rhov","RightAngleBracket","RightArrow","Rightarrow","rightarrow","RightArrowBar","RightArrowLeftArrow","rightarrowtail","RightCeiling","RightDoubleBracket","RightDownTeeVector","RightDownVector","RightDownVectorBar","RightFloor","rightharpoondown","rightharpoonup","rightleftarrows","rightleftharpoons","rightrightarrows","rightsquigarrow","RightTee","RightTeeArrow","RightTeeVector","rightthreetimes","RightTriangle","RightTriangleBar","RightTriangleEqual","RightUpDownVector","RightUpTeeVector","RightUpVector","RightUpVectorBar","RightVector","RightVectorBar","ring","risingdotseq","rlarr","rlhar","rlm","rmoust","rmoustache","rnmid","roang","roarr","robrk","ropar","Ropf","ropf","roplus","rotimes","RoundImplies","rpar","rpargt","rppolint","rrarr","Rrightarrow","rsaquo","Rscr","rscr","Rsh","rsh","rsqb","rsquo","rsquor","rthree","rtimes","rtri","rtrie","rtrif","rtriltri","RuleDelayed","ruluhar","Sacute","sacute","sbquo","Sc","sc","scap","Scaron","scaron","sccue","scE","sce","Scedil","scedil","Scirc","scirc","scnap","scnE","scnsim","scpolint","scsim","Scy","scy","sdot","sdotb","sdote","searhk","seArr","searr","searrow","sect","semi","seswar","setminus","setmn","sext","Sfr","sfr","sfrown","sharp","SHCHcy","shchcy","SHcy","shcy","ShortDownArrow","ShortLeftArrow","shortmid","shortparallel","ShortRightArrow","ShortUpArrow","shy","Sigma","sigma","sigmaf","sigmav","sim","simdot","sime","simeq","simg","simgE","siml","simlE","simne","simplus","simrarr","slarr","SmallCircle","smallsetminus","smashp","smeparsl","smid","smile","smt","smte","smtes","SOFTcy","softcy","sol","solb","solbar","Sopf","sopf","spades","spadesuit","spar","sqcap","sqcaps","sqcup","sqcups","Sqrt","sqsub","sqsube","sqsubset","sqsubseteq","sqsup","sqsupe","sqsupset","sqsupseteq","squ","Square","square","SquareIntersection","SquareSubset","SquareSubsetEqual","SquareSuperset","SquareSupersetEqual","SquareUnion","squarf","squf","srarr","Sscr","sscr","ssetmn","ssmile","sstarf","Star","star","starf","straightepsilon","straightphi","strns","Sub","sub","subdot","subE","sube","subedot","submult","subnE","subne","subplus","subrarr","Subset","subseteq","subseteqq","SubsetEqual","subsetneq","subsetneqq","subsim","subsub","subsup","succ","succapprox","succcurlyeq","Succeeds","SucceedsEqual","SucceedsSlantEqual","SucceedsTilde","succeq","succnapprox","succneqq","succnsim","succsim","SuchThat","Sum","sum","sung","Sup","sup","sup1","sup2","sup3","supdot","supdsub","supE","supe","supedot","Superset","SupersetEqual","suphsol","suphsub","suplarr","supmult","supnE","supne","supplus","Supset","supset","supseteq","supseteqq","supsetneq","supsetneqq","supsim","supsub","supsup","swarhk","swArr","swarr","swarrow","swnwar","szlig","Tab","Tau","tau","tbrk","Tcaron","tcaron","Tcedil","tcedil","Tcy","tcy","tdot","telrec","Tfr","tfr","there4","Therefore","therefore","Theta","theta","thetasym","thetav","thickapprox","thicksim","ThickSpace","thinsp","ThinSpace","thkap","thksim","THORN","thorn","Tilde","tilde","TildeEqual","TildeFullEqual","TildeTilde","times","timesb","timesbar","timesd","tint","toea","top","topbot","topcir","Topf","topf","topfork","tosa","tprime","TRADE","trade","triangle","triangledown","triangleleft","trianglelefteq","triangleq","triangleright","trianglerighteq","tridot","trie","triminus","TripleDot","triplus","trisb","tritime","trpezium","Tscr","tscr","TScy","tscy","TSHcy","tshcy","Tstrok","tstrok","twixt","twoheadleftarrow","twoheadrightarrow","Uacute","uacute","Uarr","uArr","uarr","Uarrocir","Ubrcy","ubrcy","Ubreve","ubreve","Ucirc","ucirc","Ucy","ucy","udarr","Udblac","udblac","udhar","ufisht","Ufr","ufr","Ugrave","ugrave","uHar","uharl","uharr","uhblk","ulcorn","ulcorner","ulcrop","ultri","Umacr","umacr","uml","UnderBar","UnderBrace","UnderBracket","UnderParenthesis","Union","UnionPlus","Uogon","uogon","Uopf","uopf","UpArrow","Uparrow","uparrow","UpArrowBar","UpArrowDownArrow","UpDownArrow","Updownarrow","updownarrow","UpEquilibrium","upharpoonleft","upharpoonright","uplus","UpperLeftArrow","UpperRightArrow","Upsi","upsi","upsih","Upsilon","upsilon","UpTee","UpTeeArrow","upuparrows","urcorn","urcorner","urcrop","Uring","uring","urtri","Uscr","uscr","utdot","Utilde","utilde","utri","utrif","uuarr","Uuml","uuml","uwangle","vangrt","varepsilon","varkappa","varnothing","varphi","varpi","varpropto","vArr","varr","varrho","varsigma","varsubsetneq","varsubsetneqq","varsupsetneq","varsupsetneqq","vartheta","vartriangleleft","vartriangleright","Vbar","vBar","vBarv","Vcy","vcy","VDash","Vdash","vDash","vdash","Vdashl","Vee","vee","veebar","veeeq","vellip","Verbar","verbar","Vert","vert","VerticalBar","VerticalLine","VerticalSeparator","VerticalTilde","VeryThinSpace","Vfr","vfr","vltri","vnsub","vnsup","Vopf","vopf","vprop","vrtri","Vscr","vscr","vsubnE","vsubne","vsupnE","vsupne","Vvdash","vzigzag","Wcirc","wcirc","wedbar","Wedge","wedge","wedgeq","weierp","Wfr","wfr","Wopf","wopf","wp","wr","wreath","Wscr","wscr","xcap","xcirc","xcup","xdtri","Xfr","xfr","xhArr","xharr","Xi","xi","xlArr","xlarr","xmap","xnis","xodot","Xopf","xopf","xoplus","xotime","xrArr","xrarr","Xscr","xscr","xsqcup","xuplus","xutri","xvee","xwedge","Yacute","yacute","YAcy","yacy","Ycirc","ycirc","Ycy","ycy","yen","Yfr","yfr","YIcy","yicy","Yopf","yopf","Yscr","yscr","YUcy","yucy","Yuml","yuml","Zacute","zacute","Zcaron","zcaron","Zcy","zcy","Zdot","zdot","zeetrf","ZeroWidthSpace","Zeta","zeta","Zfr","zfr","ZHcy","zhcy","zigrarr","Zopf","zopf","Zscr","zscr","zwj","zwnj","qName","uri","closed","currentNSMap","localNSMap","attributeNames","source","fromCharCode","endDTD","addValue","setTagName","lastIndexOf","offset","getLocalName","abs","long","years","one","months","weeks","days","hours","minutes","seconds","narrow","short","rQ","iS","iD","chown","iT","iR","lchmod","iI","lchown","iO","link","iA","i_","mkdtemp","iL","readFile","ik","realpath","iM","iF","ij","iq","truncate","iG","iH","iX","iz","iY","iW","iK","iJ","groups","getgroups","rZ","i1","iZ","i0","i3","_ISEXE_TEST_PLATFORM_","i2","isexe","i4","posix","i5","i6","i8","i9","i7","pathEnv","pathExtExe","oe","ot","r4","r6","OSTYPE","r9","TESTING_WINDOWS","oi","oo","oa","os","nn","no","openSync","readSync","closeSync","ol","forceShell","comspec","verifyENOENT","verifyENOENTSync","notFoundError","_parse","_enoent","oc","getOwnPropertyDescriptor","op","od","getPrototypeOf","of","oh","om","og","ov","WeakMap","oE","displayName","ignoreNonConfigurable","Reflect","ownKeys","callCount","oy","ox","ob","ow","number","action","description","standard","forced","oD","oN","signals","rC","supported","oT","oR","oI","oO","errorCode","signalDescription","Boolean","originalMessage","shortMessage","oC","o_","oL","o$","reallyExit","pid","oP","oU","oM","oF","__signal_exit_emitter__","count","emitted","infinite","setMaxListeners","oj","oG","oB","oz","oV","nl","equal","oH","alwaysLast","unload","oq","oY","oX","oW","oJ","oZ","unref","forceKillAfterTimeout","oQ","SIGTERM","isFinite","o1","killSignal","cleanup","detached","o5","o6","createWriteStream","pipeStdout","pipeStderr","pipeAll","r_","promisify","rL","PassThrough","array","objectMode","setEncoding","nc","buffer","MaxBufferError","nm","readable","isEmpty","ae","at","inputFile","an","createReadStream","aa","as","au","ah","aE","rT","isBuffer","ay","aw","templates","expressions","template","ab","ax","r$","debuglog","enabled","aS","padStart","aD","getHours","getMinutes","getSeconds","getMilliseconds","verbose","aT","preferLocal","localDir","stripFinalNewline","windowsHide","aO","aA","rP","npm_package_json","npm_config_user_agent","XDG_CONFIG_HOME","mkdirSync","lastUpdateCheck","getTime","updateCheckInterval","distTag","alwaysRun","nE","padEnd","isTTY","shouldNotifyInNpmScript","aL","aP","ak","aU","aF","aj","aB","aq","aH","aY","aK","aJ","aQ","aZ","a0","a2","a4","a6","a8","se","st","si","so","sa","ss","sl","su","sd","sm","sg","sv","sE","release","sy","nq","nY","sk","sF","sq","sB","nW","sH","n1","nQ","RetryHelper","maxAttempts","minSeconds","maxSeconds","execute","getSleepAmount","sleep","sV","httpStatusCode","new","HTTPError","sX","sz","nK","authorization","statusMessage","extract7z","nV","extractXar","extractZip","cacheFile","findAllVersions","getManifestFromRepo","tree","accept","findFromManifest","isExplicitVersion","evaluateVersions","retryAsPromised","TimeoutError","previous","_getKeyIndexFromMatchingKey","_getKeyIndexForMany","_getKeyIndexForSingle","rk","llvm","clangtidy","clangformat","ninja","cmake","conan","meson","kcov","task","doxygen","gcc","mingw","nala","s3","fs","mkdirAsync","statAsync","s2","s4","s5","s6","s8","s9","s7","__TESTING_MKDIRP_PLATFORM__","root","__TESTING_MKDIRP_NODE_VERSION__","lr","ln","li","lo","mkdirpSync","mkdirpNative","mkdirpNativeSync","mkdirpManual","mkdirpManualSync","native","nativeSync","manual","manualSync","useNative","useNativeSync","lc","DOMImplementation","ia","XMLSerializer","DOMParser","lh","lm","type","TYPE","castTo","castAs","fromXml","fromXmlElement","TAG_NAMES","toXml","indentString","lv","newlineString","dataColumns","asBigInt","BigInt","asNumber","ly","lw","replaceAll","lb","CHILD_TAG_NAMES","lx","popValue","shiftValue","childFromXmlElement","lS","lD","lN","XML_DECLARATION","XML_DOCTYPE","xmlDeclaration","xmlDoctype","valueCastTo","valueCastAs","indentRoot","lT","hdiutil","attach","_runAttach","_argsAttach","eject","ejectSync","_createEjects","devices","attachSync","_runAttachSync","_runEject","_argsEject","_runEjectSync","readonly","nobrowse","_fileArg","_parseDevices","devEntry","potentiallyMountable","contentHint","unmappedContentHint","volumeKind","mountPoint","_findRootDevice","off","lR","DIRECTORY","FILE","SYMLINK","RESOURCE_FORK","O_WRONLY","O_SYMLINK","l_","lL","_triggering","_triggered","_extracted","archive","pathRaw","sizeComp","uname","gname","atime","mtime","_readData","readData","_readRsrc","readRsrc","_readSymlink","readSymlink","hasNamedVolume","hasNamedVolumes","volumeName","volumePath","stream","_beginExtract","_stream","_extract","trigger","setAttributes","ignorePermissions","ignoreTimes","_errorExtractPathExists","_errorNoResourceFork","afterReadSetAttributesRemove","_extractFile","_extractResourceFork","_extractDirectory","_extractSymlink","_extractStreamToFile","resourceForkAsFile","afterReadSetAttributes","symlinkAsFile","_streamFile","_streamResourceFork","_streamDirectory","_streamSymlink","Readable","l$","FILE_EXTENSIONS","HAS_NAMED_VOLUMES","Entry","_reading","_afterReadSetAttributes","fileExtensions","entry","_read","_afterReadSetAttributesTrigger","lP","lk","lU","rsrcPathRaw","rsrcPath","mounterMac","each","ProgramFiles","lV","win32","win64","x86_64","lz","lY","globalThis","DOMException","reason","vcpkg","bazel","opencppcoverage","choco","brew","powershell","ccache","sccache","graphviz","ClangFormat","msvc","vcvarsall","make","sevenzip","argv"],"sources":["../../","../../node_modules/ci-info/index.js","../../node_modules/ci-info/vendors.json","../../packages/ci-log/src/index.ts","../../node_modules/@actions/core/lib/core.js","../../node_modules/@actions/core/src/core.ts","../../node_modules/@actions/core/lib/command.js","../../node_modules/@actions/core/src/command.ts","../../node_modules/@actions/core/lib/utils.js","../../node_modules/@actions/core/src/utils.ts","../../node_modules/@actions/core/lib/file-command.js","../../node_modules/@actions/core/src/file-command.ts","../../node_modules/uuid/dist/esm-node/v4.js","../../node_modules/uuid/dist/esm-node/rng.js","../../node_modules/uuid/dist/esm-node/stringify.js","../../node_modules/uuid/dist/esm-node/validate.js","../../node_modules/uuid/dist/esm-node/regex.js","../../node_modules/@actions/core/lib/oidc-utils.js","../../node_modules/@actions/core/src/oidc-utils.ts","../../node_modules/@actions/http-client/lib/index.js","../../node_modules/@actions/http-client/src/index.ts","../../node_modules/@actions/http-client/lib/proxy.js","../../node_modules/@actions/http-client/src/proxy.ts","../../node_modules/tunnel/index.js","../../node_modules/tunnel/lib/tunnel.js","../../node_modules/@actions/http-client/lib/auth.js","../../node_modules/@actions/http-client/src/auth.ts","../../node_modules/@actions/core/lib/summary.js","../../node_modules/@actions/core/src/summary.ts","../../node_modules/@actions/core/lib/path-utils.js","../../node_modules/@actions/core/src/path-utils.ts","../../node_modules/numerous/lib/numerous.js","../../node_modules/time-delta/lib/time-delta.js","../../node_modules/numerous/index.js","../../node_modules/is-node/index.js","../../node_modules/isexe/windows.js","../../node_modules/isexe/mode.js","../../node_modules/signal-exit/signals.js","../../node_modules/semver/index.js","../../node_modules/semver/internal/re.js","../../node_modules/semver/internal/constants.js","../../node_modules/semver/internal/debug.js","../../node_modules/semver/classes/semver.js","../../node_modules/semver/internal/parse-options.js","../../node_modules/semver/internal/identifiers.js","../../node_modules/semver/functions/parse.js","../../node_modules/semver/functions/valid.js","../../node_modules/semver/functions/clean.js","../../node_modules/semver/functions/inc.js","../../node_modules/semver/functions/diff.js","../../node_modules/semver/functions/major.js","../../node_modules/semver/functions/minor.js","../../node_modules/semver/functions/patch.js","../../node_modules/semver/functions/prerelease.js","../../node_modules/semver/functions/compare.js","../../node_modules/semver/functions/rcompare.js","../../node_modules/semver/functions/compare-loose.js","../../node_modules/semver/functions/compare-build.js","../../node_modules/semver/functions/sort.js","../../node_modules/semver/functions/rsort.js","../../node_modules/semver/functions/gt.js","../../node_modules/semver/functions/lt.js","../../node_modules/semver/functions/eq.js","../../node_modules/semver/functions/neq.js","../../node_modules/semver/functions/gte.js","../../node_modules/semver/functions/lte.js","../../node_modules/semver/functions/cmp.js","../../node_modules/semver/functions/coerce.js","../../node_modules/semver/classes/comparator.js","../../node_modules/semver/classes/range.js","../../node_modules/semver/node_modules/lru-cache/index.js","../../node_modules/yallist/yallist.js","../../node_modules/yallist/iterator.js","../../node_modules/semver/functions/satisfies.js","../../node_modules/semver/ranges/to-comparators.js","../../node_modules/semver/ranges/max-satisfying.js","../../node_modules/semver/ranges/min-satisfying.js","../../node_modules/semver/ranges/min-version.js","../../node_modules/semver/ranges/valid.js","../../node_modules/semver/ranges/outside.js","../../node_modules/semver/ranges/gtr.js","../../node_modules/semver/ranges/ltr.js","../../node_modules/semver/ranges/intersects.js","../../node_modules/semver/ranges/simplify.js","../../node_modules/semver/ranges/subset.js","../../node_modules/escape-quotes/node_modules/escape-string-regexp/index.js","../../node_modules/path-exists/index.js","../../node_modules/patha/dist/index.node.mjs","../../node_modules/patha/src/name.ts","../../node_modules/patha/src/normalize-trim.ts","../../node_modules/patha/src/add-exe-ext.ts","../../node_modules/patha/src/add-name-prefix.ts","../../node_modules/patha/src/add-name-suffix.ts","../../node_modules/patha/src/add-sh-ext.ts","../../node_modules/patha/src/add-sh-relative-prefix.ts","../../node_modules/patha/src/remove-ext.ts","../../node_modules/patha/src/replace-ext.ts","../../node_modules/patha/src/is-path-inside.ts","../../node_modules/escape-string-regexp/index.js","../../node_modules/replace-ext/index.js","../../node_modules/@actions/io/lib/io.js","../../node_modules/@actions/io/src/io.ts","../../node_modules/@actions/io/lib/io-util.js","../../node_modules/@actions/io/src/io-util.ts","../../node_modules/@actions/tool-cache/lib/manifest.js","../../node_modules/@actions/tool-cache/src/manifest.ts","../../node_modules/@actions/tool-cache/node_modules/semver/semver.js","../../node_modules/@actions/tool-cache/node_modules/uuid/v4.js","../../node_modules/@actions/tool-cache/node_modules/uuid/lib/rng.js","../../node_modules/@actions/tool-cache/node_modules/uuid/lib/bytesToUuid.js","../../node_modules/@actions/exec/lib/exec.js","../../node_modules/@actions/exec/src/exec.ts","../../node_modules/@actions/exec/lib/toolrunner.js","../../node_modules/@actions/exec/src/toolrunner.ts","../../node_modules/@parcel/runtime-js/lib/runtime-fd61ca5b164aabc9.js","../../node_modules/@xmldom/xmldom/lib/dom-parser.js","../../node_modules/@xmldom/xmldom/lib/conventions.js","../../node_modules/@xmldom/xmldom/lib/dom.js","../../node_modules/@xmldom/xmldom/lib/entities.js","../../node_modules/@xmldom/xmldom/lib/sax.js","../../src/main.ts","../../node_modules/numerous/locales/en.js","../../node_modules/time-delta/index.js","../../node_modules/time-delta/locales/en.js","../../packages/untildify-user/src/index.ts","../../node_modules/admina/src/index.mts","../../node_modules/admina/dist/root.mjs","../../node_modules/admina/src/root.mts","../../node_modules/which/lib/index.js","../../node_modules/which/node_modules/isexe/dist/mjs/index.js","../../node_modules/which/node_modules/isexe/src/index.ts","../../node_modules/which/node_modules/isexe/dist/mjs/posix.js","../../node_modules/which/node_modules/isexe/src/posix.ts","../../src/utils/compat/fs/promises.ts","../../node_modules/which/node_modules/isexe/dist/mjs/win32.js","../../node_modules/which/node_modules/isexe/src/win32.ts","../../node_modules/which/node_modules/isexe/src/options.ts","../../node_modules/execa/index.js","../../node_modules/cross-spawn/index.js","../../node_modules/cross-spawn/lib/parse.js","../../node_modules/cross-spawn/lib/util/resolveCommand.js","../../node_modules/cross-spawn/node_modules/which/which.js","../../node_modules/isexe/index.js","../../node_modules/path-key/index.js","../../node_modules/cross-spawn/lib/util/escape.js","../../node_modules/cross-spawn/lib/util/readShebang.js","../../node_modules/shebang-command/index.js","../../node_modules/shebang-regex/index.js","../../node_modules/cross-spawn/lib/enoent.js","../../node_modules/strip-final-newline/index.js","../../node_modules/npm-run-path/index.js","../../node_modules/npm-run-path/node_modules/path-key/index.js","../../node_modules/onetime/index.js","../../node_modules/mimic-fn/index.js","../../node_modules/execa/lib/error.js","../../node_modules/human-signals/build/src/main.js","../../node_modules/human-signals/build/src/realtime.js","../../node_modules/human-signals/build/src/signals.js","../../node_modules/human-signals/build/src/core.js","../../node_modules/execa/lib/stdio.js","../../node_modules/execa/lib/kill.js","../../node_modules/signal-exit/index.js","../../node_modules/execa/lib/pipe.js","../../node_modules/is-stream/index.js","../../node_modules/execa/lib/stream.js","../../node_modules/get-stream/index.js","../../node_modules/get-stream/buffer-stream.js","../../node_modules/merge-stream/index.js","../../node_modules/execa/lib/promise.js","../../node_modules/execa/lib/command.js","../../node_modules/execa/lib/verbose.js","../../node_modules/admina/dist/admin.mjs","../../node_modules/admina/src/admin.mts","../../node_modules/admina/dist/is-admin.mjs","../../node_modules/admina/src/is-admin.mts","../../node_modules/admina/dist/user-access.mjs","../../node_modules/admina/src/user-access.mts","../../src/check-updates.ts","../../node_modules/simple-update-notifier/build/index.js","../../package-version.json","../../src/cli-options.ts","../../node_modules/mri/lib/index.mjs","../../src/tool.ts","../../src/bazel/bazel.ts","../../src/utils/setup/setupAptPack.ts","../../src/utils/env/addEnv.ts","../../packages/exec-powershell/src/index.ts","../../packages/exec-powershell/node_modules/execa/index.js","../../packages/exec-powershell/node_modules/execa/lib/error.js","../../packages/exec-powershell/node_modules/execa/lib/stdio.js","../../packages/exec-powershell/node_modules/execa/lib/kill.js","../../packages/exec-powershell/node_modules/execa/lib/pipe.js","../../packages/exec-powershell/node_modules/execa/lib/stream.js","../../packages/exec-powershell/node_modules/execa/lib/promise.js","../../packages/exec-powershell/node_modules/execa/lib/command.js","../../packages/exec-powershell/node_modules/execa/lib/verbose.js","../../node_modules/escape-path-with-spaces/index.js","../../node_modules/escape-quotes/lib/escape-quotes.js","../../src/utils/setup/setupBrewPack.ts","../../src/brew/brew.ts","../../src/utils/setup/setupChocoPack.ts","../../src/chocolatey/chocolatey.ts","../../src/utils/env/isArch.ts","../../src/utils/env/hasDnf.ts","../../src/utils/setup/setupDnfPack.ts","../../src/utils/env/isUbuntu.ts","../../src/ccache/ccache.ts","../../src/utils/setup/setupPacmanPack.ts","../../src/cmake/cmake.ts","../../node_modules/@actions/tool-cache/lib/tool-cache.js","../../node_modules/@actions/tool-cache/src/tool-cache.ts","../../node_modules/@actions/tool-cache/lib/retry-helper.js","../../node_modules/@actions/tool-cache/src/retry-helper.ts","../../src/utils/setup/setupBin.ts","../../node_modules/retry-as-promised/dist/index.js","../../src/utils/setup/extract.ts","../../src/sevenzip/sevenzip.ts","../../src/conan/conan.ts","../../src/utils/setup/setupPipPack.ts","../../src/python/python.ts","../../node_modules/micro-memoize/dist/micro-memoize.esm.js","../../node_modules/micro-memoize/src/utils.ts","../../node_modules/micro-memoize/src/Cache.ts","../../node_modules/micro-memoize/src/index.ts","../../src/utils/setup/version.ts","../../node_modules/is-url-online/dist/index.mjs","../../src/utils/std/index.ts","../../src/versions/default_versions.ts","../../src/versions/versions.ts","../../src/utils/env/ubuntu_version.ts","../../node_modules/ubuntu-version/index.js","../../node_modules/mkdirp/dist/mjs/index.js","../../node_modules/mkdirp/src/index.ts","../../node_modules/mkdirp/dist/mjs/mkdirp-manual.js","../../node_modules/mkdirp/src/mkdirp-manual.ts","../../node_modules/mkdirp/dist/mjs/opts-arg.js","../../node_modules/mkdirp/src/opts-arg.ts","../../node_modules/mkdirp/dist/mjs/mkdirp-native.js","../../node_modules/mkdirp/src/mkdirp-native.ts","../../node_modules/mkdirp/dist/mjs/find-made.js","../../node_modules/mkdirp/src/find-made.ts","../../node_modules/mkdirp/dist/mjs/path-arg.js","../../node_modules/mkdirp/src/path-arg.ts","../../node_modules/mkdirp/dist/mjs/use-native.js","../../node_modules/mkdirp/src/use-native.ts","../../src/cppcheck/cppcheck.ts","../../src/doxygen/doxygen.ts","../../src/graphviz/graphviz.ts","../../src/utils/env/macos_version.ts","../../node_modules/macos-release/index.js","../../src/utils/setup/setupDmg.ts","../../node_modules/@shockpkg/archive-files/esm/archive/hdi.mjs","../../node_modules/@shockpkg/archive-files/src/archive/hdi.ts","../../node_modules/@shockpkg/hdi-mac/esm/mounter.mjs","../../node_modules/@shockpkg/hdi-mac/src/mounter.ts","../../node_modules/@shockpkg/plist-dom/esm/plist.mjs","../../node_modules/@shockpkg/plist-dom/src/plist.ts","../../node_modules/@shockpkg/plist-dom/esm/options.mjs","../../node_modules/@shockpkg/plist-dom/src/options.ts","../../node_modules/@shockpkg/plist-dom/esm/util.mjs","../../node_modules/@shockpkg/plist-dom/src/util.ts","../../node_modules/@xmldom/xmldom/lib/index.js","../../node_modules/@shockpkg/plist-dom/esm/value/dict.mjs","../../node_modules/@shockpkg/plist-dom/src/value/dict.ts","../../node_modules/@shockpkg/plist-dom/esm/value.mjs","../../node_modules/@shockpkg/plist-dom/src/value.ts","../../node_modules/@shockpkg/plist-dom/esm/value/array.mjs","../../node_modules/@shockpkg/plist-dom/src/value/array.ts","../../node_modules/@shockpkg/plist-dom/esm/value/boolean.mjs","../../node_modules/@shockpkg/plist-dom/src/value/boolean.ts","../../node_modules/@shockpkg/plist-dom/esm/value/data.mjs","../../node_modules/@shockpkg/plist-dom/src/value/data.ts","../../node_modules/@shockpkg/plist-dom/esm/value/integer.mjs","../../node_modules/@shockpkg/plist-dom/src/value/integer.ts","../../node_modules/@shockpkg/plist-dom/esm/value/real.mjs","../../node_modules/@shockpkg/plist-dom/src/value/real.ts","../../node_modules/@shockpkg/plist-dom/esm/value/string.mjs","../../node_modules/@shockpkg/plist-dom/src/value/string.ts","../../node_modules/@shockpkg/archive-files/esm/archive.mjs","../../node_modules/@shockpkg/archive-files/src/archive.ts","../../node_modules/@shockpkg/archive-files/esm/types.mjs","../../node_modules/@shockpkg/archive-files/src/types.ts","../../node_modules/@shockpkg/archive-files/esm/util.mjs","../../node_modules/@shockpkg/archive-files/src/util.ts","../../src/gcc/gcc.ts","../../src/macos-sdk/macos-sdk.ts","../../src/gcovr/gcovr.ts","../../src/kcov/kcov.ts","../../src/ninja/ninja.ts","../../src/llvm/llvm.ts","../../src/llvm/llvm_installer.ts","../../src/installTool.ts","../../src/vcvarsall/vcvarsall.ts","../../node_modules/msvc-dev-cmd/lib.js","../../node_modules/p-timeout/index.js","../../src/llvm/llvm_url.ts","../../src/make/make.ts","../../src/meson/meson.ts","../../src/msvc/msvc.ts","../../src/nala/nala.ts","../../src/opencppcoverage/opencppcoverage.ts","../../src/powershell/powershell.ts","../../src/sccache/sccache.ts","../../src/task/task.ts","../../src/vcpkg/vcpkg.ts","../../src/compilers.ts"],"sourcesContent":["#!/usr/bin/env node\nvar $d7DIX$os = require(\"os\");\nvar $d7DIX$path = require(\"path\");\nvar $d7DIX$fs = require(\"fs\");\nvar $d7DIX$crypto = require(\"crypto\");\nvar $d7DIX$http = require(\"http\");\nvar $d7DIX$https = require(\"https\");\nrequire(\"net\");\nvar $d7DIX$tls = require(\"tls\");\nvar $d7DIX$events = require(\"events\");\nvar $d7DIX$assert = require(\"assert\");\nvar $d7DIX$util = require(\"util\");\nvar $d7DIX$nodefs = require(\"node:fs\");\nvar $d7DIX$child_process = require(\"child_process\");\nvar $d7DIX$string_decoder = require(\"string_decoder\");\nvar $d7DIX$timers = require(\"timers\");\nvar $d7DIX$nodebuffer = require(\"node:buffer\");\nvar $d7DIX$nodepath = require(\"node:path\");\nvar $d7DIX$nodechild_process = require(\"node:child_process\");\nvar $d7DIX$nodeprocess = require(\"node:process\");\nvar $d7DIX$nodeurl = require(\"node:url\");\nvar $d7DIX$nodeos = require(\"node:os\");\nvar $d7DIX$buffer = require(\"buffer\");\nvar $d7DIX$stream = require(\"stream\");\nvar $d7DIX$nodeutil = require(\"node:util\");\nvar $d7DIX$process = require(\"process\");\nvar $d7DIX$url = require(\"url\");\nvar $d7DIX$nodestream = require(\"node:stream\");\nvar $d7DIX$nodestreampromises = require(\"node:stream/promises\");\nvar $d7DIX$console = require(\"console\");\n\n\nfunction $parcel$export(e, n, v, s) {\n Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});\n}\n\nfunction $parcel$interopDefault(a) {\n return a && a.__esModule ? a.default : a;\n}\n\n var $parcel$global = globalThis;\n \nvar $parcel$modules = {};\nvar $parcel$inits = {};\n\nvar parcelRequire = $parcel$global[\"parcelRequire810d\"];\n\nif (parcelRequire == null) {\n parcelRequire = function(id) {\n if (id in $parcel$modules) {\n return $parcel$modules[id].exports;\n }\n if (id in $parcel$inits) {\n var init = $parcel$inits[id];\n delete $parcel$inits[id];\n var module = {id: id, exports: {}};\n $parcel$modules[id] = module;\n init.call(module.exports, module, module.exports);\n return module.exports;\n }\n var err = new Error(\"Cannot find module '\" + id + \"'\");\n err.code = 'MODULE_NOT_FOUND';\n throw err;\n };\n\n parcelRequire.register = function register(id, init) {\n $parcel$inits[id] = init;\n };\n\n $parcel$global[\"parcelRequire810d\"] = parcelRequire;\n}\n\nvar parcelRegister = parcelRequire.register;\nparcelRegister(\"52cQ1\", function(module, exports) {\n\"use strict\";\n\nvar $jgqtC = parcelRequire(\"jgqtC\");\nconst $3aa719050363449a$var$env = process.env;\n// Used for testing only\nObject.defineProperty(module.exports, \"_vendors\", {\n value: $jgqtC.map(function(v) {\n return v.constant;\n })\n});\nmodule.exports.name = null;\nmodule.exports.isPR = null;\n$jgqtC.forEach(function(vendor) {\n const envs = Array.isArray(vendor.env) ? vendor.env : [\n vendor.env\n ];\n const isCI = envs.every(function(obj) {\n return $3aa719050363449a$var$checkEnv(obj);\n });\n module.exports[vendor.constant] = isCI;\n if (!isCI) return;\n module.exports.name = vendor.name;\n switch(typeof vendor.pr){\n case \"string\":\n // \"pr\": \"CIRRUS_PR\"\n module.exports.isPR = !!$3aa719050363449a$var$env[vendor.pr];\n break;\n case \"object\":\n if (\"env\" in vendor.pr) // \"pr\": { \"env\": \"BUILDKITE_PULL_REQUEST\", \"ne\": \"false\" }\n module.exports.isPR = vendor.pr.env in $3aa719050363449a$var$env && $3aa719050363449a$var$env[vendor.pr.env] !== vendor.pr.ne;\n else if (\"any\" in vendor.pr) // \"pr\": { \"any\": [\"ghprbPullId\", \"CHANGE_ID\"] }\n module.exports.isPR = vendor.pr.any.some(function(key) {\n return !!$3aa719050363449a$var$env[key];\n });\n else // \"pr\": { \"DRONE_BUILD_EVENT\": \"pull_request\" }\n module.exports.isPR = $3aa719050363449a$var$checkEnv(vendor.pr);\n break;\n default:\n // PR detection not supported for this vendor\n module.exports.isPR = null;\n }\n});\nmodule.exports.isCI = !!($3aa719050363449a$var$env.CI !== \"false\" && // Bypass all checks if CI env is explicitly set to 'false'\n($3aa719050363449a$var$env.BUILD_ID || // Jenkins, Cloudbees\n$3aa719050363449a$var$env.BUILD_NUMBER || // Jenkins, TeamCity\n$3aa719050363449a$var$env.CI || // Travis CI, CircleCI, Cirrus CI, Gitlab CI, Appveyor, CodeShip, dsari\n$3aa719050363449a$var$env.CI_APP_ID || // Appflow\n$3aa719050363449a$var$env.CI_BUILD_ID || // Appflow\n$3aa719050363449a$var$env.CI_BUILD_NUMBER || // Appflow\n$3aa719050363449a$var$env.CI_NAME || // Codeship and others\n$3aa719050363449a$var$env.CONTINUOUS_INTEGRATION || // Travis CI, Cirrus CI\n$3aa719050363449a$var$env.RUN_ID || // TaskCluster, dsari\nmodule.exports.name || false));\nfunction $3aa719050363449a$var$checkEnv(obj) {\n // \"env\": \"CIRRUS\"\n if (typeof obj === \"string\") return !!$3aa719050363449a$var$env[obj];\n // \"env\": { \"env\": \"NODE\", \"includes\": \"/app/.heroku/node/bin/node\" }\n if (\"env\" in obj) // Currently there are no other types, uncomment when there are\n // if ('includes' in obj) {\n return $3aa719050363449a$var$env[obj.env] && $3aa719050363449a$var$env[obj.env].includes(obj.includes);\n if (\"any\" in obj) return obj.any.some(function(k) {\n return !!$3aa719050363449a$var$env[k];\n });\n return Object.keys(obj).every(function(k) {\n return $3aa719050363449a$var$env[k] === obj[k];\n });\n}\n\n});\nparcelRegister(\"jgqtC\", function(module, exports) {\nmodule.exports = JSON.parse('[{\"name\":\"Agola CI\",\"constant\":\"AGOLA\",\"env\":\"AGOLA_GIT_REF\",\"pr\":\"AGOLA_PULL_REQUEST_ID\"},{\"name\":\"Appcircle\",\"constant\":\"APPCIRCLE\",\"env\":\"AC_APPCIRCLE\"},{\"name\":\"AppVeyor\",\"constant\":\"APPVEYOR\",\"env\":\"APPVEYOR\",\"pr\":\"APPVEYOR_PULL_REQUEST_NUMBER\"},{\"name\":\"AWS CodeBuild\",\"constant\":\"CODEBUILD\",\"env\":\"CODEBUILD_BUILD_ARN\"},{\"name\":\"Azure Pipelines\",\"constant\":\"AZURE_PIPELINES\",\"env\":\"TF_BUILD\",\"pr\":{\"BUILD_REASON\":\"PullRequest\"}},{\"name\":\"Bamboo\",\"constant\":\"BAMBOO\",\"env\":\"bamboo_planKey\"},{\"name\":\"Bitbucket Pipelines\",\"constant\":\"BITBUCKET\",\"env\":\"BITBUCKET_COMMIT\",\"pr\":\"BITBUCKET_PR_ID\"},{\"name\":\"Bitrise\",\"constant\":\"BITRISE\",\"env\":\"BITRISE_IO\",\"pr\":\"BITRISE_PULL_REQUEST\"},{\"name\":\"Buddy\",\"constant\":\"BUDDY\",\"env\":\"BUDDY_WORKSPACE_ID\",\"pr\":\"BUDDY_EXECUTION_PULL_REQUEST_ID\"},{\"name\":\"Buildkite\",\"constant\":\"BUILDKITE\",\"env\":\"BUILDKITE\",\"pr\":{\"env\":\"BUILDKITE_PULL_REQUEST\",\"ne\":\"false\"}},{\"name\":\"CircleCI\",\"constant\":\"CIRCLE\",\"env\":\"CIRCLECI\",\"pr\":\"CIRCLE_PULL_REQUEST\"},{\"name\":\"Cirrus CI\",\"constant\":\"CIRRUS\",\"env\":\"CIRRUS_CI\",\"pr\":\"CIRRUS_PR\"},{\"name\":\"Codefresh\",\"constant\":\"CODEFRESH\",\"env\":\"CF_BUILD_ID\",\"pr\":{\"any\":[\"CF_PULL_REQUEST_NUMBER\",\"CF_PULL_REQUEST_ID\"]}},{\"name\":\"Codemagic\",\"constant\":\"CODEMAGIC\",\"env\":\"CM_BUILD_ID\",\"pr\":\"CM_PULL_REQUEST\"},{\"name\":\"Codeship\",\"constant\":\"CODESHIP\",\"env\":{\"CI_NAME\":\"codeship\"}},{\"name\":\"Drone\",\"constant\":\"DRONE\",\"env\":\"DRONE\",\"pr\":{\"DRONE_BUILD_EVENT\":\"pull_request\"}},{\"name\":\"dsari\",\"constant\":\"DSARI\",\"env\":\"DSARI\"},{\"name\":\"Earthly\",\"constant\":\"EARTHLY\",\"env\":\"EARTHLY_CI\"},{\"name\":\"Expo Application Services\",\"constant\":\"EAS\",\"env\":\"EAS_BUILD\"},{\"name\":\"Gerrit\",\"constant\":\"GERRIT\",\"env\":\"GERRIT_PROJECT\"},{\"name\":\"Gitea Actions\",\"constant\":\"GITEA_ACTIONS\",\"env\":\"GITEA_ACTIONS\"},{\"name\":\"GitHub Actions\",\"constant\":\"GITHUB_ACTIONS\",\"env\":\"GITHUB_ACTIONS\",\"pr\":{\"GITHUB_EVENT_NAME\":\"pull_request\"}},{\"name\":\"GitLab CI\",\"constant\":\"GITLAB\",\"env\":\"GITLAB_CI\",\"pr\":\"CI_MERGE_REQUEST_ID\"},{\"name\":\"GoCD\",\"constant\":\"GOCD\",\"env\":\"GO_PIPELINE_LABEL\"},{\"name\":\"Google Cloud Build\",\"constant\":\"GOOGLE_CLOUD_BUILD\",\"env\":\"BUILDER_OUTPUT\"},{\"name\":\"Harness CI\",\"constant\":\"HARNESS\",\"env\":\"HARNESS_BUILD_ID\"},{\"name\":\"Heroku\",\"constant\":\"HEROKU\",\"env\":{\"env\":\"NODE\",\"includes\":\"/app/.heroku/node/bin/node\"}},{\"name\":\"Hudson\",\"constant\":\"HUDSON\",\"env\":\"HUDSON_URL\"},{\"name\":\"Jenkins\",\"constant\":\"JENKINS\",\"env\":[\"JENKINS_URL\",\"BUILD_ID\"],\"pr\":{\"any\":[\"ghprbPullId\",\"CHANGE_ID\"]}},{\"name\":\"LayerCI\",\"constant\":\"LAYERCI\",\"env\":\"LAYERCI\",\"pr\":\"LAYERCI_PULL_REQUEST\"},{\"name\":\"Magnum CI\",\"constant\":\"MAGNUM\",\"env\":\"MAGNUM\"},{\"name\":\"Netlify CI\",\"constant\":\"NETLIFY\",\"env\":\"NETLIFY\",\"pr\":{\"env\":\"PULL_REQUEST\",\"ne\":\"false\"}},{\"name\":\"Nevercode\",\"constant\":\"NEVERCODE\",\"env\":\"NEVERCODE\",\"pr\":{\"env\":\"NEVERCODE_PULL_REQUEST\",\"ne\":\"false\"}},{\"name\":\"Prow\",\"constant\":\"PROW\",\"env\":\"PROW_JOB_ID\"},{\"name\":\"ReleaseHub\",\"constant\":\"RELEASEHUB\",\"env\":\"RELEASE_BUILD_ID\"},{\"name\":\"Render\",\"constant\":\"RENDER\",\"env\":\"RENDER\",\"pr\":{\"IS_PULL_REQUEST\":\"true\"}},{\"name\":\"Sail CI\",\"constant\":\"SAIL\",\"env\":\"SAILCI\",\"pr\":\"SAIL_PULL_REQUEST_NUMBER\"},{\"name\":\"Screwdriver\",\"constant\":\"SCREWDRIVER\",\"env\":\"SCREWDRIVER\",\"pr\":{\"env\":\"SD_PULL_REQUEST\",\"ne\":\"false\"}},{\"name\":\"Semaphore\",\"constant\":\"SEMAPHORE\",\"env\":\"SEMAPHORE\",\"pr\":\"PULL_REQUEST_NUMBER\"},{\"name\":\"Sourcehut\",\"constant\":\"SOURCEHUT\",\"env\":{\"CI_NAME\":\"sourcehut\"}},{\"name\":\"Strider CD\",\"constant\":\"STRIDER\",\"env\":\"STRIDER\"},{\"name\":\"TaskCluster\",\"constant\":\"TASKCLUSTER\",\"env\":[\"TASK_ID\",\"RUN_ID\"]},{\"name\":\"TeamCity\",\"constant\":\"TEAMCITY\",\"env\":\"TEAMCITY_VERSION\"},{\"name\":\"Travis CI\",\"constant\":\"TRAVIS\",\"env\":\"TRAVIS\",\"pr\":{\"env\":\"TRAVIS_PULL_REQUEST\",\"ne\":\"false\"}},{\"name\":\"Vela\",\"constant\":\"VELA\",\"env\":\"VELA\",\"pr\":{\"VELA_PULL_REQUEST\":\"1\"}},{\"name\":\"Vercel\",\"constant\":\"VERCEL\",\"env\":{\"any\":[\"NOW_BUILDER\",\"VERCEL\"]},\"pr\":\"VERCEL_GIT_PULL_REQUEST_ID\"},{\"name\":\"Visual Studio App Center\",\"constant\":\"APPCENTER\",\"env\":\"APPCENTER_BUILD_ID\"},{\"name\":\"Woodpecker\",\"constant\":\"WOODPECKER\",\"env\":{\"CI\":\"woodpecker\"},\"pr\":{\"CI_BUILD_EVENT\":\"pull_request\"}},{\"name\":\"Xcode Cloud\",\"constant\":\"XCODE_CLOUD\",\"env\":\"CI_XCODE_PROJECT\",\"pr\":\"CI_PULL_REQUEST_NUMBER\"},{\"name\":\"Xcode Server\",\"constant\":\"XCODE_SERVER\",\"env\":\"XCS\"}]');\n\n});\n\n\nparcelRegister(\"ER74K\", function(module, exports) {\n\n$parcel$export(module.exports, \"error\", () => $59a05e0535061862$export$a3bc9b8ed74fc);\n$parcel$export(module.exports, \"success\", () => $59a05e0535061862$export$fe7c49d056ea1d88);\n$parcel$export(module.exports, \"warning\", () => $59a05e0535061862$export$491112666e282270);\n$parcel$export(module.exports, \"notice\", () => $59a05e0535061862$export$b31f6ae88848cf15);\n$parcel$export(module.exports, \"info\", () => $59a05e0535061862$export$a80b3bd66acc52ff);\n\nvar $4t50X = parcelRequire(\"4t50X\");\n\nvar $52cQ1 = parcelRequire(\"52cQ1\");\nfunction $59a05e0535061862$export$a3bc9b8ed74fc(err) {\n return (0, $52cQ1.GITHUB_ACTIONS) ? $4t50X.error(err) : console.log(`\\x1b[31m${err}\\x1b[0m`);\n}\nfunction $59a05e0535061862$export$fe7c49d056ea1d88(msg) {\n return console.log(`\\x1b[32m${msg}\\x1b[0m`);\n}\nfunction $59a05e0535061862$export$491112666e282270(msg) {\n return (0, $52cQ1.GITHUB_ACTIONS) ? $4t50X.warning(msg) : console.log(`\\x1b[33m${msg}\\x1b[0m`);\n}\nfunction $59a05e0535061862$export$b31f6ae88848cf15(msg) {\n return (0, $52cQ1.GITHUB_ACTIONS) ? $4t50X.notice(msg) : console.log(`\\x1b[94m${msg}\\x1b[0m`);\n}\nfunction $59a05e0535061862$export$a80b3bd66acc52ff(msg) {\n return (0, $52cQ1.GITHUB_ACTIONS) ? $4t50X.info(msg) : console.log(msg);\n}\n\n});\nparcelRegister(\"4t50X\", function(module, exports) {\n\"use strict\";\nvar $340dc29cb75a8fc5$var$__createBinding = module.exports && module.exports.__createBinding || (Object.create ? function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n Object.defineProperty(o, k2, {\n enumerable: true,\n get: function() {\n return m[k];\n }\n });\n} : function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n o[k2] = m[k];\n});\nvar $340dc29cb75a8fc5$var$__setModuleDefault = module.exports && module.exports.__setModuleDefault || (Object.create ? function(o, v) {\n Object.defineProperty(o, \"default\", {\n enumerable: true,\n value: v\n });\n} : function(o, v) {\n o[\"default\"] = v;\n});\nvar $340dc29cb75a8fc5$var$__importStar = module.exports && module.exports.__importStar || function(mod) {\n if (mod && mod.__esModule) return mod;\n var result = {};\n if (mod != null) {\n for(var k in mod)if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) $340dc29cb75a8fc5$var$__createBinding(result, mod, k);\n }\n $340dc29cb75a8fc5$var$__setModuleDefault(result, mod);\n return result;\n};\nvar $340dc29cb75a8fc5$var$__awaiter = module.exports && module.exports.__awaiter || function(thisArg, _arguments, P, generator) {\n function adopt(value) {\n return value instanceof P ? value : new P(function(resolve) {\n resolve(value);\n });\n }\n return new (P || (P = Promise))(function(resolve, reject) {\n function fulfilled(value) {\n try {\n step(generator.next(value));\n } catch (e) {\n reject(e);\n }\n }\n function rejected(value) {\n try {\n step(generator[\"throw\"](value));\n } catch (e) {\n reject(e);\n }\n }\n function step(result) {\n result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);\n }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nObject.defineProperty(module.exports, \"__esModule\", {\n value: true\n});\nmodule.exports.getIDToken = module.exports.getState = module.exports.saveState = module.exports.group = module.exports.endGroup = module.exports.startGroup = module.exports.info = module.exports.notice = module.exports.warning = module.exports.error = module.exports.debug = module.exports.isDebug = module.exports.setFailed = module.exports.setCommandEcho = module.exports.setOutput = module.exports.getBooleanInput = module.exports.getMultilineInput = module.exports.getInput = module.exports.addPath = module.exports.setSecret = module.exports.exportVariable = module.exports.ExitCode = void 0;\n\nvar $dIPEE = parcelRequire(\"dIPEE\");\n\nvar $aSbHp = parcelRequire(\"aSbHp\");\n\nvar $i0ItD = parcelRequire(\"i0ItD\");\n\nconst $340dc29cb75a8fc5$var$os = $340dc29cb75a8fc5$var$__importStar($d7DIX$os);\n\nconst $340dc29cb75a8fc5$var$path = $340dc29cb75a8fc5$var$__importStar($d7DIX$path);\n\nvar $6dNYa = parcelRequire(\"6dNYa\");\n/**\n * The code to exit an action\n */ var $340dc29cb75a8fc5$var$ExitCode;\n(function(ExitCode) {\n /**\n * A code indicating that the action was successful\n */ ExitCode[ExitCode[\"Success\"] = 0] = \"Success\";\n /**\n * A code indicating that the action was a failure\n */ ExitCode[ExitCode[\"Failure\"] = 1] = \"Failure\";\n})($340dc29cb75a8fc5$var$ExitCode = module.exports.ExitCode || (module.exports.ExitCode = {}));\n//-----------------------------------------------------------------------\n// Variables\n//-----------------------------------------------------------------------\n/**\n * Sets env variable for this action and future actions in the job\n * @param name the name of the variable to set\n * @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify\n */ // eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction $340dc29cb75a8fc5$var$exportVariable(name, val) {\n const convertedVal = $i0ItD.toCommandValue(val);\n process.env[name] = convertedVal;\n const filePath = process.env[\"GITHUB_ENV\"] || \"\";\n if (filePath) return $aSbHp.issueFileCommand(\"ENV\", $aSbHp.prepareKeyValueMessage(name, val));\n $dIPEE.issueCommand(\"set-env\", {\n name: name\n }, convertedVal);\n}\nmodule.exports.exportVariable = $340dc29cb75a8fc5$var$exportVariable;\n/**\n * Registers a secret which will get masked from logs\n * @param secret value of the secret\n */ function $340dc29cb75a8fc5$var$setSecret(secret) {\n $dIPEE.issueCommand(\"add-mask\", {}, secret);\n}\nmodule.exports.setSecret = $340dc29cb75a8fc5$var$setSecret;\n/**\n * Prepends inputPath to the PATH (for this action and future actions)\n * @param inputPath\n */ function $340dc29cb75a8fc5$var$addPath(inputPath) {\n const filePath = process.env[\"GITHUB_PATH\"] || \"\";\n if (filePath) $aSbHp.issueFileCommand(\"PATH\", inputPath);\n else $dIPEE.issueCommand(\"add-path\", {}, inputPath);\n process.env[\"PATH\"] = `${inputPath}${$340dc29cb75a8fc5$var$path.delimiter}${process.env[\"PATH\"]}`;\n}\nmodule.exports.addPath = $340dc29cb75a8fc5$var$addPath;\n/**\n * Gets the value of an input.\n * Unless trimWhitespace is set to false in InputOptions, the value is also trimmed.\n * Returns an empty string if the value is not defined.\n *\n * @param name name of the input to get\n * @param options optional. See InputOptions.\n * @returns string\n */ function $340dc29cb75a8fc5$var$getInput(name, options) {\n const val = process.env[`INPUT_${name.replace(/ /g, \"_\").toUpperCase()}`] || \"\";\n if (options && options.required && !val) throw new Error(`Input required and not supplied: ${name}`);\n if (options && options.trimWhitespace === false) return val;\n return val.trim();\n}\nmodule.exports.getInput = $340dc29cb75a8fc5$var$getInput;\n/**\n * Gets the values of an multiline input. Each value is also trimmed.\n *\n * @param name name of the input to get\n * @param options optional. See InputOptions.\n * @returns string[]\n *\n */ function $340dc29cb75a8fc5$var$getMultilineInput(name, options) {\n const inputs = $340dc29cb75a8fc5$var$getInput(name, options).split(\"\\n\").filter((x)=>x !== \"\");\n if (options && options.trimWhitespace === false) return inputs;\n return inputs.map((input)=>input.trim());\n}\nmodule.exports.getMultilineInput = $340dc29cb75a8fc5$var$getMultilineInput;\n/**\n * Gets the input value of the boolean type in the YAML 1.2 \"core schema\" specification.\n * Support boolean input list: `true | True | TRUE | false | False | FALSE` .\n * The return value is also in boolean type.\n * ref: https://yaml.org/spec/1.2/spec.html#id2804923\n *\n * @param name name of the input to get\n * @param options optional. See InputOptions.\n * @returns boolean\n */ function $340dc29cb75a8fc5$var$getBooleanInput(name, options) {\n const trueValue = [\n \"true\",\n \"True\",\n \"TRUE\"\n ];\n const falseValue = [\n \"false\",\n \"False\",\n \"FALSE\"\n ];\n const val = $340dc29cb75a8fc5$var$getInput(name, options);\n if (trueValue.includes(val)) return true;\n if (falseValue.includes(val)) return false;\n throw new TypeError(`Input does not meet YAML 1.2 \"Core Schema\" specification: ${name}\\n` + `Support boolean input list: \\`true | True | TRUE | false | False | FALSE\\``);\n}\nmodule.exports.getBooleanInput = $340dc29cb75a8fc5$var$getBooleanInput;\n/**\n * Sets the value of an output.\n *\n * @param name name of the output to set\n * @param value value to store. Non-string values will be converted to a string via JSON.stringify\n */ // eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction $340dc29cb75a8fc5$var$setOutput(name, value) {\n const filePath = process.env[\"GITHUB_OUTPUT\"] || \"\";\n if (filePath) return $aSbHp.issueFileCommand(\"OUTPUT\", $aSbHp.prepareKeyValueMessage(name, value));\n process.stdout.write($340dc29cb75a8fc5$var$os.EOL);\n $dIPEE.issueCommand(\"set-output\", {\n name: name\n }, $i0ItD.toCommandValue(value));\n}\nmodule.exports.setOutput = $340dc29cb75a8fc5$var$setOutput;\n/**\n * Enables or disables the echoing of commands into stdout for the rest of the step.\n * Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set.\n *\n */ function $340dc29cb75a8fc5$var$setCommandEcho(enabled) {\n $dIPEE.issue(\"echo\", enabled ? \"on\" : \"off\");\n}\nmodule.exports.setCommandEcho = $340dc29cb75a8fc5$var$setCommandEcho;\n//-----------------------------------------------------------------------\n// Results\n//-----------------------------------------------------------------------\n/**\n * Sets the action status to failed.\n * When the action exits it will be with an exit code of 1\n * @param message add error issue message\n */ function $340dc29cb75a8fc5$var$setFailed(message) {\n process.exitCode = $340dc29cb75a8fc5$var$ExitCode.Failure;\n $340dc29cb75a8fc5$var$error(message);\n}\nmodule.exports.setFailed = $340dc29cb75a8fc5$var$setFailed;\n//-----------------------------------------------------------------------\n// Logging Commands\n//-----------------------------------------------------------------------\n/**\n * Gets whether Actions Step Debug is on or not\n */ function $340dc29cb75a8fc5$var$isDebug() {\n return process.env[\"RUNNER_DEBUG\"] === \"1\";\n}\nmodule.exports.isDebug = $340dc29cb75a8fc5$var$isDebug;\n/**\n * Writes debug message to user log\n * @param message debug message\n */ function $340dc29cb75a8fc5$var$debug(message) {\n $dIPEE.issueCommand(\"debug\", {}, message);\n}\nmodule.exports.debug = $340dc29cb75a8fc5$var$debug;\n/**\n * Adds an error issue\n * @param message error issue message. Errors will be converted to string via toString()\n * @param properties optional properties to add to the annotation.\n */ function $340dc29cb75a8fc5$var$error(message, properties = {}) {\n $dIPEE.issueCommand(\"error\", $i0ItD.toCommandProperties(properties), message instanceof Error ? message.toString() : message);\n}\nmodule.exports.error = $340dc29cb75a8fc5$var$error;\n/**\n * Adds a warning issue\n * @param message warning issue message. Errors will be converted to string via toString()\n * @param properties optional properties to add to the annotation.\n */ function $340dc29cb75a8fc5$var$warning(message, properties = {}) {\n $dIPEE.issueCommand(\"warning\", $i0ItD.toCommandProperties(properties), message instanceof Error ? message.toString() : message);\n}\nmodule.exports.warning = $340dc29cb75a8fc5$var$warning;\n/**\n * Adds a notice issue\n * @param message notice issue message. Errors will be converted to string via toString()\n * @param properties optional properties to add to the annotation.\n */ function $340dc29cb75a8fc5$var$notice(message, properties = {}) {\n $dIPEE.issueCommand(\"notice\", $i0ItD.toCommandProperties(properties), message instanceof Error ? message.toString() : message);\n}\nmodule.exports.notice = $340dc29cb75a8fc5$var$notice;\n/**\n * Writes info to log with console.log.\n * @param message info message\n */ function $340dc29cb75a8fc5$var$info(message) {\n process.stdout.write(message + $340dc29cb75a8fc5$var$os.EOL);\n}\nmodule.exports.info = $340dc29cb75a8fc5$var$info;\n/**\n * Begin an output group.\n *\n * Output until the next `groupEnd` will be foldable in this group\n *\n * @param name The name of the output group\n */ function $340dc29cb75a8fc5$var$startGroup(name) {\n $dIPEE.issue(\"group\", name);\n}\nmodule.exports.startGroup = $340dc29cb75a8fc5$var$startGroup;\n/**\n * End an output group.\n */ function $340dc29cb75a8fc5$var$endGroup() {\n $dIPEE.issue(\"endgroup\");\n}\nmodule.exports.endGroup = $340dc29cb75a8fc5$var$endGroup;\n/**\n * Wrap an asynchronous function call in a group.\n *\n * Returns the same type as the function itself.\n *\n * @param name The name of the group\n * @param fn The function to wrap in the group\n */ function $340dc29cb75a8fc5$var$group(name, fn) {\n return $340dc29cb75a8fc5$var$__awaiter(this, void 0, void 0, function*() {\n $340dc29cb75a8fc5$var$startGroup(name);\n let result;\n try {\n result = yield fn();\n } finally{\n $340dc29cb75a8fc5$var$endGroup();\n }\n return result;\n });\n}\nmodule.exports.group = $340dc29cb75a8fc5$var$group;\n//-----------------------------------------------------------------------\n// Wrapper action state\n//-----------------------------------------------------------------------\n/**\n * Saves state for current action, the state can only be retrieved by this action's post job execution.\n *\n * @param name name of the state to store\n * @param value value to store. Non-string values will be converted to a string via JSON.stringify\n */ // eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction $340dc29cb75a8fc5$var$saveState(name, value) {\n const filePath = process.env[\"GITHUB_STATE\"] || \"\";\n if (filePath) return $aSbHp.issueFileCommand(\"STATE\", $aSbHp.prepareKeyValueMessage(name, value));\n $dIPEE.issueCommand(\"save-state\", {\n name: name\n }, $i0ItD.toCommandValue(value));\n}\nmodule.exports.saveState = $340dc29cb75a8fc5$var$saveState;\n/**\n * Gets the value of an state set by this action's main execution.\n *\n * @param name name of the state to get\n * @returns string\n */ function $340dc29cb75a8fc5$var$getState(name) {\n return process.env[`STATE_${name}`] || \"\";\n}\nmodule.exports.getState = $340dc29cb75a8fc5$var$getState;\nfunction $340dc29cb75a8fc5$var$getIDToken(aud) {\n return $340dc29cb75a8fc5$var$__awaiter(this, void 0, void 0, function*() {\n return yield $6dNYa.OidcClient.getIDToken(aud);\n });\n}\nmodule.exports.getIDToken = $340dc29cb75a8fc5$var$getIDToken;\n\nvar $dTpO2 = parcelRequire(\"dTpO2\");\nObject.defineProperty(module.exports, \"summary\", {\n enumerable: true,\n get: function() {\n return $dTpO2.summary;\n }\n});\n\nvar $dTpO2 = parcelRequire(\"dTpO2\");\nObject.defineProperty(module.exports, \"markdownSummary\", {\n enumerable: true,\n get: function() {\n return $dTpO2.markdownSummary;\n }\n});\n\nvar $azKnO = parcelRequire(\"azKnO\");\nObject.defineProperty(module.exports, \"toPosixPath\", {\n enumerable: true,\n get: function() {\n return $azKnO.toPosixPath;\n }\n});\nObject.defineProperty(module.exports, \"toWin32Path\", {\n enumerable: true,\n get: function() {\n return $azKnO.toWin32Path;\n }\n});\nObject.defineProperty(module.exports, \"toPlatformPath\", {\n enumerable: true,\n get: function() {\n return $azKnO.toPlatformPath;\n }\n});\n\n});\nparcelRegister(\"dIPEE\", function(module, exports) {\n\"use strict\";\nvar $9fd773f80bf7d36c$var$__createBinding = module.exports && module.exports.__createBinding || (Object.create ? function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n Object.defineProperty(o, k2, {\n enumerable: true,\n get: function() {\n return m[k];\n }\n });\n} : function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n o[k2] = m[k];\n});\nvar $9fd773f80bf7d36c$var$__setModuleDefault = module.exports && module.exports.__setModuleDefault || (Object.create ? function(o, v) {\n Object.defineProperty(o, \"default\", {\n enumerable: true,\n value: v\n });\n} : function(o, v) {\n o[\"default\"] = v;\n});\nvar $9fd773f80bf7d36c$var$__importStar = module.exports && module.exports.__importStar || function(mod) {\n if (mod && mod.__esModule) return mod;\n var result = {};\n if (mod != null) {\n for(var k in mod)if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) $9fd773f80bf7d36c$var$__createBinding(result, mod, k);\n }\n $9fd773f80bf7d36c$var$__setModuleDefault(result, mod);\n return result;\n};\nObject.defineProperty(module.exports, \"__esModule\", {\n value: true\n});\nmodule.exports.issue = module.exports.issueCommand = void 0;\n\nconst $9fd773f80bf7d36c$var$os = $9fd773f80bf7d36c$var$__importStar($d7DIX$os);\n\nvar $i0ItD = parcelRequire(\"i0ItD\");\n/**\n * Commands\n *\n * Command Format:\n * ::name key=value,key=value::message\n *\n * Examples:\n * ::warning::This is the message\n * ::set-env name=MY_VAR::some value\n */ function $9fd773f80bf7d36c$var$issueCommand(command, properties, message) {\n const cmd = new $9fd773f80bf7d36c$var$Command(command, properties, message);\n process.stdout.write(cmd.toString() + $9fd773f80bf7d36c$var$os.EOL);\n}\nmodule.exports.issueCommand = $9fd773f80bf7d36c$var$issueCommand;\nfunction $9fd773f80bf7d36c$var$issue(name, message = \"\") {\n $9fd773f80bf7d36c$var$issueCommand(name, {}, message);\n}\nmodule.exports.issue = $9fd773f80bf7d36c$var$issue;\nconst $9fd773f80bf7d36c$var$CMD_STRING = \"::\";\nclass $9fd773f80bf7d36c$var$Command {\n constructor(command, properties, message){\n if (!command) command = \"missing.command\";\n this.command = command;\n this.properties = properties;\n this.message = message;\n }\n toString() {\n let cmdStr = $9fd773f80bf7d36c$var$CMD_STRING + this.command;\n if (this.properties && Object.keys(this.properties).length > 0) {\n cmdStr += \" \";\n let first = true;\n for(const key in this.properties)if (this.properties.hasOwnProperty(key)) {\n const val = this.properties[key];\n if (val) {\n if (first) first = false;\n else cmdStr += \",\";\n cmdStr += `${key}=${$9fd773f80bf7d36c$var$escapeProperty(val)}`;\n }\n }\n }\n cmdStr += `${$9fd773f80bf7d36c$var$CMD_STRING}${$9fd773f80bf7d36c$var$escapeData(this.message)}`;\n return cmdStr;\n }\n}\nfunction $9fd773f80bf7d36c$var$escapeData(s) {\n return $i0ItD.toCommandValue(s).replace(/%/g, \"%25\").replace(/\\r/g, \"%0D\").replace(/\\n/g, \"%0A\");\n}\nfunction $9fd773f80bf7d36c$var$escapeProperty(s) {\n return $i0ItD.toCommandValue(s).replace(/%/g, \"%25\").replace(/\\r/g, \"%0D\").replace(/\\n/g, \"%0A\").replace(/:/g, \"%3A\").replace(/,/g, \"%2C\");\n}\n\n});\nparcelRegister(\"i0ItD\", function(module, exports) {\n\"use strict\";\n// We use any as a valid input type\n/* eslint-disable @typescript-eslint/no-explicit-any */ Object.defineProperty(module.exports, \"__esModule\", {\n value: true\n});\nmodule.exports.toCommandProperties = module.exports.toCommandValue = void 0;\n/**\n * Sanitizes an input into a string so it can be passed into issueCommand safely\n * @param input input to sanitize into a string\n */ function $d1caba43517904de$var$toCommandValue(input) {\n if (input === null || input === undefined) return \"\";\n else if (typeof input === \"string\" || input instanceof String) return input;\n return JSON.stringify(input);\n}\nmodule.exports.toCommandValue = $d1caba43517904de$var$toCommandValue;\n/**\n *\n * @param annotationProperties\n * @returns The command properties to send with the actual annotation command\n * See IssueCommandProperties: https://github.com/actions/runner/blob/main/src/Runner.Worker/ActionCommandManager.cs#L646\n */ function $d1caba43517904de$var$toCommandProperties(annotationProperties) {\n if (!Object.keys(annotationProperties).length) return {};\n return {\n title: annotationProperties.title,\n file: annotationProperties.file,\n line: annotationProperties.startLine,\n endLine: annotationProperties.endLine,\n col: annotationProperties.startColumn,\n endColumn: annotationProperties.endColumn\n };\n}\nmodule.exports.toCommandProperties = $d1caba43517904de$var$toCommandProperties;\n\n});\n\n\nparcelRegister(\"aSbHp\", function(module, exports) {\n\"use strict\";\n// For internal use, subject to change.\nvar $7ea805c232758762$var$__createBinding = module.exports && module.exports.__createBinding || (Object.create ? function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n Object.defineProperty(o, k2, {\n enumerable: true,\n get: function() {\n return m[k];\n }\n });\n} : function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n o[k2] = m[k];\n});\nvar $7ea805c232758762$var$__setModuleDefault = module.exports && module.exports.__setModuleDefault || (Object.create ? function(o, v) {\n Object.defineProperty(o, \"default\", {\n enumerable: true,\n value: v\n });\n} : function(o, v) {\n o[\"default\"] = v;\n});\nvar $7ea805c232758762$var$__importStar = module.exports && module.exports.__importStar || function(mod) {\n if (mod && mod.__esModule) return mod;\n var result = {};\n if (mod != null) {\n for(var k in mod)if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) $7ea805c232758762$var$__createBinding(result, mod, k);\n }\n $7ea805c232758762$var$__setModuleDefault(result, mod);\n return result;\n};\nObject.defineProperty(module.exports, \"__esModule\", {\n value: true\n});\nmodule.exports.prepareKeyValueMessage = module.exports.issueFileCommand = void 0;\n\n// We use any as a valid input type\n/* eslint-disable @typescript-eslint/no-explicit-any */ const $7ea805c232758762$var$fs = $7ea805c232758762$var$__importStar($d7DIX$fs);\n\nconst $7ea805c232758762$var$os = $7ea805c232758762$var$__importStar($d7DIX$os);\n\nvar $e3G3w = parcelRequire(\"e3G3w\");\n\nvar $i0ItD = parcelRequire(\"i0ItD\");\nfunction $7ea805c232758762$var$issueFileCommand(command, message) {\n const filePath = process.env[`GITHUB_${command}`];\n if (!filePath) throw new Error(`Unable to find environment variable for file command ${command}`);\n if (!$7ea805c232758762$var$fs.existsSync(filePath)) throw new Error(`Missing file at path: ${filePath}`);\n $7ea805c232758762$var$fs.appendFileSync(filePath, `${$i0ItD.toCommandValue(message)}${$7ea805c232758762$var$os.EOL}`, {\n encoding: \"utf8\"\n });\n}\nmodule.exports.issueFileCommand = $7ea805c232758762$var$issueFileCommand;\nfunction $7ea805c232758762$var$prepareKeyValueMessage(key, value) {\n const delimiter = `ghadelimiter_${$e3G3w.default()}`;\n const convertedValue = $i0ItD.toCommandValue(value);\n // These should realistically never happen, but just in case someone finds a\n // way to exploit uuid generation let's not allow keys or values that contain\n // the delimiter.\n if (key.includes(delimiter)) throw new Error(`Unexpected input: name should not contain the delimiter \"${delimiter}\"`);\n if (convertedValue.includes(delimiter)) throw new Error(`Unexpected input: value should not contain the delimiter \"${delimiter}\"`);\n return `${key}<<${delimiter}${$7ea805c232758762$var$os.EOL}${convertedValue}${$7ea805c232758762$var$os.EOL}${delimiter}`;\n}\nmodule.exports.prepareKeyValueMessage = $7ea805c232758762$var$prepareKeyValueMessage;\n\n});\nparcelRegister(\"e3G3w\", function(module, exports) {\n\n$parcel$export(module.exports, \"default\", () => $a3c1f7e44989a758$export$2e2bcd8739ae039);\n\nvar $kDGEy = parcelRequire(\"kDGEy\");\n\nvar $2ckr2 = parcelRequire(\"2ckr2\");\nfunction $a3c1f7e44989a758$var$v4(options, buf, offset) {\n options = options || {};\n const rnds = options.random || (options.rng || (0, $kDGEy.default))(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n rnds[6] = rnds[6] & 0x0f | 0x40;\n rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided\n if (buf) {\n offset = offset || 0;\n for(let i = 0; i < 16; ++i)buf[offset + i] = rnds[i];\n return buf;\n }\n return (0, $2ckr2.default)(rnds);\n}\nvar $a3c1f7e44989a758$export$2e2bcd8739ae039 = $a3c1f7e44989a758$var$v4;\n\n});\nparcelRegister(\"kDGEy\", function(module, exports) {\n\n$parcel$export(module.exports, \"default\", () => $f0688929972e8cca$export$2e2bcd8739ae039);\n\nconst $f0688929972e8cca$var$rnds8Pool = new Uint8Array(256); // # of random values to pre-allocate\nlet $f0688929972e8cca$var$poolPtr = $f0688929972e8cca$var$rnds8Pool.length;\nfunction $f0688929972e8cca$export$2e2bcd8739ae039() {\n if ($f0688929972e8cca$var$poolPtr > $f0688929972e8cca$var$rnds8Pool.length - 16) {\n (0, ($parcel$interopDefault($d7DIX$crypto))).randomFillSync($f0688929972e8cca$var$rnds8Pool);\n $f0688929972e8cca$var$poolPtr = 0;\n }\n return $f0688929972e8cca$var$rnds8Pool.slice($f0688929972e8cca$var$poolPtr, $f0688929972e8cca$var$poolPtr += 16);\n}\n\n});\n\nparcelRegister(\"2ckr2\", function(module, exports) {\n\n$parcel$export(module.exports, \"default\", () => $199c8db8e94efcb9$export$2e2bcd8739ae039);\n\nvar $9IL8W = parcelRequire(\"9IL8W\");\n/**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */ const $199c8db8e94efcb9$var$byteToHex = [];\nfor(let i = 0; i < 256; ++i)$199c8db8e94efcb9$var$byteToHex.push((i + 0x100).toString(16).substr(1));\nfunction $199c8db8e94efcb9$var$stringify(arr, offset = 0) {\n // Note: Be careful editing this code! It's been tuned for performance\n // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434\n const uuid = ($199c8db8e94efcb9$var$byteToHex[arr[offset + 0]] + $199c8db8e94efcb9$var$byteToHex[arr[offset + 1]] + $199c8db8e94efcb9$var$byteToHex[arr[offset + 2]] + $199c8db8e94efcb9$var$byteToHex[arr[offset + 3]] + \"-\" + $199c8db8e94efcb9$var$byteToHex[arr[offset + 4]] + $199c8db8e94efcb9$var$byteToHex[arr[offset + 5]] + \"-\" + $199c8db8e94efcb9$var$byteToHex[arr[offset + 6]] + $199c8db8e94efcb9$var$byteToHex[arr[offset + 7]] + \"-\" + $199c8db8e94efcb9$var$byteToHex[arr[offset + 8]] + $199c8db8e94efcb9$var$byteToHex[arr[offset + 9]] + \"-\" + $199c8db8e94efcb9$var$byteToHex[arr[offset + 10]] + $199c8db8e94efcb9$var$byteToHex[arr[offset + 11]] + $199c8db8e94efcb9$var$byteToHex[arr[offset + 12]] + $199c8db8e94efcb9$var$byteToHex[arr[offset + 13]] + $199c8db8e94efcb9$var$byteToHex[arr[offset + 14]] + $199c8db8e94efcb9$var$byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID. If this throws, it's likely due to one\n // of the following:\n // - One or more input array values don't map to a hex octet (leading to\n // \"undefined\" in the uuid)\n // - Invalid input values for the RFC `version` or `variant` fields\n if (!(0, $9IL8W.default)(uuid)) throw TypeError(\"Stringified UUID is invalid\");\n return uuid;\n}\nvar $199c8db8e94efcb9$export$2e2bcd8739ae039 = $199c8db8e94efcb9$var$stringify;\n\n});\nparcelRegister(\"9IL8W\", function(module, exports) {\n\n$parcel$export(module.exports, \"default\", () => $713ccacc4438b458$export$2e2bcd8739ae039);\n\nvar $hDU47 = parcelRequire(\"hDU47\");\nfunction $713ccacc4438b458$var$validate(uuid) {\n return typeof uuid === \"string\" && (0, $hDU47.default).test(uuid);\n}\nvar $713ccacc4438b458$export$2e2bcd8739ae039 = $713ccacc4438b458$var$validate;\n\n});\nparcelRegister(\"hDU47\", function(module, exports) {\n\n$parcel$export(module.exports, \"default\", () => $cd81919c4b3b9e01$export$2e2bcd8739ae039);\nvar $cd81919c4b3b9e01$export$2e2bcd8739ae039 = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;\n\n});\n\n\n\n\n\nparcelRegister(\"6dNYa\", function(module, exports) {\n\"use strict\";\nvar $487ab7ded41d44aa$var$__awaiter = module.exports && module.exports.__awaiter || function(thisArg, _arguments, P, generator) {\n function adopt(value) {\n return value instanceof P ? value : new P(function(resolve) {\n resolve(value);\n });\n }\n return new (P || (P = Promise))(function(resolve, reject) {\n function fulfilled(value) {\n try {\n step(generator.next(value));\n } catch (e) {\n reject(e);\n }\n }\n function rejected(value) {\n try {\n step(generator[\"throw\"](value));\n } catch (e) {\n reject(e);\n }\n }\n function step(result) {\n result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);\n }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nObject.defineProperty(module.exports, \"__esModule\", {\n value: true\n});\nmodule.exports.OidcClient = void 0;\n\nvar $a7JAS = parcelRequire(\"a7JAS\");\n\nvar $3T6Pq = parcelRequire(\"3T6Pq\");\n\nvar $4t50X = parcelRequire(\"4t50X\");\nclass $487ab7ded41d44aa$var$OidcClient {\n static createHttpClient(allowRetry = true, maxRetry = 10) {\n const requestOptions = {\n allowRetries: allowRetry,\n maxRetries: maxRetry\n };\n return new $a7JAS.HttpClient(\"actions/oidc-client\", [\n new $3T6Pq.BearerCredentialHandler($487ab7ded41d44aa$var$OidcClient.getRequestToken())\n ], requestOptions);\n }\n static getRequestToken() {\n const token = process.env[\"ACTIONS_ID_TOKEN_REQUEST_TOKEN\"];\n if (!token) throw new Error(\"Unable to get ACTIONS_ID_TOKEN_REQUEST_TOKEN env variable\");\n return token;\n }\n static getIDTokenUrl() {\n const runtimeUrl = process.env[\"ACTIONS_ID_TOKEN_REQUEST_URL\"];\n if (!runtimeUrl) throw new Error(\"Unable to get ACTIONS_ID_TOKEN_REQUEST_URL env variable\");\n return runtimeUrl;\n }\n static getCall(id_token_url) {\n var _a;\n return $487ab7ded41d44aa$var$__awaiter(this, void 0, void 0, function*() {\n const httpclient = $487ab7ded41d44aa$var$OidcClient.createHttpClient();\n const res = yield httpclient.getJson(id_token_url).catch((error)=>{\n throw new Error(`Failed to get ID Token. \\n \n Error Code : ${error.statusCode}\\n \n Error Message: ${error.message}`);\n });\n const id_token = (_a = res.result) === null || _a === void 0 ? void 0 : _a.value;\n if (!id_token) throw new Error(\"Response json body do not have ID Token field\");\n return id_token;\n });\n }\n static getIDToken(audience) {\n return $487ab7ded41d44aa$var$__awaiter(this, void 0, void 0, function*() {\n try {\n // New ID Token is requested from action service\n let id_token_url = $487ab7ded41d44aa$var$OidcClient.getIDTokenUrl();\n if (audience) {\n const encodedAudience = encodeURIComponent(audience);\n id_token_url = `${id_token_url}&audience=${encodedAudience}`;\n }\n $4t50X.debug(`ID token url is ${id_token_url}`);\n const id_token = yield $487ab7ded41d44aa$var$OidcClient.getCall(id_token_url);\n $4t50X.setSecret(id_token);\n return id_token;\n } catch (error) {\n throw new Error(`Error message: ${error.message}`);\n }\n });\n }\n}\nmodule.exports.OidcClient = $487ab7ded41d44aa$var$OidcClient;\n\n});\nparcelRegister(\"a7JAS\", function(module, exports) {\n\"use strict\";\n/* eslint-disable @typescript-eslint/no-explicit-any */ var $75edecd1a4092d7a$var$__createBinding = module.exports && module.exports.__createBinding || (Object.create ? function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n Object.defineProperty(o, k2, {\n enumerable: true,\n get: function() {\n return m[k];\n }\n });\n} : function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n o[k2] = m[k];\n});\nvar $75edecd1a4092d7a$var$__setModuleDefault = module.exports && module.exports.__setModuleDefault || (Object.create ? function(o, v) {\n Object.defineProperty(o, \"default\", {\n enumerable: true,\n value: v\n });\n} : function(o, v) {\n o[\"default\"] = v;\n});\nvar $75edecd1a4092d7a$var$__importStar = module.exports && module.exports.__importStar || function(mod) {\n if (mod && mod.__esModule) return mod;\n var result = {};\n if (mod != null) {\n for(var k in mod)if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) $75edecd1a4092d7a$var$__createBinding(result, mod, k);\n }\n $75edecd1a4092d7a$var$__setModuleDefault(result, mod);\n return result;\n};\nvar $75edecd1a4092d7a$var$__awaiter = module.exports && module.exports.__awaiter || function(thisArg, _arguments, P, generator) {\n function adopt(value) {\n return value instanceof P ? value : new P(function(resolve) {\n resolve(value);\n });\n }\n return new (P || (P = Promise))(function(resolve, reject) {\n function fulfilled(value) {\n try {\n step(generator.next(value));\n } catch (e) {\n reject(e);\n }\n }\n function rejected(value) {\n try {\n step(generator[\"throw\"](value));\n } catch (e) {\n reject(e);\n }\n }\n function step(result) {\n result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);\n }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nObject.defineProperty(module.exports, \"__esModule\", {\n value: true\n});\nmodule.exports.HttpClient = module.exports.isHttps = module.exports.HttpClientResponse = module.exports.HttpClientError = module.exports.getProxyUrl = module.exports.MediaTypes = module.exports.Headers = module.exports.HttpCodes = void 0;\n\nconst $75edecd1a4092d7a$var$http = $75edecd1a4092d7a$var$__importStar($d7DIX$http);\n\nconst $75edecd1a4092d7a$var$https = $75edecd1a4092d7a$var$__importStar($d7DIX$https);\n\nconst $75edecd1a4092d7a$var$pm = $75edecd1a4092d7a$var$__importStar((parcelRequire(\"8gh3V\")));\n\nconst $75edecd1a4092d7a$var$tunnel = $75edecd1a4092d7a$var$__importStar((parcelRequire(\"7i1qo\")));\nvar $75edecd1a4092d7a$var$HttpCodes;\n(function(HttpCodes) {\n HttpCodes[HttpCodes[\"OK\"] = 200] = \"OK\";\n HttpCodes[HttpCodes[\"MultipleChoices\"] = 300] = \"MultipleChoices\";\n HttpCodes[HttpCodes[\"MovedPermanently\"] = 301] = \"MovedPermanently\";\n HttpCodes[HttpCodes[\"ResourceMoved\"] = 302] = \"ResourceMoved\";\n HttpCodes[HttpCodes[\"SeeOther\"] = 303] = \"SeeOther\";\n HttpCodes[HttpCodes[\"NotModified\"] = 304] = \"NotModified\";\n HttpCodes[HttpCodes[\"UseProxy\"] = 305] = \"UseProxy\";\n HttpCodes[HttpCodes[\"SwitchProxy\"] = 306] = \"SwitchProxy\";\n HttpCodes[HttpCodes[\"TemporaryRedirect\"] = 307] = \"TemporaryRedirect\";\n HttpCodes[HttpCodes[\"PermanentRedirect\"] = 308] = \"PermanentRedirect\";\n HttpCodes[HttpCodes[\"BadRequest\"] = 400] = \"BadRequest\";\n HttpCodes[HttpCodes[\"Unauthorized\"] = 401] = \"Unauthorized\";\n HttpCodes[HttpCodes[\"PaymentRequired\"] = 402] = \"PaymentRequired\";\n HttpCodes[HttpCodes[\"Forbidden\"] = 403] = \"Forbidden\";\n HttpCodes[HttpCodes[\"NotFound\"] = 404] = \"NotFound\";\n HttpCodes[HttpCodes[\"MethodNotAllowed\"] = 405] = \"MethodNotAllowed\";\n HttpCodes[HttpCodes[\"NotAcceptable\"] = 406] = \"NotAcceptable\";\n HttpCodes[HttpCodes[\"ProxyAuthenticationRequired\"] = 407] = \"ProxyAuthenticationRequired\";\n HttpCodes[HttpCodes[\"RequestTimeout\"] = 408] = \"RequestTimeout\";\n HttpCodes[HttpCodes[\"Conflict\"] = 409] = \"Conflict\";\n HttpCodes[HttpCodes[\"Gone\"] = 410] = \"Gone\";\n HttpCodes[HttpCodes[\"TooManyRequests\"] = 429] = \"TooManyRequests\";\n HttpCodes[HttpCodes[\"InternalServerError\"] = 500] = \"InternalServerError\";\n HttpCodes[HttpCodes[\"NotImplemented\"] = 501] = \"NotImplemented\";\n HttpCodes[HttpCodes[\"BadGateway\"] = 502] = \"BadGateway\";\n HttpCodes[HttpCodes[\"ServiceUnavailable\"] = 503] = \"ServiceUnavailable\";\n HttpCodes[HttpCodes[\"GatewayTimeout\"] = 504] = \"GatewayTimeout\";\n})($75edecd1a4092d7a$var$HttpCodes = module.exports.HttpCodes || (module.exports.HttpCodes = {}));\nvar $75edecd1a4092d7a$var$Headers;\n(function(Headers) {\n Headers[\"Accept\"] = \"accept\";\n Headers[\"ContentType\"] = \"content-type\";\n})($75edecd1a4092d7a$var$Headers = module.exports.Headers || (module.exports.Headers = {}));\nvar $75edecd1a4092d7a$var$MediaTypes;\n(function(MediaTypes) {\n MediaTypes[\"ApplicationJson\"] = \"application/json\";\n})($75edecd1a4092d7a$var$MediaTypes = module.exports.MediaTypes || (module.exports.MediaTypes = {}));\n/**\n * Returns the proxy URL, depending upon the supplied url and proxy environment variables.\n * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com\n */ function $75edecd1a4092d7a$var$getProxyUrl(serverUrl) {\n const proxyUrl = $75edecd1a4092d7a$var$pm.getProxyUrl(new URL(serverUrl));\n return proxyUrl ? proxyUrl.href : \"\";\n}\nmodule.exports.getProxyUrl = $75edecd1a4092d7a$var$getProxyUrl;\nconst $75edecd1a4092d7a$var$HttpRedirectCodes = [\n $75edecd1a4092d7a$var$HttpCodes.MovedPermanently,\n $75edecd1a4092d7a$var$HttpCodes.ResourceMoved,\n $75edecd1a4092d7a$var$HttpCodes.SeeOther,\n $75edecd1a4092d7a$var$HttpCodes.TemporaryRedirect,\n $75edecd1a4092d7a$var$HttpCodes.PermanentRedirect\n];\nconst $75edecd1a4092d7a$var$HttpResponseRetryCodes = [\n $75edecd1a4092d7a$var$HttpCodes.BadGateway,\n $75edecd1a4092d7a$var$HttpCodes.ServiceUnavailable,\n $75edecd1a4092d7a$var$HttpCodes.GatewayTimeout\n];\nconst $75edecd1a4092d7a$var$RetryableHttpVerbs = [\n \"OPTIONS\",\n \"GET\",\n \"DELETE\",\n \"HEAD\"\n];\nconst $75edecd1a4092d7a$var$ExponentialBackoffCeiling = 10;\nconst $75edecd1a4092d7a$var$ExponentialBackoffTimeSlice = 5;\nclass $75edecd1a4092d7a$var$HttpClientError extends Error {\n constructor(message, statusCode){\n super(message);\n this.name = \"HttpClientError\";\n this.statusCode = statusCode;\n Object.setPrototypeOf(this, $75edecd1a4092d7a$var$HttpClientError.prototype);\n }\n}\nmodule.exports.HttpClientError = $75edecd1a4092d7a$var$HttpClientError;\nclass $75edecd1a4092d7a$var$HttpClientResponse {\n constructor(message){\n this.message = message;\n }\n readBody() {\n return $75edecd1a4092d7a$var$__awaiter(this, void 0, void 0, function*() {\n return new Promise((resolve)=>$75edecd1a4092d7a$var$__awaiter(this, void 0, void 0, function*() {\n let output = Buffer.alloc(0);\n this.message.on(\"data\", (chunk)=>{\n output = Buffer.concat([\n output,\n chunk\n ]);\n });\n this.message.on(\"end\", ()=>{\n resolve(output.toString());\n });\n }));\n });\n }\n}\nmodule.exports.HttpClientResponse = $75edecd1a4092d7a$var$HttpClientResponse;\nfunction $75edecd1a4092d7a$var$isHttps(requestUrl) {\n const parsedUrl = new URL(requestUrl);\n return parsedUrl.protocol === \"https:\";\n}\nmodule.exports.isHttps = $75edecd1a4092d7a$var$isHttps;\nclass $75edecd1a4092d7a$var$HttpClient {\n constructor(userAgent, handlers, requestOptions){\n this._ignoreSslError = false;\n this._allowRedirects = true;\n this._allowRedirectDowngrade = false;\n this._maxRedirects = 50;\n this._allowRetries = false;\n this._maxRetries = 1;\n this._keepAlive = false;\n this._disposed = false;\n this.userAgent = userAgent;\n this.handlers = handlers || [];\n this.requestOptions = requestOptions;\n if (requestOptions) {\n if (requestOptions.ignoreSslError != null) this._ignoreSslError = requestOptions.ignoreSslError;\n this._socketTimeout = requestOptions.socketTimeout;\n if (requestOptions.allowRedirects != null) this._allowRedirects = requestOptions.allowRedirects;\n if (requestOptions.allowRedirectDowngrade != null) this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade;\n if (requestOptions.maxRedirects != null) this._maxRedirects = Math.max(requestOptions.maxRedirects, 0);\n if (requestOptions.keepAlive != null) this._keepAlive = requestOptions.keepAlive;\n if (requestOptions.allowRetries != null) this._allowRetries = requestOptions.allowRetries;\n if (requestOptions.maxRetries != null) this._maxRetries = requestOptions.maxRetries;\n }\n }\n options(requestUrl, additionalHeaders) {\n return $75edecd1a4092d7a$var$__awaiter(this, void 0, void 0, function*() {\n return this.request(\"OPTIONS\", requestUrl, null, additionalHeaders || {});\n });\n }\n get(requestUrl, additionalHeaders) {\n return $75edecd1a4092d7a$var$__awaiter(this, void 0, void 0, function*() {\n return this.request(\"GET\", requestUrl, null, additionalHeaders || {});\n });\n }\n del(requestUrl, additionalHeaders) {\n return $75edecd1a4092d7a$var$__awaiter(this, void 0, void 0, function*() {\n return this.request(\"DELETE\", requestUrl, null, additionalHeaders || {});\n });\n }\n post(requestUrl, data, additionalHeaders) {\n return $75edecd1a4092d7a$var$__awaiter(this, void 0, void 0, function*() {\n return this.request(\"POST\", requestUrl, data, additionalHeaders || {});\n });\n }\n patch(requestUrl, data, additionalHeaders) {\n return $75edecd1a4092d7a$var$__awaiter(this, void 0, void 0, function*() {\n return this.request(\"PATCH\", requestUrl, data, additionalHeaders || {});\n });\n }\n put(requestUrl, data, additionalHeaders) {\n return $75edecd1a4092d7a$var$__awaiter(this, void 0, void 0, function*() {\n return this.request(\"PUT\", requestUrl, data, additionalHeaders || {});\n });\n }\n head(requestUrl, additionalHeaders) {\n return $75edecd1a4092d7a$var$__awaiter(this, void 0, void 0, function*() {\n return this.request(\"HEAD\", requestUrl, null, additionalHeaders || {});\n });\n }\n sendStream(verb, requestUrl, stream, additionalHeaders) {\n return $75edecd1a4092d7a$var$__awaiter(this, void 0, void 0, function*() {\n return this.request(verb, requestUrl, stream, additionalHeaders);\n });\n }\n /**\n * Gets a typed object from an endpoint\n * Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise\n */ getJson(requestUrl, additionalHeaders = {}) {\n return $75edecd1a4092d7a$var$__awaiter(this, void 0, void 0, function*() {\n additionalHeaders[$75edecd1a4092d7a$var$Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, $75edecd1a4092d7a$var$Headers.Accept, $75edecd1a4092d7a$var$MediaTypes.ApplicationJson);\n const res = yield this.get(requestUrl, additionalHeaders);\n return this._processResponse(res, this.requestOptions);\n });\n }\n postJson(requestUrl, obj, additionalHeaders = {}) {\n return $75edecd1a4092d7a$var$__awaiter(this, void 0, void 0, function*() {\n const data = JSON.stringify(obj, null, 2);\n additionalHeaders[$75edecd1a4092d7a$var$Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, $75edecd1a4092d7a$var$Headers.Accept, $75edecd1a4092d7a$var$MediaTypes.ApplicationJson);\n additionalHeaders[$75edecd1a4092d7a$var$Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, $75edecd1a4092d7a$var$Headers.ContentType, $75edecd1a4092d7a$var$MediaTypes.ApplicationJson);\n const res = yield this.post(requestUrl, data, additionalHeaders);\n return this._processResponse(res, this.requestOptions);\n });\n }\n putJson(requestUrl, obj, additionalHeaders = {}) {\n return $75edecd1a4092d7a$var$__awaiter(this, void 0, void 0, function*() {\n const data = JSON.stringify(obj, null, 2);\n additionalHeaders[$75edecd1a4092d7a$var$Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, $75edecd1a4092d7a$var$Headers.Accept, $75edecd1a4092d7a$var$MediaTypes.ApplicationJson);\n additionalHeaders[$75edecd1a4092d7a$var$Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, $75edecd1a4092d7a$var$Headers.ContentType, $75edecd1a4092d7a$var$MediaTypes.ApplicationJson);\n const res = yield this.put(requestUrl, data, additionalHeaders);\n return this._processResponse(res, this.requestOptions);\n });\n }\n patchJson(requestUrl, obj, additionalHeaders = {}) {\n return $75edecd1a4092d7a$var$__awaiter(this, void 0, void 0, function*() {\n const data = JSON.stringify(obj, null, 2);\n additionalHeaders[$75edecd1a4092d7a$var$Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, $75edecd1a4092d7a$var$Headers.Accept, $75edecd1a4092d7a$var$MediaTypes.ApplicationJson);\n additionalHeaders[$75edecd1a4092d7a$var$Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, $75edecd1a4092d7a$var$Headers.ContentType, $75edecd1a4092d7a$var$MediaTypes.ApplicationJson);\n const res = yield this.patch(requestUrl, data, additionalHeaders);\n return this._processResponse(res, this.requestOptions);\n });\n }\n /**\n * Makes a raw http request.\n * All other methods such as get, post, patch, and request ultimately call this.\n * Prefer get, del, post and patch\n */ request(verb, requestUrl, data, headers) {\n return $75edecd1a4092d7a$var$__awaiter(this, void 0, void 0, function*() {\n if (this._disposed) throw new Error(\"Client has already been disposed.\");\n const parsedUrl = new URL(requestUrl);\n let info = this._prepareRequest(verb, parsedUrl, headers);\n // Only perform retries on reads since writes may not be idempotent.\n const maxTries = this._allowRetries && $75edecd1a4092d7a$var$RetryableHttpVerbs.includes(verb) ? this._maxRetries + 1 : 1;\n let numTries = 0;\n let response;\n do {\n response = yield this.requestRaw(info, data);\n // Check if it's an authentication challenge\n if (response && response.message && response.message.statusCode === $75edecd1a4092d7a$var$HttpCodes.Unauthorized) {\n let authenticationHandler;\n for (const handler of this.handlers)if (handler.canHandleAuthentication(response)) {\n authenticationHandler = handler;\n break;\n }\n if (authenticationHandler) return authenticationHandler.handleAuthentication(this, info, data);\n else // We have received an unauthorized response but have no handlers to handle it.\n // Let the response return to the caller.\n return response;\n }\n let redirectsRemaining = this._maxRedirects;\n while(response.message.statusCode && $75edecd1a4092d7a$var$HttpRedirectCodes.includes(response.message.statusCode) && this._allowRedirects && redirectsRemaining > 0){\n const redirectUrl = response.message.headers[\"location\"];\n if (!redirectUrl) break;\n const parsedRedirectUrl = new URL(redirectUrl);\n if (parsedUrl.protocol === \"https:\" && parsedUrl.protocol !== parsedRedirectUrl.protocol && !this._allowRedirectDowngrade) throw new Error(\"Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.\");\n // we need to finish reading the response before reassigning response\n // which will leak the open socket.\n yield response.readBody();\n // strip authorization header if redirected to a different hostname\n if (parsedRedirectUrl.hostname !== parsedUrl.hostname) {\n for(const header in headers)// header names are case insensitive\n if (header.toLowerCase() === \"authorization\") delete headers[header];\n }\n // let's make the request with the new redirectUrl\n info = this._prepareRequest(verb, parsedRedirectUrl, headers);\n response = yield this.requestRaw(info, data);\n redirectsRemaining--;\n }\n if (!response.message.statusCode || !$75edecd1a4092d7a$var$HttpResponseRetryCodes.includes(response.message.statusCode)) // If not a retry code, return immediately instead of retrying\n return response;\n numTries += 1;\n if (numTries < maxTries) {\n yield response.readBody();\n yield this._performExponentialBackoff(numTries);\n }\n }while (numTries < maxTries);\n return response;\n });\n }\n /**\n * Needs to be called if keepAlive is set to true in request options.\n */ dispose() {\n if (this._agent) this._agent.destroy();\n this._disposed = true;\n }\n /**\n * Raw request.\n * @param info\n * @param data\n */ requestRaw(info, data) {\n return $75edecd1a4092d7a$var$__awaiter(this, void 0, void 0, function*() {\n return new Promise((resolve, reject)=>{\n function callbackForResult(err, res) {\n if (err) reject(err);\n else if (!res) // If `err` is not passed, then `res` must be passed.\n reject(new Error(\"Unknown error\"));\n else resolve(res);\n }\n this.requestRawWithCallback(info, data, callbackForResult);\n });\n });\n }\n /**\n * Raw request with callback.\n * @param info\n * @param data\n * @param onResult\n */ requestRawWithCallback(info, data, onResult) {\n if (typeof data === \"string\") {\n if (!info.options.headers) info.options.headers = {};\n info.options.headers[\"Content-Length\"] = Buffer.byteLength(data, \"utf8\");\n }\n let callbackCalled = false;\n function handleResult(err, res) {\n if (!callbackCalled) {\n callbackCalled = true;\n onResult(err, res);\n }\n }\n const req = info.httpModule.request(info.options, (msg)=>{\n const res = new $75edecd1a4092d7a$var$HttpClientResponse(msg);\n handleResult(undefined, res);\n });\n let socket;\n req.on(\"socket\", (sock)=>{\n socket = sock;\n });\n // If we ever get disconnected, we want the socket to timeout eventually\n req.setTimeout(this._socketTimeout || 180000, ()=>{\n if (socket) socket.end();\n handleResult(new Error(`Request timeout: ${info.options.path}`));\n });\n req.on(\"error\", function(err) {\n // err has statusCode property\n // res should have headers\n handleResult(err);\n });\n if (data && typeof data === \"string\") req.write(data, \"utf8\");\n if (data && typeof data !== \"string\") {\n data.on(\"close\", function() {\n req.end();\n });\n data.pipe(req);\n } else req.end();\n }\n /**\n * Gets an http agent. This function is useful when you need an http agent that handles\n * routing through a proxy server - depending upon the url and proxy environment variables.\n * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com\n */ getAgent(serverUrl) {\n const parsedUrl = new URL(serverUrl);\n return this._getAgent(parsedUrl);\n }\n _prepareRequest(method, requestUrl, headers) {\n const info = {};\n info.parsedUrl = requestUrl;\n const usingSsl = info.parsedUrl.protocol === \"https:\";\n info.httpModule = usingSsl ? $75edecd1a4092d7a$var$https : $75edecd1a4092d7a$var$http;\n const defaultPort = usingSsl ? 443 : 80;\n info.options = {};\n info.options.host = info.parsedUrl.hostname;\n info.options.port = info.parsedUrl.port ? parseInt(info.parsedUrl.port) : defaultPort;\n info.options.path = (info.parsedUrl.pathname || \"\") + (info.parsedUrl.search || \"\");\n info.options.method = method;\n info.options.headers = this._mergeHeaders(headers);\n if (this.userAgent != null) info.options.headers[\"user-agent\"] = this.userAgent;\n info.options.agent = this._getAgent(info.parsedUrl);\n // gives handlers an opportunity to participate\n if (this.handlers) for (const handler of this.handlers)handler.prepareRequest(info.options);\n return info;\n }\n _mergeHeaders(headers) {\n if (this.requestOptions && this.requestOptions.headers) return Object.assign({}, $75edecd1a4092d7a$var$lowercaseKeys(this.requestOptions.headers), $75edecd1a4092d7a$var$lowercaseKeys(headers || {}));\n return $75edecd1a4092d7a$var$lowercaseKeys(headers || {});\n }\n _getExistingOrDefaultHeader(additionalHeaders, header, _default) {\n let clientHeader;\n if (this.requestOptions && this.requestOptions.headers) clientHeader = $75edecd1a4092d7a$var$lowercaseKeys(this.requestOptions.headers)[header];\n return additionalHeaders[header] || clientHeader || _default;\n }\n _getAgent(parsedUrl) {\n let agent;\n const proxyUrl = $75edecd1a4092d7a$var$pm.getProxyUrl(parsedUrl);\n const useProxy = proxyUrl && proxyUrl.hostname;\n if (this._keepAlive && useProxy) agent = this._proxyAgent;\n if (this._keepAlive && !useProxy) agent = this._agent;\n // if agent is already assigned use that agent.\n if (agent) return agent;\n const usingSsl = parsedUrl.protocol === \"https:\";\n let maxSockets = 100;\n if (this.requestOptions) maxSockets = this.requestOptions.maxSockets || $75edecd1a4092d7a$var$http.globalAgent.maxSockets;\n // This is `useProxy` again, but we need to check `proxyURl` directly for TypeScripts's flow analysis.\n if (proxyUrl && proxyUrl.hostname) {\n const agentOptions = {\n maxSockets: maxSockets,\n keepAlive: this._keepAlive,\n proxy: Object.assign(Object.assign({}, (proxyUrl.username || proxyUrl.password) && {\n proxyAuth: `${proxyUrl.username}:${proxyUrl.password}`\n }), {\n host: proxyUrl.hostname,\n port: proxyUrl.port\n })\n };\n let tunnelAgent;\n const overHttps = proxyUrl.protocol === \"https:\";\n if (usingSsl) tunnelAgent = overHttps ? $75edecd1a4092d7a$var$tunnel.httpsOverHttps : $75edecd1a4092d7a$var$tunnel.httpsOverHttp;\n else tunnelAgent = overHttps ? $75edecd1a4092d7a$var$tunnel.httpOverHttps : $75edecd1a4092d7a$var$tunnel.httpOverHttp;\n agent = tunnelAgent(agentOptions);\n this._proxyAgent = agent;\n }\n // if reusing agent across request and tunneling agent isn't assigned create a new agent\n if (this._keepAlive && !agent) {\n const options = {\n keepAlive: this._keepAlive,\n maxSockets: maxSockets\n };\n agent = usingSsl ? new $75edecd1a4092d7a$var$https.Agent(options) : new $75edecd1a4092d7a$var$http.Agent(options);\n this._agent = agent;\n }\n // if not using private agent and tunnel agent isn't setup then use global agent\n if (!agent) agent = usingSsl ? $75edecd1a4092d7a$var$https.globalAgent : $75edecd1a4092d7a$var$http.globalAgent;\n if (usingSsl && this._ignoreSslError) // we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process\n // http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options\n // we have to cast it to any and change it directly\n agent.options = Object.assign(agent.options || {}, {\n rejectUnauthorized: false\n });\n return agent;\n }\n _performExponentialBackoff(retryNumber) {\n return $75edecd1a4092d7a$var$__awaiter(this, void 0, void 0, function*() {\n retryNumber = Math.min($75edecd1a4092d7a$var$ExponentialBackoffCeiling, retryNumber);\n const ms = $75edecd1a4092d7a$var$ExponentialBackoffTimeSlice * Math.pow(2, retryNumber);\n return new Promise((resolve)=>setTimeout(()=>resolve(), ms));\n });\n }\n _processResponse(res, options) {\n return $75edecd1a4092d7a$var$__awaiter(this, void 0, void 0, function*() {\n return new Promise((resolve, reject)=>$75edecd1a4092d7a$var$__awaiter(this, void 0, void 0, function*() {\n const statusCode = res.message.statusCode || 0;\n const response = {\n statusCode: statusCode,\n result: null,\n headers: {}\n };\n // not found leads to null obj returned\n if (statusCode === $75edecd1a4092d7a$var$HttpCodes.NotFound) resolve(response);\n // get the result from the body\n function dateTimeDeserializer(key, value) {\n if (typeof value === \"string\") {\n const a = new Date(value);\n if (!isNaN(a.valueOf())) return a;\n }\n return value;\n }\n let obj;\n let contents;\n try {\n contents = yield res.readBody();\n if (contents && contents.length > 0) {\n if (options && options.deserializeDates) obj = JSON.parse(contents, dateTimeDeserializer);\n else obj = JSON.parse(contents);\n response.result = obj;\n }\n response.headers = res.message.headers;\n } catch (err) {\n // Invalid resource (contents not json); leaving result obj null\n }\n // note that 3xx redirects are handled by the http layer.\n if (statusCode > 299) {\n let msg;\n // if exception/error in body, attempt to get better error\n if (obj && obj.message) msg = obj.message;\n else if (contents && contents.length > 0) // it may be the case that the exception is in the body message as string\n msg = contents;\n else msg = `Failed request: (${statusCode})`;\n const err = new $75edecd1a4092d7a$var$HttpClientError(msg, statusCode);\n err.result = response.result;\n reject(err);\n } else resolve(response);\n }));\n });\n }\n}\nmodule.exports.HttpClient = $75edecd1a4092d7a$var$HttpClient;\nconst $75edecd1a4092d7a$var$lowercaseKeys = (obj)=>Object.keys(obj).reduce((c, k)=>(c[k.toLowerCase()] = obj[k], c), {});\n\n});\nparcelRegister(\"8gh3V\", function(module, exports) {\n\"use strict\";\nObject.defineProperty(module.exports, \"__esModule\", {\n value: true\n});\nmodule.exports.checkBypass = module.exports.getProxyUrl = void 0;\nfunction $603d0d99277438f4$var$getProxyUrl(reqUrl) {\n const usingSsl = reqUrl.protocol === \"https:\";\n if ($603d0d99277438f4$var$checkBypass(reqUrl)) return undefined;\n const proxyVar = (()=>{\n if (usingSsl) return process.env[\"https_proxy\"] || process.env[\"HTTPS_PROXY\"];\n else return process.env[\"http_proxy\"] || process.env[\"HTTP_PROXY\"];\n })();\n if (proxyVar) return new URL(proxyVar);\n else return undefined;\n}\nmodule.exports.getProxyUrl = $603d0d99277438f4$var$getProxyUrl;\nfunction $603d0d99277438f4$var$checkBypass(reqUrl) {\n if (!reqUrl.hostname) return false;\n const reqHost = reqUrl.hostname;\n if ($603d0d99277438f4$var$isLoopbackAddress(reqHost)) return true;\n const noProxy = process.env[\"no_proxy\"] || process.env[\"NO_PROXY\"] || \"\";\n if (!noProxy) return false;\n // Determine the request port\n let reqPort;\n if (reqUrl.port) reqPort = Number(reqUrl.port);\n else if (reqUrl.protocol === \"http:\") reqPort = 80;\n else if (reqUrl.protocol === \"https:\") reqPort = 443;\n // Format the request hostname and hostname with port\n const upperReqHosts = [\n reqUrl.hostname.toUpperCase()\n ];\n if (typeof reqPort === \"number\") upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`);\n // Compare request host against noproxy\n for (const upperNoProxyItem of noProxy.split(\",\").map((x)=>x.trim().toUpperCase()).filter((x)=>x)){\n if (upperNoProxyItem === \"*\" || upperReqHosts.some((x)=>x === upperNoProxyItem || x.endsWith(`.${upperNoProxyItem}`) || upperNoProxyItem.startsWith(\".\") && x.endsWith(`${upperNoProxyItem}`))) return true;\n }\n return false;\n}\nmodule.exports.checkBypass = $603d0d99277438f4$var$checkBypass;\nfunction $603d0d99277438f4$var$isLoopbackAddress(host) {\n const hostLower = host.toLowerCase();\n return hostLower === \"localhost\" || hostLower.startsWith(\"127.\") || hostLower.startsWith(\"[::1]\") || hostLower.startsWith(\"[0:0:0:0:0:0:0:1]\");\n}\n\n});\n\nparcelRegister(\"7i1qo\", function(module, exports) {\n\nmodule.exports = (parcelRequire(\"fbmJm\"));\n\n});\nparcelRegister(\"fbmJm\", function(module, exports) {\n\n$parcel$export(module.exports, \"httpOverHttp\", () => $b0d983e8249a2cc9$export$25cbd437c61a3835, (v) => $b0d983e8249a2cc9$export$25cbd437c61a3835 = v);\n$parcel$export(module.exports, \"httpsOverHttp\", () => $b0d983e8249a2cc9$export$c06e3df7111bae43, (v) => $b0d983e8249a2cc9$export$c06e3df7111bae43 = v);\n$parcel$export(module.exports, \"httpOverHttps\", () => $b0d983e8249a2cc9$export$5d50e36ef656139f, (v) => $b0d983e8249a2cc9$export$5d50e36ef656139f = v);\n$parcel$export(module.exports, \"httpsOverHttps\", () => $b0d983e8249a2cc9$export$212d6605025321cc, (v) => $b0d983e8249a2cc9$export$212d6605025321cc = v);\n$parcel$export(module.exports, \"debug\", () => $b0d983e8249a2cc9$export$1c9f709888824e05, (v) => $b0d983e8249a2cc9$export$1c9f709888824e05 = v);\nvar $b0d983e8249a2cc9$export$25cbd437c61a3835;\nvar $b0d983e8249a2cc9$export$c06e3df7111bae43;\nvar $b0d983e8249a2cc9$export$5d50e36ef656139f;\nvar $b0d983e8249a2cc9$export$212d6605025321cc;\nvar $b0d983e8249a2cc9$export$1c9f709888824e05;\n\"use strict\";\n\n\n\n\n\n\n\n$b0d983e8249a2cc9$export$25cbd437c61a3835 = $b0d983e8249a2cc9$var$httpOverHttp;\n$b0d983e8249a2cc9$export$c06e3df7111bae43 = $b0d983e8249a2cc9$var$httpsOverHttp;\n$b0d983e8249a2cc9$export$5d50e36ef656139f = $b0d983e8249a2cc9$var$httpOverHttps;\n$b0d983e8249a2cc9$export$212d6605025321cc = $b0d983e8249a2cc9$var$httpsOverHttps;\nfunction $b0d983e8249a2cc9$var$httpOverHttp(options) {\n var agent = new $b0d983e8249a2cc9$var$TunnelingAgent(options);\n agent.request = $d7DIX$http.request;\n return agent;\n}\nfunction $b0d983e8249a2cc9$var$httpsOverHttp(options) {\n var agent = new $b0d983e8249a2cc9$var$TunnelingAgent(options);\n agent.request = $d7DIX$http.request;\n agent.createSocket = $b0d983e8249a2cc9$var$createSecureSocket;\n agent.defaultPort = 443;\n return agent;\n}\nfunction $b0d983e8249a2cc9$var$httpOverHttps(options) {\n var agent = new $b0d983e8249a2cc9$var$TunnelingAgent(options);\n agent.request = $d7DIX$https.request;\n return agent;\n}\nfunction $b0d983e8249a2cc9$var$httpsOverHttps(options) {\n var agent = new $b0d983e8249a2cc9$var$TunnelingAgent(options);\n agent.request = $d7DIX$https.request;\n agent.createSocket = $b0d983e8249a2cc9$var$createSecureSocket;\n agent.defaultPort = 443;\n return agent;\n}\nfunction $b0d983e8249a2cc9$var$TunnelingAgent(options) {\n var self = this;\n self.options = options || {};\n self.proxyOptions = self.options.proxy || {};\n self.maxSockets = self.options.maxSockets || $d7DIX$http.Agent.defaultMaxSockets;\n self.requests = [];\n self.sockets = [];\n self.on(\"free\", function onFree(socket, host, port, localAddress) {\n var options = $b0d983e8249a2cc9$var$toOptions(host, port, localAddress);\n for(var i = 0, len = self.requests.length; i < len; ++i){\n var pending = self.requests[i];\n if (pending.host === options.host && pending.port === options.port) {\n // Detect the request to connect same origin server,\n // reuse the connection.\n self.requests.splice(i, 1);\n pending.request.onSocket(socket);\n return;\n }\n }\n socket.destroy();\n self.removeSocket(socket);\n });\n}\n$d7DIX$util.inherits($b0d983e8249a2cc9$var$TunnelingAgent, $d7DIX$events.EventEmitter);\n$b0d983e8249a2cc9$var$TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) {\n var self = this;\n var options = $b0d983e8249a2cc9$var$mergeOptions({\n request: req\n }, self.options, $b0d983e8249a2cc9$var$toOptions(host, port, localAddress));\n if (self.sockets.length >= this.maxSockets) {\n // We are over limit so we'll add it to the queue.\n self.requests.push(options);\n return;\n }\n // If we are under maxSockets create a new one.\n self.createSocket(options, function(socket) {\n socket.on(\"free\", onFree);\n socket.on(\"close\", onCloseOrRemove);\n socket.on(\"agentRemove\", onCloseOrRemove);\n req.onSocket(socket);\n function onFree() {\n self.emit(\"free\", socket, options);\n }\n function onCloseOrRemove(err) {\n self.removeSocket(socket);\n socket.removeListener(\"free\", onFree);\n socket.removeListener(\"close\", onCloseOrRemove);\n socket.removeListener(\"agentRemove\", onCloseOrRemove);\n }\n });\n};\n$b0d983e8249a2cc9$var$TunnelingAgent.prototype.createSocket = function createSocket(options, cb) {\n var self = this;\n var placeholder = {};\n self.sockets.push(placeholder);\n var connectOptions = $b0d983e8249a2cc9$var$mergeOptions({}, self.proxyOptions, {\n method: \"CONNECT\",\n path: options.host + \":\" + options.port,\n agent: false,\n headers: {\n host: options.host + \":\" + options.port\n }\n });\n if (options.localAddress) connectOptions.localAddress = options.localAddress;\n if (connectOptions.proxyAuth) {\n connectOptions.headers = connectOptions.headers || {};\n connectOptions.headers[\"Proxy-Authorization\"] = \"Basic \" + new Buffer(connectOptions.proxyAuth).toString(\"base64\");\n }\n $b0d983e8249a2cc9$var$debug(\"making CONNECT request\");\n var connectReq = self.request(connectOptions);\n connectReq.useChunkedEncodingByDefault = false; // for v0.6\n connectReq.once(\"response\", onResponse); // for v0.6\n connectReq.once(\"upgrade\", onUpgrade); // for v0.6\n connectReq.once(\"connect\", onConnect); // for v0.7 or later\n connectReq.once(\"error\", onError);\n connectReq.end();\n function onResponse(res) {\n // Very hacky. This is necessary to avoid http-parser leaks.\n res.upgrade = true;\n }\n function onUpgrade(res, socket, head) {\n // Hacky.\n process.nextTick(function() {\n onConnect(res, socket, head);\n });\n }\n function onConnect(res, socket, head) {\n connectReq.removeAllListeners();\n socket.removeAllListeners();\n if (res.statusCode !== 200) {\n $b0d983e8249a2cc9$var$debug(\"tunneling socket could not be established, statusCode=%d\", res.statusCode);\n socket.destroy();\n var error = new Error(\"tunneling socket could not be established, statusCode=\" + res.statusCode);\n error.code = \"ECONNRESET\";\n options.request.emit(\"error\", error);\n self.removeSocket(placeholder);\n return;\n }\n if (head.length > 0) {\n $b0d983e8249a2cc9$var$debug(\"got illegal response body from proxy\");\n socket.destroy();\n var error = new Error(\"got illegal response body from proxy\");\n error.code = \"ECONNRESET\";\n options.request.emit(\"error\", error);\n self.removeSocket(placeholder);\n return;\n }\n $b0d983e8249a2cc9$var$debug(\"tunneling connection has established\");\n self.sockets[self.sockets.indexOf(placeholder)] = socket;\n return cb(socket);\n }\n function onError(cause) {\n connectReq.removeAllListeners();\n $b0d983e8249a2cc9$var$debug(\"tunneling socket could not be established, cause=%s\\n\", cause.message, cause.stack);\n var error = new Error(\"tunneling socket could not be established, cause=\" + cause.message);\n error.code = \"ECONNRESET\";\n options.request.emit(\"error\", error);\n self.removeSocket(placeholder);\n }\n};\n$b0d983e8249a2cc9$var$TunnelingAgent.prototype.removeSocket = function removeSocket(socket) {\n var pos = this.sockets.indexOf(socket);\n if (pos === -1) return;\n this.sockets.splice(pos, 1);\n var pending = this.requests.shift();\n if (pending) // If we have pending requests and a socket gets closed a new one\n // needs to be created to take over in the pool for the one that closed.\n this.createSocket(pending, function(socket) {\n pending.request.onSocket(socket);\n });\n};\nfunction $b0d983e8249a2cc9$var$createSecureSocket(options, cb) {\n var self = this;\n $b0d983e8249a2cc9$var$TunnelingAgent.prototype.createSocket.call(self, options, function(socket) {\n var hostHeader = options.request.getHeader(\"host\");\n var tlsOptions = $b0d983e8249a2cc9$var$mergeOptions({}, self.options, {\n socket: socket,\n servername: hostHeader ? hostHeader.replace(/:.*$/, \"\") : options.host\n });\n // 0 is dummy port for v0.6\n var secureSocket = $d7DIX$tls.connect(0, tlsOptions);\n self.sockets[self.sockets.indexOf(socket)] = secureSocket;\n cb(secureSocket);\n });\n}\nfunction $b0d983e8249a2cc9$var$toOptions(host, port, localAddress) {\n if (typeof host === \"string\") return {\n host: host,\n port: port,\n localAddress: localAddress\n };\n return host; // for v0.11 or later\n}\nfunction $b0d983e8249a2cc9$var$mergeOptions(target) {\n for(var i = 1, len = arguments.length; i < len; ++i){\n var overrides = arguments[i];\n if (typeof overrides === \"object\") {\n var keys = Object.keys(overrides);\n for(var j = 0, keyLen = keys.length; j < keyLen; ++j){\n var k = keys[j];\n if (overrides[k] !== undefined) target[k] = overrides[k];\n }\n }\n }\n return target;\n}\nvar $b0d983e8249a2cc9$var$debug;\nif (process.env.NODE_DEBUG && /\\btunnel\\b/.test(process.env.NODE_DEBUG)) $b0d983e8249a2cc9$var$debug = function() {\n var args = Array.prototype.slice.call(arguments);\n if (typeof args[0] === \"string\") args[0] = \"TUNNEL: \" + args[0];\n else args.unshift(\"TUNNEL:\");\n console.error.apply(console, args);\n};\nelse $b0d983e8249a2cc9$var$debug = function() {};\n$b0d983e8249a2cc9$export$1c9f709888824e05 = $b0d983e8249a2cc9$var$debug; // for test\n\n});\n\n\n\nparcelRegister(\"3T6Pq\", function(module, exports) {\n\"use strict\";\nvar $2d4bce26bfd1284d$var$__awaiter = module.exports && module.exports.__awaiter || function(thisArg, _arguments, P, generator) {\n function adopt(value) {\n return value instanceof P ? value : new P(function(resolve) {\n resolve(value);\n });\n }\n return new (P || (P = Promise))(function(resolve, reject) {\n function fulfilled(value) {\n try {\n step(generator.next(value));\n } catch (e) {\n reject(e);\n }\n }\n function rejected(value) {\n try {\n step(generator[\"throw\"](value));\n } catch (e) {\n reject(e);\n }\n }\n function step(result) {\n result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);\n }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nObject.defineProperty(module.exports, \"__esModule\", {\n value: true\n});\nmodule.exports.PersonalAccessTokenCredentialHandler = module.exports.BearerCredentialHandler = module.exports.BasicCredentialHandler = void 0;\nclass $2d4bce26bfd1284d$var$BasicCredentialHandler {\n constructor(username, password){\n this.username = username;\n this.password = password;\n }\n prepareRequest(options) {\n if (!options.headers) throw Error(\"The request has no headers\");\n options.headers[\"Authorization\"] = `Basic ${Buffer.from(`${this.username}:${this.password}`).toString(\"base64\")}`;\n }\n // This handler cannot handle 401\n canHandleAuthentication() {\n return false;\n }\n handleAuthentication() {\n return $2d4bce26bfd1284d$var$__awaiter(this, void 0, void 0, function*() {\n throw new Error(\"not implemented\");\n });\n }\n}\nmodule.exports.BasicCredentialHandler = $2d4bce26bfd1284d$var$BasicCredentialHandler;\nclass $2d4bce26bfd1284d$var$BearerCredentialHandler {\n constructor(token){\n this.token = token;\n }\n // currently implements pre-authorization\n // TODO: support preAuth = false where it hooks on 401\n prepareRequest(options) {\n if (!options.headers) throw Error(\"The request has no headers\");\n options.headers[\"Authorization\"] = `Bearer ${this.token}`;\n }\n // This handler cannot handle 401\n canHandleAuthentication() {\n return false;\n }\n handleAuthentication() {\n return $2d4bce26bfd1284d$var$__awaiter(this, void 0, void 0, function*() {\n throw new Error(\"not implemented\");\n });\n }\n}\nmodule.exports.BearerCredentialHandler = $2d4bce26bfd1284d$var$BearerCredentialHandler;\nclass $2d4bce26bfd1284d$var$PersonalAccessTokenCredentialHandler {\n constructor(token){\n this.token = token;\n }\n // currently implements pre-authorization\n // TODO: support preAuth = false where it hooks on 401\n prepareRequest(options) {\n if (!options.headers) throw Error(\"The request has no headers\");\n options.headers[\"Authorization\"] = `Basic ${Buffer.from(`PAT:${this.token}`).toString(\"base64\")}`;\n }\n // This handler cannot handle 401\n canHandleAuthentication() {\n return false;\n }\n handleAuthentication() {\n return $2d4bce26bfd1284d$var$__awaiter(this, void 0, void 0, function*() {\n throw new Error(\"not implemented\");\n });\n }\n}\nmodule.exports.PersonalAccessTokenCredentialHandler = $2d4bce26bfd1284d$var$PersonalAccessTokenCredentialHandler;\n\n});\n\n\nparcelRegister(\"dTpO2\", function(module, exports) {\n\"use strict\";\nvar $a1d46df778449c59$var$__awaiter = module.exports && module.exports.__awaiter || function(thisArg, _arguments, P, generator) {\n function adopt(value) {\n return value instanceof P ? value : new P(function(resolve) {\n resolve(value);\n });\n }\n return new (P || (P = Promise))(function(resolve, reject) {\n function fulfilled(value) {\n try {\n step(generator.next(value));\n } catch (e) {\n reject(e);\n }\n }\n function rejected(value) {\n try {\n step(generator[\"throw\"](value));\n } catch (e) {\n reject(e);\n }\n }\n function step(result) {\n result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);\n }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nObject.defineProperty(module.exports, \"__esModule\", {\n value: true\n});\nmodule.exports.summary = module.exports.markdownSummary = module.exports.SUMMARY_DOCS_URL = module.exports.SUMMARY_ENV_VAR = void 0;\n\n\nconst { access: $a1d46df778449c59$var$access, appendFile: $a1d46df778449c59$var$appendFile, writeFile: $a1d46df778449c59$var$writeFile } = $d7DIX$fs.promises;\nmodule.exports.SUMMARY_ENV_VAR = \"GITHUB_STEP_SUMMARY\";\nmodule.exports.SUMMARY_DOCS_URL = \"https://docs.github.com/actions/using-workflows/workflow-commands-for-github-actions#adding-a-job-summary\";\nclass $a1d46df778449c59$var$Summary {\n constructor(){\n this._buffer = \"\";\n }\n /**\n * Finds the summary file path from the environment, rejects if env var is not found or file does not exist\n * Also checks r/w permissions.\n *\n * @returns step summary file path\n */ filePath() {\n return $a1d46df778449c59$var$__awaiter(this, void 0, void 0, function*() {\n if (this._filePath) return this._filePath;\n const pathFromEnv = process.env[module.exports.SUMMARY_ENV_VAR];\n if (!pathFromEnv) throw new Error(`Unable to find environment variable for $${module.exports.SUMMARY_ENV_VAR}. Check if your runtime environment supports job summaries.`);\n try {\n yield $a1d46df778449c59$var$access(pathFromEnv, $d7DIX$fs.constants.R_OK | $d7DIX$fs.constants.W_OK);\n } catch (_a) {\n throw new Error(`Unable to access summary file: '${pathFromEnv}'. Check if the file has correct read/write permissions.`);\n }\n this._filePath = pathFromEnv;\n return this._filePath;\n });\n }\n /**\n * Wraps content in an HTML tag, adding any HTML attributes\n *\n * @param {string} tag HTML tag to wrap\n * @param {string | null} content content within the tag\n * @param {[attribute: string]: string} attrs key-value list of HTML attributes to add\n *\n * @returns {string} content wrapped in HTML element\n */ wrap(tag, content, attrs = {}) {\n const htmlAttrs = Object.entries(attrs).map(([key, value])=>` ${key}=\"${value}\"`).join(\"\");\n if (!content) return `<${tag}${htmlAttrs}>`;\n return `<${tag}${htmlAttrs}>${content}`;\n }\n /**\n * Writes text in the buffer to the summary buffer file and empties buffer. Will append by default.\n *\n * @param {SummaryWriteOptions} [options] (optional) options for write operation\n *\n * @returns {Promise} summary instance\n */ write(options) {\n return $a1d46df778449c59$var$__awaiter(this, void 0, void 0, function*() {\n const overwrite = !!(options === null || options === void 0 ? void 0 : options.overwrite);\n const filePath = yield this.filePath();\n const writeFunc = overwrite ? $a1d46df778449c59$var$writeFile : $a1d46df778449c59$var$appendFile;\n yield writeFunc(filePath, this._buffer, {\n encoding: \"utf8\"\n });\n return this.emptyBuffer();\n });\n }\n /**\n * Clears the summary buffer and wipes the summary file\n *\n * @returns {Summary} summary instance\n */ clear() {\n return $a1d46df778449c59$var$__awaiter(this, void 0, void 0, function*() {\n return this.emptyBuffer().write({\n overwrite: true\n });\n });\n }\n /**\n * Returns the current summary buffer as a string\n *\n * @returns {string} string of summary buffer\n */ stringify() {\n return this._buffer;\n }\n /**\n * If the summary buffer is empty\n *\n * @returns {boolen} true if the buffer is empty\n */ isEmptyBuffer() {\n return this._buffer.length === 0;\n }\n /**\n * Resets the summary buffer without writing to summary file\n *\n * @returns {Summary} summary instance\n */ emptyBuffer() {\n this._buffer = \"\";\n return this;\n }\n /**\n * Adds raw text to the summary buffer\n *\n * @param {string} text content to add\n * @param {boolean} [addEOL=false] (optional) append an EOL to the raw text (default: false)\n *\n * @returns {Summary} summary instance\n */ addRaw(text, addEOL = false) {\n this._buffer += text;\n return addEOL ? this.addEOL() : this;\n }\n /**\n * Adds the operating system-specific end-of-line marker to the buffer\n *\n * @returns {Summary} summary instance\n */ addEOL() {\n return this.addRaw($d7DIX$os.EOL);\n }\n /**\n * Adds an HTML codeblock to the summary buffer\n *\n * @param {string} code content to render within fenced code block\n * @param {string} lang (optional) language to syntax highlight code\n *\n * @returns {Summary} summary instance\n */ addCodeBlock(code, lang) {\n const attrs = Object.assign({}, lang && {\n lang: lang\n });\n const element = this.wrap(\"pre\", this.wrap(\"code\", code), attrs);\n return this.addRaw(element).addEOL();\n }\n /**\n * Adds an HTML list to the summary buffer\n *\n * @param {string[]} items list of items to render\n * @param {boolean} [ordered=false] (optional) if the rendered list should be ordered or not (default: false)\n *\n * @returns {Summary} summary instance\n */ addList(items, ordered = false) {\n const tag = ordered ? \"ol\" : \"ul\";\n const listItems = items.map((item)=>this.wrap(\"li\", item)).join(\"\");\n const element = this.wrap(tag, listItems);\n return this.addRaw(element).addEOL();\n }\n /**\n * Adds an HTML table to the summary buffer\n *\n * @param {SummaryTableCell[]} rows table rows\n *\n * @returns {Summary} summary instance\n */ addTable(rows) {\n const tableBody = rows.map((row)=>{\n const cells = row.map((cell)=>{\n if (typeof cell === \"string\") return this.wrap(\"td\", cell);\n const { header: header, data: data, colspan: colspan, rowspan: rowspan } = cell;\n const tag = header ? \"th\" : \"td\";\n const attrs = Object.assign(Object.assign({}, colspan && {\n colspan: colspan\n }), rowspan && {\n rowspan: rowspan\n });\n return this.wrap(tag, data, attrs);\n }).join(\"\");\n return this.wrap(\"tr\", cells);\n }).join(\"\");\n const element = this.wrap(\"table\", tableBody);\n return this.addRaw(element).addEOL();\n }\n /**\n * Adds a collapsable HTML details element to the summary buffer\n *\n * @param {string} label text for the closed state\n * @param {string} content collapsable content\n *\n * @returns {Summary} summary instance\n */ addDetails(label, content) {\n const element = this.wrap(\"details\", this.wrap(\"summary\", label) + content);\n return this.addRaw(element).addEOL();\n }\n /**\n * Adds an HTML image tag to the summary buffer\n *\n * @param {string} src path to the image you to embed\n * @param {string} alt text description of the image\n * @param {SummaryImageOptions} options (optional) addition image attributes\n *\n * @returns {Summary} summary instance\n */ addImage(src, alt, options) {\n const { width: width, height: height } = options || {};\n const attrs = Object.assign(Object.assign({}, width && {\n width: width\n }), height && {\n height: height\n });\n const element = this.wrap(\"img\", null, Object.assign({\n src: src,\n alt: alt\n }, attrs));\n return this.addRaw(element).addEOL();\n }\n /**\n * Adds an HTML section heading element\n *\n * @param {string} text heading text\n * @param {number | string} [level=1] (optional) the heading level, default: 1\n *\n * @returns {Summary} summary instance\n */ addHeading(text, level) {\n const tag = `h${level}`;\n const allowedTag = [\n \"h1\",\n \"h2\",\n \"h3\",\n \"h4\",\n \"h5\",\n \"h6\"\n ].includes(tag) ? tag : \"h1\";\n const element = this.wrap(allowedTag, text);\n return this.addRaw(element).addEOL();\n }\n /**\n * Adds an HTML thematic break (
) to the summary buffer\n *\n * @returns {Summary} summary instance\n */ addSeparator() {\n const element = this.wrap(\"hr\", null);\n return this.addRaw(element).addEOL();\n }\n /**\n * Adds an HTML line break (
) to the summary buffer\n *\n * @returns {Summary} summary instance\n */ addBreak() {\n const element = this.wrap(\"br\", null);\n return this.addRaw(element).addEOL();\n }\n /**\n * Adds an HTML blockquote to the summary buffer\n *\n * @param {string} text quote text\n * @param {string} cite (optional) citation url\n *\n * @returns {Summary} summary instance\n */ addQuote(text, cite) {\n const attrs = Object.assign({}, cite && {\n cite: cite\n });\n const element = this.wrap(\"blockquote\", text, attrs);\n return this.addRaw(element).addEOL();\n }\n /**\n * Adds an HTML anchor tag to the summary buffer\n *\n * @param {string} text link text/content\n * @param {string} href hyperlink\n *\n * @returns {Summary} summary instance\n */ addLink(text, href) {\n const element = this.wrap(\"a\", text, {\n href: href\n });\n return this.addRaw(element).addEOL();\n }\n}\nconst $a1d46df778449c59$var$_summary = new $a1d46df778449c59$var$Summary();\n/**\n * @deprecated use `core.summary`\n */ module.exports.markdownSummary = $a1d46df778449c59$var$_summary;\nmodule.exports.summary = $a1d46df778449c59$var$_summary;\n\n});\n\nparcelRegister(\"azKnO\", function(module, exports) {\n\"use strict\";\nvar $7b3126f8d7bd7b01$var$__createBinding = module.exports && module.exports.__createBinding || (Object.create ? function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n Object.defineProperty(o, k2, {\n enumerable: true,\n get: function() {\n return m[k];\n }\n });\n} : function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n o[k2] = m[k];\n});\nvar $7b3126f8d7bd7b01$var$__setModuleDefault = module.exports && module.exports.__setModuleDefault || (Object.create ? function(o, v) {\n Object.defineProperty(o, \"default\", {\n enumerable: true,\n value: v\n });\n} : function(o, v) {\n o[\"default\"] = v;\n});\nvar $7b3126f8d7bd7b01$var$__importStar = module.exports && module.exports.__importStar || function(mod) {\n if (mod && mod.__esModule) return mod;\n var result = {};\n if (mod != null) {\n for(var k in mod)if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) $7b3126f8d7bd7b01$var$__createBinding(result, mod, k);\n }\n $7b3126f8d7bd7b01$var$__setModuleDefault(result, mod);\n return result;\n};\nObject.defineProperty(module.exports, \"__esModule\", {\n value: true\n});\nmodule.exports.toPlatformPath = module.exports.toWin32Path = module.exports.toPosixPath = void 0;\n\nconst $7b3126f8d7bd7b01$var$path = $7b3126f8d7bd7b01$var$__importStar($d7DIX$path);\n/**\n * toPosixPath converts the given path to the posix form. On Windows, \\\\ will be\n * replaced with /.\n *\n * @param pth. Path to transform.\n * @return string Posix path.\n */ function $7b3126f8d7bd7b01$var$toPosixPath(pth) {\n return pth.replace(/[\\\\]/g, \"/\");\n}\nmodule.exports.toPosixPath = $7b3126f8d7bd7b01$var$toPosixPath;\n/**\n * toWin32Path converts the given path to the win32 form. On Linux, / will be\n * replaced with \\\\.\n *\n * @param pth. Path to transform.\n * @return string Win32 path.\n */ function $7b3126f8d7bd7b01$var$toWin32Path(pth) {\n return pth.replace(/[/]/g, \"\\\\\");\n}\nmodule.exports.toWin32Path = $7b3126f8d7bd7b01$var$toWin32Path;\n/**\n * toPlatformPath converts the given path to a platform-specific path. It does\n * this by replacing instances of / and \\ with the platform-specific path\n * separator.\n *\n * @param pth The path to platformize.\n * @return string The platform-specific path.\n */ function $7b3126f8d7bd7b01$var$toPlatformPath(pth) {\n return pth.replace(/[/\\\\]/g, $7b3126f8d7bd7b01$var$path.sep);\n}\nmodule.exports.toPlatformPath = $7b3126f8d7bd7b01$var$toPlatformPath;\n\n});\n\n\n\nparcelRegister(\"eCDnw\", function(module, exports) {\n\nvar $aa532906b08b4bb5$var$$parcel$__dirname = $d7DIX$path.resolve(__dirname, \"../../node_modules/numerous/lib\");\n(function() {\n \"use strict\";\n var root = this;\n //=========//\n // GLOBALS //\n //=========//\n var locales = {};\n //==========//\n // EXPOSING //\n //==========//\n var moduleDefinition = {\n create: factory,\n addLocale: addLocale,\n pluralize: pluralize\n };\n if (\"undefined\" !== typeof module.exports) module.exports = moduleDefinition;\n else root.numerous = moduleDefinition;\n //==================//\n // PUBLIC FUNCTIONS //\n //==================//\n /**\n * Creates new instance of numerous.\n *\n * @param {string} locale\n * @returns {object}\n */ function factory(locale) {\n checkLocale(locale);\n return {\n pluralize: function(value, variants) {\n return pluralize(locale, value, variants);\n }\n };\n }\n /**\n * Adds pluralization function for specified locale.\n * Usually externally called by locale itself.\n *\n * @param {string} locale\n * @param {function} callable\n */ function addLocale(locale, callable) {\n locales[locale] = callable;\n }\n /**\n * Returns variant from the specified list of variants\n * according to the specified value and locale.\n *\n * @param {string} locale\n * @param {int} value\n * @param {object} variants\n */ function pluralize(locale, value, variants) {\n checkLocale(locale);\n if (\"object\" !== typeof variants) throw new Error(\"List of variants should be specified as an object\");\n var key = locales[locale](value);\n return \"undefined\" !== typeof variants[key] ? variants[key] : null;\n }\n //===================//\n // PRIVATE FUNCTIONS //\n //===================//\n /**\n * Returns true if specified locale is loaded, false otherwise.\n *\n * @param {string} locale\n *\n * @returns {boolean}\n */ function hasLocale(locale) {\n return \"undefined\" !== typeof locales[locale];\n }\n /**\n * Checks if locale is loaded. If not, tries to load it.\n *\n * @param {string} locale\n */ function checkLocale(locale) {\n if (!hasLocale(locale)) requireLocale(locale);\n }\n /**\n * Tries to load the specified locale.\n *\n * @param {string} locale\n */ function requireLocale(locale) {\n try {\n require($aa532906b08b4bb5$var$$parcel$__dirname + \"/../locales/\" + locale + \".js\");\n } catch (error) {\n throw Error(\"Failed to load the following locale: \" + locale);\n }\n }\n}).call(module.exports);\n\n});\n\nparcelRegister(\"gMm9F\", function(module, exports) {\n//==============//\n// DEPENDENCIES //\n//==============//\n\nvar $iWDmx = parcelRequire(\"iWDmx\");\n\nvar $9xs9T = parcelRequire(\"9xs9T\");\n//================//\n// MODULE GLOBALS //\n//================//\n/**\n * Pre-calculating millisecond values for each time unit.\n */ const $c372508a6b96a969$var$timeUnits = [\n [\n \"years\",\n 29030400000\n ],\n [\n \"months\",\n 2419200000\n ],\n [\n \"weeks\",\n 604800000\n ],\n [\n \"days\",\n 86400000\n ],\n [\n \"hours\",\n 3600000\n ],\n [\n \"minutes\",\n 60000\n ],\n [\n \"seconds\",\n 1000\n ]\n];\nconst $c372508a6b96a969$var$defaultConfig = {\n locale: \"en\",\n span: 2,\n delimiter: \", \",\n unitType: \"long\",\n unitTypeLookupOrder: [\n \"long\",\n \"short\",\n \"narrow\"\n ],\n autoloadLocales: true\n};\n/**\n * Contains data of loaded locales.\n * @type {Object}\n */ const $c372508a6b96a969$var$locales = {};\n//=========//\n// EXPORTS //\n//=========//\nmodule.exports = {\n create: $c372508a6b96a969$var$timeDeltaFactory,\n addLocale: $c372508a6b96a969$var$addLocale,\n defaultConfig: $c372508a6b96a969$var$defaultConfig\n};\n//===========//\n// FUNCTIONS //\n//===========//\n/**\n * Adds pluralization data for the specified locale.\n * Should be called in browser.\n *\n * @param {Object|Object[]} localeData\n */ function $c372508a6b96a969$var$addLocale(localeData) {\n // Normalizing input\n if (!Array.isArray(localeData)) localeData = [\n localeData\n ];\n for (const item of localeData){\n const { id: id, data: data } = item;\n $c372508a6b96a969$var$locales[id] = data;\n }\n}\n/**\n * Creates new instance.\n *\n * @param {object?} config\n *\n * @returns {object}\n */ function $c372508a6b96a969$var$timeDeltaFactory(config) {\n // Initializing config by extending the default one\n config = Object.assign({}, $c372508a6b96a969$var$defaultConfig, config || {});\n return {\n /**\n * Public proxy for internal format function.\n *\n * @param {Date} firstDate\n * @param {Date} secondDate\n * @param {object?} options\n *\n * @returns {string}\n */ format: function(firstDate, secondDate, options) {\n // Allowing to override config with each individual call\n options = Object.assign({}, config, options || {});\n return $c372508a6b96a969$var$format(firstDate, secondDate, options);\n }\n };\n}\n/**\n * Returns difference between two dates as a text string.\n *\n * @param {Date} firstDate\n * @param {Date} secondDate\n * @param {object} config\n *\n * @returns {string}\n */ function $c372508a6b96a969$var$format(firstDate, secondDate, config) {\n $c372508a6b96a969$var$ensureLocaleLoadedOrThrow(config.locale, {\n autoload: config.autoloadLocales\n });\n // Handling input arguments\n // -----\n if (!firstDate) throw new Error(\"Missing first date argument\");\n if (!secondDate) throw new Error(\"Missing second date argument\");\n // Calculating\n // -----\n const difference = $c372508a6b96a969$var$getDifference(firstDate, secondDate);\n const parts = [];\n for (const unit of difference){\n const [name, value] = unit;\n if (value > 0) parts.push($c372508a6b96a969$var$pluralize(name, value, config));\n if (parts.length >= config.span) break;\n }\n // Returning the string value\n return parts.join(config.delimiter);\n}\n/**\n * Checks if locale is loaded. If not, tries to load it in Node.js,\n * or throws and error in Browser.\n *\n * @param {string} locale\n * @param {Object?} options\n */ function $c372508a6b96a969$var$ensureLocaleLoadedOrThrow(locale, options) {\n const { autoload: autoload } = options;\n if ($c372508a6b96a969$var$hasLocale(locale)) return;\n if ($9xs9T && autoload) $c372508a6b96a969$var$requireLocale(locale);\n else throw new Error(`Missing locale: ${locale}, you must load it manually before using it`);\n}\n/**\n * Returns true if specified locale is loaded, false otherwise.\n *\n * @param {string} localeId\n *\n * @returns {boolean}\n */ function $c372508a6b96a969$var$hasLocale(localeId) {\n return Boolean($c372508a6b96a969$var$locales[localeId]);\n}\n/**\n * Tries to load the specified locale.\n *\n * @param {string} localeId\n */ function $c372508a6b96a969$var$requireLocale(localeId) {\n try {\n $c372508a6b96a969$var$addLocale(require(`../locales/${localeId}.js`));\n } catch (error) {\n throw Error(`Failed to load locale: ${localeId} from ../locales/${localeId}.js. If using a bundled time-delta, set 'autoloadLocales: false' in the config: ${error}`);\n }\n}\n/**\n * Returns difference as separate time units.\n *\n * @param {Date} firstDate\n * @param {Date} secondDate\n *\n * @returns {Array}\n */ function $c372508a6b96a969$var$getDifference(firstDate, secondDate) {\n let difference = secondDate - firstDate;\n const results = [];\n $c372508a6b96a969$var$timeUnits.some(function(unit) {\n const name = unit[0];\n const divider = unit[1];\n const value = Math.floor(difference / divider);\n difference -= value * divider;\n results.push([\n name,\n value\n ]);\n if (difference <= 0) // Breaking the loop.\n return true;\n });\n return results;\n}\n/**\n * Returns localized and pluralized time unit.\n *\n * @param {string} unit\n * @param {int} value\n * @param {object} config\n *\n * @returns {string}\n */ function $c372508a6b96a969$var$pluralize(unit, value, config) {\n const unitTypeData = $c372508a6b96a969$var$getLocaleDataForUnitType(config);\n const unitString = $iWDmx.pluralize(config.locale, value, unitTypeData[unit]);\n return unitString.replace(\"{0}\", value);\n}\n/**\n * Returns locale data for preferred unit type.\n *\n * @param {object} config\n *\n * @returns {Array}\n */ function $c372508a6b96a969$var$getLocaleDataForUnitType(config) {\n const localeData = $c372508a6b96a969$var$locales[config.locale];\n // Making a copy of array from config.\n let lookupOrder = config.unitTypeLookupOrder.slice();\n // Adding interested type to the top.\n lookupOrder.unshift(config.unitType);\n // Making sure only unique items are present.\n lookupOrder = $c372508a6b96a969$var$arrayUnique(lookupOrder);\n let unitTypeData = null;\n lookupOrder.some(function(unitType) {\n if (\"undefined\" !== typeof localeData[unitType]) {\n unitTypeData = localeData[unitType];\n // Breaking the loop.\n return true;\n }\n });\n if (null === unitTypeData) throw new Error(\"Can not find any unit type data for locale: \" + config.locale);\n return unitTypeData;\n}\n/**\n * Returns array with only unique items.\n *\n * @param {Array} array\n *\n * @returns {Array}\n */ function $c372508a6b96a969$var$arrayUnique(array) {\n return Array.from(new Set(array));\n}\n\n});\nparcelRegister(\"iWDmx\", function(module, exports) {\n\nmodule.exports = (parcelRequire(\"eCDnw\"));\n\n});\n\nparcelRegister(\"9xs9T\", function(module, exports) {\n// Coding standard for this project defined @ https://github.com/MatthewSH/standards/blob/master/JavaScript.md\n\"use strict\";\nexports = module.exports = !!(typeof process !== \"undefined\" && process.versions && process.versions.node);\n\n});\n\n\nparcelRegister(\"bGwAu\", function(module, exports) {\nmodule.exports = $881ce52b35d88d20$var$isexe;\n$881ce52b35d88d20$var$isexe.sync = $881ce52b35d88d20$var$sync;\n\nfunction $881ce52b35d88d20$var$checkPathExt(path, options) {\n var pathext = options.pathExt !== undefined ? options.pathExt : process.env.PATHEXT;\n if (!pathext) return true;\n pathext = pathext.split(\";\");\n if (pathext.indexOf(\"\") !== -1) return true;\n for(var i = 0; i < pathext.length; i++){\n var p = pathext[i].toLowerCase();\n if (p && path.substr(-p.length).toLowerCase() === p) return true;\n }\n return false;\n}\nfunction $881ce52b35d88d20$var$checkStat(stat, path, options) {\n if (!stat.isSymbolicLink() && !stat.isFile()) return false;\n return $881ce52b35d88d20$var$checkPathExt(path, options);\n}\nfunction $881ce52b35d88d20$var$isexe(path, options, cb) {\n $d7DIX$fs.stat(path, function(er, stat) {\n cb(er, er ? false : $881ce52b35d88d20$var$checkStat(stat, path, options));\n });\n}\nfunction $881ce52b35d88d20$var$sync(path, options) {\n return $881ce52b35d88d20$var$checkStat($d7DIX$fs.statSync(path), path, options);\n}\n\n});\n\nparcelRegister(\"d3qS7\", function(module, exports) {\nmodule.exports = $9810665efbefe038$var$isexe;\n$9810665efbefe038$var$isexe.sync = $9810665efbefe038$var$sync;\n\nfunction $9810665efbefe038$var$isexe(path, options, cb) {\n $d7DIX$fs.stat(path, function(er, stat) {\n cb(er, er ? false : $9810665efbefe038$var$checkStat(stat, options));\n });\n}\nfunction $9810665efbefe038$var$sync(path, options) {\n return $9810665efbefe038$var$checkStat($d7DIX$fs.statSync(path), options);\n}\nfunction $9810665efbefe038$var$checkStat(stat, options) {\n return stat.isFile() && $9810665efbefe038$var$checkMode(stat, options);\n}\nfunction $9810665efbefe038$var$checkMode(stat, options) {\n var mod = stat.mode;\n var uid = stat.uid;\n var gid = stat.gid;\n var myUid = options.uid !== undefined ? options.uid : process.getuid && process.getuid();\n var myGid = options.gid !== undefined ? options.gid : process.getgid && process.getgid();\n var u = parseInt(\"100\", 8);\n var g = parseInt(\"010\", 8);\n var o = parseInt(\"001\", 8);\n var ug = u | g;\n var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;\n return ret;\n}\n\n});\n\nparcelRegister(\"e1Rfe\", function(module, exports) {\n// This is not the set of all possible signals.\n//\n// It IS, however, the set of all signals that trigger\n// an exit on either Linux or BSD systems. Linux is a\n// superset of the signal names supported on BSD, and\n// the unknown signals just fail to register, so we can\n// catch that easily enough.\n//\n// Don't bother with SIGKILL. It's uncatchable, which\n// means that we can't fire any callbacks anyway.\n//\n// If a user does happen to register a handler on a non-\n// fatal signal like SIGWINCH or something, and then\n// exit, it'll end up firing `process.emit('exit')`, so\n// the handler will be fired anyway.\n//\n// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised\n// artificially, inherently leave the process in a\n// state from which it is not safe to try and enter JS\n// listeners.\nmodule.exports = [\n \"SIGABRT\",\n \"SIGALRM\",\n \"SIGHUP\",\n \"SIGINT\",\n \"SIGTERM\"\n];\nif (process.platform !== \"win32\") module.exports.push(\"SIGVTALRM\", \"SIGXCPU\", \"SIGXFSZ\", \"SIGUSR2\", \"SIGTRAP\", \"SIGSYS\", \"SIGQUIT\", \"SIGIOT\");\nif (process.platform === \"linux\") module.exports.push(\"SIGIO\", \"SIGPOLL\", \"SIGPWR\", \"SIGSTKFLT\", \"SIGUNUSED\");\n\n});\n\nparcelRegister(\"bSUdl\", function(module, exports) {\n// just pre-load all the stuff that index.js lazily exports\n\nvar $9J5od = parcelRequire(\"9J5od\");\n\nvar $3qgxS = parcelRequire(\"3qgxS\");\n\nvar $aMLnW = parcelRequire(\"aMLnW\");\n\nvar $fx8Ft = parcelRequire(\"fx8Ft\");\n\nvar $UI3XL = parcelRequire(\"UI3XL\");\n\nvar $l655J = parcelRequire(\"l655J\");\n\nvar $jzJq8 = parcelRequire(\"jzJq8\");\n\nvar $b1nH1 = parcelRequire(\"b1nH1\");\n\nvar $inG4j = parcelRequire(\"inG4j\");\n\nvar $2aJGP = parcelRequire(\"2aJGP\");\n\nvar $h6Ixq = parcelRequire(\"h6Ixq\");\n\nvar $90ROK = parcelRequire(\"90ROK\");\n\nvar $8m4O1 = parcelRequire(\"8m4O1\");\n\nvar $3uysP = parcelRequire(\"3uysP\");\n\nvar $hYBTv = parcelRequire(\"hYBTv\");\n\nvar $ftcZo = parcelRequire(\"ftcZo\");\n\nvar $1CIrW = parcelRequire(\"1CIrW\");\n\nvar $exBHN = parcelRequire(\"exBHN\");\n\nvar $lm1lq = parcelRequire(\"lm1lq\");\n\nvar $cPjhN = parcelRequire(\"cPjhN\");\n\nvar $avz3V = parcelRequire(\"avz3V\");\n\nvar $fXQFJ = parcelRequire(\"fXQFJ\");\n\nvar $bu0Ra = parcelRequire(\"bu0Ra\");\n\nvar $9xdhv = parcelRequire(\"9xdhv\");\n\nvar $8aNoG = parcelRequire(\"8aNoG\");\n\nvar $8gipG = parcelRequire(\"8gipG\");\n\nvar $l8hao = parcelRequire(\"l8hao\");\n\nvar $dSz9p = parcelRequire(\"dSz9p\");\n\nvar $4FTez = parcelRequire(\"4FTez\");\n\nvar $2bU8Y = parcelRequire(\"2bU8Y\");\n\nvar $eRnrA = parcelRequire(\"eRnrA\");\n\nvar $aAvhf = parcelRequire(\"aAvhf\");\n\nvar $iWAcu = parcelRequire(\"iWAcu\");\n\nvar $32TwK = parcelRequire(\"32TwK\");\n\nvar $194Ox = parcelRequire(\"194Ox\");\n\nvar $a8VZj = parcelRequire(\"a8VZj\");\n\nvar $2yv5J = parcelRequire(\"2yv5J\");\n\nvar $46KXA = parcelRequire(\"46KXA\");\n\nvar $e3Thp = parcelRequire(\"e3Thp\");\n\nvar $8g51l = parcelRequire(\"8g51l\");\n\nvar $96YVB = parcelRequire(\"96YVB\");\nmodule.exports = {\n parse: $UI3XL,\n valid: $l655J,\n clean: $jzJq8,\n inc: $b1nH1,\n diff: $inG4j,\n major: $2aJGP,\n minor: $h6Ixq,\n patch: $90ROK,\n prerelease: $8m4O1,\n compare: $3uysP,\n rcompare: $hYBTv,\n compareLoose: $ftcZo,\n compareBuild: $1CIrW,\n sort: $exBHN,\n rsort: $lm1lq,\n gt: $cPjhN,\n lt: $avz3V,\n eq: $fXQFJ,\n neq: $bu0Ra,\n gte: $9xdhv,\n lte: $8aNoG,\n cmp: $8gipG,\n coerce: $l8hao,\n Comparator: $dSz9p,\n Range: $4FTez,\n satisfies: $2bU8Y,\n toComparators: $eRnrA,\n maxSatisfying: $aAvhf,\n minSatisfying: $iWAcu,\n minVersion: $32TwK,\n validRange: $194Ox,\n outside: $a8VZj,\n gtr: $2yv5J,\n ltr: $46KXA,\n intersects: $e3Thp,\n simplifyRange: $8g51l,\n subset: $96YVB,\n SemVer: $aMLnW,\n re: $9J5od.re,\n src: $9J5od.src,\n tokens: $9J5od.t,\n SEMVER_SPEC_VERSION: $3qgxS.SEMVER_SPEC_VERSION,\n RELEASE_TYPES: $3qgxS.RELEASE_TYPES,\n compareIdentifiers: $fx8Ft.compareIdentifiers,\n rcompareIdentifiers: $fx8Ft.rcompareIdentifiers\n};\n\n});\nparcelRegister(\"9J5od\", function(module, exports) {\n\nvar $3qgxS = parcelRequire(\"3qgxS\");\nvar $714c7f42b7f0e43a$require$MAX_SAFE_COMPONENT_LENGTH = $3qgxS.MAX_SAFE_COMPONENT_LENGTH;\nvar $714c7f42b7f0e43a$require$MAX_SAFE_BUILD_LENGTH = $3qgxS.MAX_SAFE_BUILD_LENGTH;\nvar $714c7f42b7f0e43a$require$MAX_LENGTH = $3qgxS.MAX_LENGTH;\n\nvar $3CqZ1 = parcelRequire(\"3CqZ1\");\nexports = module.exports = {};\n// The actual regexps go on exports.re\nconst re = exports.re = [];\nconst safeRe = exports.safeRe = [];\nconst src = exports.src = [];\nconst t = exports.t = {};\nlet R = 0;\nconst LETTERDASHNUMBER = \"[a-zA-Z0-9-]\";\n// Replace some greedy regex tokens to prevent regex dos issues. These regex are\n// used internally via the safeRe object since all inputs in this library get\n// normalized first to trim and collapse all extra whitespace. The original\n// regexes are exported for userland consumption and lower level usage. A\n// future breaking change could export the safer regex only with a note that\n// all input should have extra whitespace removed.\nconst safeRegexReplacements = [\n [\n \"\\\\s\",\n 1\n ],\n [\n \"\\\\d\",\n $714c7f42b7f0e43a$require$MAX_LENGTH\n ],\n [\n LETTERDASHNUMBER,\n $714c7f42b7f0e43a$require$MAX_SAFE_BUILD_LENGTH\n ]\n];\nconst makeSafeRegex = (value)=>{\n for (const [token, max] of safeRegexReplacements)value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);\n return value;\n};\nconst createToken = (name, value, isGlobal)=>{\n const safe = makeSafeRegex(value);\n const index = R++;\n $3CqZ1(name, index, value);\n t[name] = index;\n src[index] = value;\n re[index] = new RegExp(value, isGlobal ? \"g\" : undefined);\n safeRe[index] = new RegExp(safe, isGlobal ? \"g\" : undefined);\n};\n// The following Regular Expressions can be used for tokenizing,\n// validating, and parsing SemVer version strings.\n// ## Numeric Identifier\n// A single `0`, or a non-zero digit followed by zero or more digits.\ncreateToken(\"NUMERICIDENTIFIER\", \"0|[1-9]\\\\d*\");\ncreateToken(\"NUMERICIDENTIFIERLOOSE\", \"\\\\d+\");\n// ## Non-numeric Identifier\n// Zero or more digits, followed by a letter or hyphen, and then zero or\n// more letters, digits, or hyphens.\ncreateToken(\"NONNUMERICIDENTIFIER\", `\\\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);\n// ## Main Version\n// Three dot-separated numeric identifiers.\ncreateToken(\"MAINVERSION\", `(${src[t.NUMERICIDENTIFIER]})\\\\.` + `(${src[t.NUMERICIDENTIFIER]})\\\\.` + `(${src[t.NUMERICIDENTIFIER]})`);\ncreateToken(\"MAINVERSIONLOOSE\", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\\\.` + `(${src[t.NUMERICIDENTIFIERLOOSE]})\\\\.` + `(${src[t.NUMERICIDENTIFIERLOOSE]})`);\n// ## Pre-release Version Identifier\n// A numeric identifier, or a non-numeric identifier.\ncreateToken(\"PRERELEASEIDENTIFIER\", `(?:${src[t.NUMERICIDENTIFIER]}|${src[t.NONNUMERICIDENTIFIER]})`);\ncreateToken(\"PRERELEASEIDENTIFIERLOOSE\", `(?:${src[t.NUMERICIDENTIFIERLOOSE]}|${src[t.NONNUMERICIDENTIFIER]})`);\n// ## Pre-release Version\n// Hyphen, followed by one or more dot-separated pre-release version\n// identifiers.\ncreateToken(\"PRERELEASE\", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\\\.${src[t.PRERELEASEIDENTIFIER]})*))`);\ncreateToken(\"PRERELEASELOOSE\", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);\n// ## Build Metadata Identifier\n// Any combination of digits, letters, or hyphens.\ncreateToken(\"BUILDIDENTIFIER\", `${LETTERDASHNUMBER}+`);\n// ## Build Metadata\n// Plus sign, followed by one or more period-separated build metadata\n// identifiers.\ncreateToken(\"BUILD\", `(?:\\\\+(${src[t.BUILDIDENTIFIER]}(?:\\\\.${src[t.BUILDIDENTIFIER]})*))`);\n// ## Full Version String\n// A main version, followed optionally by a pre-release version and\n// build metadata.\n// Note that the only major, minor, patch, and pre-release sections of\n// the version string are capturing groups. The build metadata is not a\n// capturing group, because it should not ever be used in version\n// comparison.\ncreateToken(\"FULLPLAIN\", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);\ncreateToken(\"FULL\", `^${src[t.FULLPLAIN]}$`);\n// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.\n// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty\n// common in the npm registry.\ncreateToken(\"LOOSEPLAIN\", `[v=\\\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);\ncreateToken(\"LOOSE\", `^${src[t.LOOSEPLAIN]}$`);\ncreateToken(\"GTLT\", \"((?:<|>)?=?)\");\n// Something like \"2.*\" or \"1.2.x\".\n// Note that \"x.x\" is a valid xRange identifer, meaning \"any version\"\n// Only the first item is strictly required.\ncreateToken(\"XRANGEIDENTIFIERLOOSE\", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\\\*`);\ncreateToken(\"XRANGEIDENTIFIER\", `${src[t.NUMERICIDENTIFIER]}|x|X|\\\\*`);\ncreateToken(\"XRANGEPLAIN\", `[v=\\\\s]*(${src[t.XRANGEIDENTIFIER]})` + `(?:\\\\.(${src[t.XRANGEIDENTIFIER]})` + `(?:\\\\.(${src[t.XRANGEIDENTIFIER]})` + `(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?` + `)?)?`);\ncreateToken(\"XRANGEPLAINLOOSE\", `[v=\\\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:\\\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:\\\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?` + `)?)?`);\ncreateToken(\"XRANGE\", `^${src[t.GTLT]}\\\\s*${src[t.XRANGEPLAIN]}$`);\ncreateToken(\"XRANGELOOSE\", `^${src[t.GTLT]}\\\\s*${src[t.XRANGEPLAINLOOSE]}$`);\n// Coercion.\n// Extract anything that could conceivably be a part of a valid semver\ncreateToken(\"COERCEPLAIN\", `${\"(^|[^\\\\d])(\\\\d{1,\"}${$714c7f42b7f0e43a$require$MAX_SAFE_COMPONENT_LENGTH}})` + `(?:\\\\.(\\\\d{1,${$714c7f42b7f0e43a$require$MAX_SAFE_COMPONENT_LENGTH}}))?` + `(?:\\\\.(\\\\d{1,${$714c7f42b7f0e43a$require$MAX_SAFE_COMPONENT_LENGTH}}))?`);\ncreateToken(\"COERCE\", `${src[t.COERCEPLAIN]}(?:$|[^\\\\d])`);\ncreateToken(\"COERCEFULL\", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?` + `(?:${src[t.BUILD]})?` + `(?:$|[^\\\\d])`);\ncreateToken(\"COERCERTL\", src[t.COERCE], true);\ncreateToken(\"COERCERTLFULL\", src[t.COERCEFULL], true);\n// Tilde ranges.\n// Meaning is \"reasonably at or greater than\"\ncreateToken(\"LONETILDE\", \"(?:~>?)\");\ncreateToken(\"TILDETRIM\", `(\\\\s*)${src[t.LONETILDE]}\\\\s+`, true);\nexports.tildeTrimReplace = \"$1~\";\ncreateToken(\"TILDE\", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);\ncreateToken(\"TILDELOOSE\", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);\n// Caret ranges.\n// Meaning is \"at least and backwards compatible with\"\ncreateToken(\"LONECARET\", \"(?:\\\\^)\");\ncreateToken(\"CARETTRIM\", `(\\\\s*)${src[t.LONECARET]}\\\\s+`, true);\nexports.caretTrimReplace = \"$1^\";\ncreateToken(\"CARET\", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);\ncreateToken(\"CARETLOOSE\", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);\n// A simple gt/lt/eq thing, or just \"\" to indicate \"any version\"\ncreateToken(\"COMPARATORLOOSE\", `^${src[t.GTLT]}\\\\s*(${src[t.LOOSEPLAIN]})$|^$`);\ncreateToken(\"COMPARATOR\", `^${src[t.GTLT]}\\\\s*(${src[t.FULLPLAIN]})$|^$`);\n// An expression to strip any whitespace between the gtlt and the thing\n// it modifies, so that `> 1.2.3` ==> `>1.2.3`\ncreateToken(\"COMPARATORTRIM\", `(\\\\s*)${src[t.GTLT]}\\\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);\nexports.comparatorTrimReplace = \"$1$2$3\";\n// Something like `1.2.3 - 1.2.4`\n// Note that these all use the loose form, because they'll be\n// checked against either the strict or loose comparator form\n// later.\ncreateToken(\"HYPHENRANGE\", `^\\\\s*(${src[t.XRANGEPLAIN]})` + `\\\\s+-\\\\s+` + `(${src[t.XRANGEPLAIN]})` + `\\\\s*$`);\ncreateToken(\"HYPHENRANGELOOSE\", `^\\\\s*(${src[t.XRANGEPLAINLOOSE]})` + `\\\\s+-\\\\s+` + `(${src[t.XRANGEPLAINLOOSE]})` + `\\\\s*$`);\n// Star ranges basically just allow anything at all.\ncreateToken(\"STAR\", \"(<|>)?=?\\\\s*\\\\*\");\n// >=0.0.0 is like a star\ncreateToken(\"GTE0\", \"^\\\\s*>=\\\\s*0\\\\.0\\\\.0\\\\s*$\");\ncreateToken(\"GTE0PRE\", \"^\\\\s*>=\\\\s*0\\\\.0\\\\.0-0\\\\s*$\");\n\n});\nparcelRegister(\"3qgxS\", function(module, exports) {\n// Note: this is the semver.org version of the spec that it implements\n// Not necessarily the package version of this code.\nconst $27e0a264f9f9f368$var$SEMVER_SPEC_VERSION = \"2.0.0\";\nconst $27e0a264f9f9f368$var$MAX_LENGTH = 256;\nconst $27e0a264f9f9f368$var$MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */ 9007199254740991;\n// Max safe segment length for coercion.\nconst $27e0a264f9f9f368$var$MAX_SAFE_COMPONENT_LENGTH = 16;\n// Max safe length for a build identifier. The max length minus 6 characters for\n// the shortest version with a build 0.0.0+BUILD.\nconst $27e0a264f9f9f368$var$MAX_SAFE_BUILD_LENGTH = $27e0a264f9f9f368$var$MAX_LENGTH - 6;\nconst $27e0a264f9f9f368$var$RELEASE_TYPES = [\n \"major\",\n \"premajor\",\n \"minor\",\n \"preminor\",\n \"patch\",\n \"prepatch\",\n \"prerelease\"\n];\nmodule.exports = {\n MAX_LENGTH: $27e0a264f9f9f368$var$MAX_LENGTH,\n MAX_SAFE_COMPONENT_LENGTH: $27e0a264f9f9f368$var$MAX_SAFE_COMPONENT_LENGTH,\n MAX_SAFE_BUILD_LENGTH: $27e0a264f9f9f368$var$MAX_SAFE_BUILD_LENGTH,\n MAX_SAFE_INTEGER: $27e0a264f9f9f368$var$MAX_SAFE_INTEGER,\n RELEASE_TYPES: $27e0a264f9f9f368$var$RELEASE_TYPES,\n SEMVER_SPEC_VERSION: $27e0a264f9f9f368$var$SEMVER_SPEC_VERSION,\n FLAG_INCLUDE_PRERELEASE: 1,\n FLAG_LOOSE: 2\n};\n\n});\n\nparcelRegister(\"3CqZ1\", function(module, exports) {\nconst $2a29da066bedbbfc$var$debug = typeof process === \"object\" && process.env && process.env.NODE_DEBUG && /\\bsemver\\b/i.test(process.env.NODE_DEBUG) ? (...args)=>console.error(\"SEMVER\", ...args) : ()=>{};\nmodule.exports = $2a29da066bedbbfc$var$debug;\n\n});\n\n\nparcelRegister(\"aMLnW\", function(module, exports) {\n\nvar $3CqZ1 = parcelRequire(\"3CqZ1\");\n\nvar $3qgxS = parcelRequire(\"3qgxS\");\nvar $7da324c382d6a88a$require$MAX_LENGTH = $3qgxS.MAX_LENGTH;\nvar $7da324c382d6a88a$require$MAX_SAFE_INTEGER = $3qgxS.MAX_SAFE_INTEGER;\n\nvar $9J5od = parcelRequire(\"9J5od\");\nvar $7da324c382d6a88a$require$re = $9J5od.safeRe;\nvar $7da324c382d6a88a$require$t = $9J5od.t;\n\nvar $6omBt = parcelRequire(\"6omBt\");\n\nvar $fx8Ft = parcelRequire(\"fx8Ft\");\nvar $7da324c382d6a88a$require$compareIdentifiers = $fx8Ft.compareIdentifiers;\nclass $7da324c382d6a88a$var$SemVer {\n constructor(version, options){\n options = $6omBt(options);\n if (version instanceof $7da324c382d6a88a$var$SemVer) {\n if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) return version;\n else version = version.version;\n } else if (typeof version !== \"string\") throw new TypeError(`Invalid version. Must be a string. Got type \"${typeof version}\".`);\n if (version.length > $7da324c382d6a88a$require$MAX_LENGTH) throw new TypeError(`version is longer than ${$7da324c382d6a88a$require$MAX_LENGTH} characters`);\n $3CqZ1(\"SemVer\", version, options);\n this.options = options;\n this.loose = !!options.loose;\n // this isn't actually relevant for versions, but keep it so that we\n // don't run into trouble passing this.options around.\n this.includePrerelease = !!options.includePrerelease;\n const m = version.trim().match(options.loose ? $7da324c382d6a88a$require$re[$7da324c382d6a88a$require$t.LOOSE] : $7da324c382d6a88a$require$re[$7da324c382d6a88a$require$t.FULL]);\n if (!m) throw new TypeError(`Invalid Version: ${version}`);\n this.raw = version;\n // these are actually numbers\n this.major = +m[1];\n this.minor = +m[2];\n this.patch = +m[3];\n if (this.major > $7da324c382d6a88a$require$MAX_SAFE_INTEGER || this.major < 0) throw new TypeError(\"Invalid major version\");\n if (this.minor > $7da324c382d6a88a$require$MAX_SAFE_INTEGER || this.minor < 0) throw new TypeError(\"Invalid minor version\");\n if (this.patch > $7da324c382d6a88a$require$MAX_SAFE_INTEGER || this.patch < 0) throw new TypeError(\"Invalid patch version\");\n // numberify any prerelease numeric ids\n if (!m[4]) this.prerelease = [];\n else this.prerelease = m[4].split(\".\").map((id)=>{\n if (/^[0-9]+$/.test(id)) {\n const num = +id;\n if (num >= 0 && num < $7da324c382d6a88a$require$MAX_SAFE_INTEGER) return num;\n }\n return id;\n });\n this.build = m[5] ? m[5].split(\".\") : [];\n this.format();\n }\n format() {\n this.version = `${this.major}.${this.minor}.${this.patch}`;\n if (this.prerelease.length) this.version += `-${this.prerelease.join(\".\")}`;\n return this.version;\n }\n toString() {\n return this.version;\n }\n compare(other) {\n $3CqZ1(\"SemVer.compare\", this.version, this.options, other);\n if (!(other instanceof $7da324c382d6a88a$var$SemVer)) {\n if (typeof other === \"string\" && other === this.version) return 0;\n other = new $7da324c382d6a88a$var$SemVer(other, this.options);\n }\n if (other.version === this.version) return 0;\n return this.compareMain(other) || this.comparePre(other);\n }\n compareMain(other) {\n if (!(other instanceof $7da324c382d6a88a$var$SemVer)) other = new $7da324c382d6a88a$var$SemVer(other, this.options);\n return $7da324c382d6a88a$require$compareIdentifiers(this.major, other.major) || $7da324c382d6a88a$require$compareIdentifiers(this.minor, other.minor) || $7da324c382d6a88a$require$compareIdentifiers(this.patch, other.patch);\n }\n comparePre(other) {\n if (!(other instanceof $7da324c382d6a88a$var$SemVer)) other = new $7da324c382d6a88a$var$SemVer(other, this.options);\n // NOT having a prerelease is > having one\n if (this.prerelease.length && !other.prerelease.length) return -1;\n else if (!this.prerelease.length && other.prerelease.length) return 1;\n else if (!this.prerelease.length && !other.prerelease.length) return 0;\n let i = 0;\n do {\n const a = this.prerelease[i];\n const b = other.prerelease[i];\n $3CqZ1(\"prerelease compare\", i, a, b);\n if (a === undefined && b === undefined) return 0;\n else if (b === undefined) return 1;\n else if (a === undefined) return -1;\n else if (a === b) continue;\n else return $7da324c382d6a88a$require$compareIdentifiers(a, b);\n }while (++i);\n }\n compareBuild(other) {\n if (!(other instanceof $7da324c382d6a88a$var$SemVer)) other = new $7da324c382d6a88a$var$SemVer(other, this.options);\n let i = 0;\n do {\n const a = this.build[i];\n const b = other.build[i];\n $3CqZ1(\"prerelease compare\", i, a, b);\n if (a === undefined && b === undefined) return 0;\n else if (b === undefined) return 1;\n else if (a === undefined) return -1;\n else if (a === b) continue;\n else return $7da324c382d6a88a$require$compareIdentifiers(a, b);\n }while (++i);\n }\n // preminor will bump the version up to the next minor release, and immediately\n // down to pre-release. premajor and prepatch work the same way.\n inc(release, identifier, identifierBase) {\n switch(release){\n case \"premajor\":\n this.prerelease.length = 0;\n this.patch = 0;\n this.minor = 0;\n this.major++;\n this.inc(\"pre\", identifier, identifierBase);\n break;\n case \"preminor\":\n this.prerelease.length = 0;\n this.patch = 0;\n this.minor++;\n this.inc(\"pre\", identifier, identifierBase);\n break;\n case \"prepatch\":\n // If this is already a prerelease, it will bump to the next version\n // drop any prereleases that might already exist, since they are not\n // relevant at this point.\n this.prerelease.length = 0;\n this.inc(\"patch\", identifier, identifierBase);\n this.inc(\"pre\", identifier, identifierBase);\n break;\n // If the input is a non-prerelease version, this acts the same as\n // prepatch.\n case \"prerelease\":\n if (this.prerelease.length === 0) this.inc(\"patch\", identifier, identifierBase);\n this.inc(\"pre\", identifier, identifierBase);\n break;\n case \"major\":\n // If this is a pre-major version, bump up to the same major version.\n // Otherwise increment major.\n // 1.0.0-5 bumps to 1.0.0\n // 1.1.0 bumps to 2.0.0\n if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) this.major++;\n this.minor = 0;\n this.patch = 0;\n this.prerelease = [];\n break;\n case \"minor\":\n // If this is a pre-minor version, bump up to the same minor version.\n // Otherwise increment minor.\n // 1.2.0-5 bumps to 1.2.0\n // 1.2.1 bumps to 1.3.0\n if (this.patch !== 0 || this.prerelease.length === 0) this.minor++;\n this.patch = 0;\n this.prerelease = [];\n break;\n case \"patch\":\n // If this is not a pre-release version, it will increment the patch.\n // If it is a pre-release it will bump up to the same patch version.\n // 1.2.0-5 patches to 1.2.0\n // 1.2.0 patches to 1.2.1\n if (this.prerelease.length === 0) this.patch++;\n this.prerelease = [];\n break;\n // This probably shouldn't be used publicly.\n // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.\n case \"pre\":\n {\n const base = Number(identifierBase) ? 1 : 0;\n if (!identifier && identifierBase === false) throw new Error(\"invalid increment argument: identifier is empty\");\n if (this.prerelease.length === 0) this.prerelease = [\n base\n ];\n else {\n let i = this.prerelease.length;\n while(--i >= 0)if (typeof this.prerelease[i] === \"number\") {\n this.prerelease[i]++;\n i = -2;\n }\n if (i === -1) {\n // didn't increment anything\n if (identifier === this.prerelease.join(\".\") && identifierBase === false) throw new Error(\"invalid increment argument: identifier already exists\");\n this.prerelease.push(base);\n }\n }\n if (identifier) {\n // 1.2.0-beta.1 bumps to 1.2.0-beta.2,\n // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0\n let prerelease = [\n identifier,\n base\n ];\n if (identifierBase === false) prerelease = [\n identifier\n ];\n if ($7da324c382d6a88a$require$compareIdentifiers(this.prerelease[0], identifier) === 0) {\n if (isNaN(this.prerelease[1])) this.prerelease = prerelease;\n } else this.prerelease = prerelease;\n }\n break;\n }\n default:\n throw new Error(`invalid increment argument: ${release}`);\n }\n this.raw = this.format();\n if (this.build.length) this.raw += `+${this.build.join(\".\")}`;\n return this;\n }\n}\nmodule.exports = $7da324c382d6a88a$var$SemVer;\n\n});\nparcelRegister(\"6omBt\", function(module, exports) {\n// parse out just the options we care about\nconst $4a7684854438b3a8$var$looseOption = Object.freeze({\n loose: true\n});\nconst $4a7684854438b3a8$var$emptyOpts = Object.freeze({});\nconst $4a7684854438b3a8$var$parseOptions = (options)=>{\n if (!options) return $4a7684854438b3a8$var$emptyOpts;\n if (typeof options !== \"object\") return $4a7684854438b3a8$var$looseOption;\n return options;\n};\nmodule.exports = $4a7684854438b3a8$var$parseOptions;\n\n});\n\nparcelRegister(\"fx8Ft\", function(module, exports) {\nconst $b4f0a9608bfa578c$var$numeric = /^[0-9]+$/;\nconst $b4f0a9608bfa578c$var$compareIdentifiers = (a, b)=>{\n const anum = $b4f0a9608bfa578c$var$numeric.test(a);\n const bnum = $b4f0a9608bfa578c$var$numeric.test(b);\n if (anum && bnum) {\n a = +a;\n b = +b;\n }\n return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;\n};\nconst $b4f0a9608bfa578c$var$rcompareIdentifiers = (a, b)=>$b4f0a9608bfa578c$var$compareIdentifiers(b, a);\nmodule.exports = {\n compareIdentifiers: $b4f0a9608bfa578c$var$compareIdentifiers,\n rcompareIdentifiers: $b4f0a9608bfa578c$var$rcompareIdentifiers\n};\n\n});\n\n\nparcelRegister(\"UI3XL\", function(module, exports) {\n\nvar $aMLnW = parcelRequire(\"aMLnW\");\nconst $0aa7690e2bf9b583$var$parse = (version, options, throwErrors = false)=>{\n if (version instanceof $aMLnW) return version;\n try {\n return new $aMLnW(version, options);\n } catch (er) {\n if (!throwErrors) return null;\n throw er;\n }\n};\nmodule.exports = $0aa7690e2bf9b583$var$parse;\n\n});\n\nparcelRegister(\"l655J\", function(module, exports) {\n\nvar $UI3XL = parcelRequire(\"UI3XL\");\nconst $f5be1b9124e8a995$var$valid = (version, options)=>{\n const v = $UI3XL(version, options);\n return v ? v.version : null;\n};\nmodule.exports = $f5be1b9124e8a995$var$valid;\n\n});\n\nparcelRegister(\"jzJq8\", function(module, exports) {\n\nvar $UI3XL = parcelRequire(\"UI3XL\");\nconst $e40484ca80391047$var$clean = (version, options)=>{\n const s = $UI3XL(version.trim().replace(/^[=v]+/, \"\"), options);\n return s ? s.version : null;\n};\nmodule.exports = $e40484ca80391047$var$clean;\n\n});\n\nparcelRegister(\"b1nH1\", function(module, exports) {\n\nvar $aMLnW = parcelRequire(\"aMLnW\");\nconst $80622aa1b4dfbc9d$var$inc = (version, release, options, identifier, identifierBase)=>{\n if (typeof options === \"string\") {\n identifierBase = identifier;\n identifier = options;\n options = undefined;\n }\n try {\n return new $aMLnW(version instanceof $aMLnW ? version.version : version, options).inc(release, identifier, identifierBase).version;\n } catch (er) {\n return null;\n }\n};\nmodule.exports = $80622aa1b4dfbc9d$var$inc;\n\n});\n\nparcelRegister(\"inG4j\", function(module, exports) {\n\nvar $UI3XL = parcelRequire(\"UI3XL\");\nconst $d61b01eb687284bf$var$diff = (version1, version2)=>{\n const v1 = $UI3XL(version1, null, true);\n const v2 = $UI3XL(version2, null, true);\n const comparison = v1.compare(v2);\n if (comparison === 0) return null;\n const v1Higher = comparison > 0;\n const highVersion = v1Higher ? v1 : v2;\n const lowVersion = v1Higher ? v2 : v1;\n const highHasPre = !!highVersion.prerelease.length;\n const lowHasPre = !!lowVersion.prerelease.length;\n if (lowHasPre && !highHasPre) {\n // Going from prerelease -> no prerelease requires some special casing\n // If the low version has only a major, then it will always be a major\n // Some examples:\n // 1.0.0-1 -> 1.0.0\n // 1.0.0-1 -> 1.1.1\n // 1.0.0-1 -> 2.0.0\n if (!lowVersion.patch && !lowVersion.minor) return \"major\";\n // Otherwise it can be determined by checking the high version\n if (highVersion.patch) // anything higher than a patch bump would result in the wrong version\n return \"patch\";\n if (highVersion.minor) // anything higher than a minor bump would result in the wrong version\n return \"minor\";\n // bumping major/minor/patch all have same result\n return \"major\";\n }\n // add the `pre` prefix if we are going to a prerelease version\n const prefix = highHasPre ? \"pre\" : \"\";\n if (v1.major !== v2.major) return prefix + \"major\";\n if (v1.minor !== v2.minor) return prefix + \"minor\";\n if (v1.patch !== v2.patch) return prefix + \"patch\";\n // high and low are preleases\n return \"prerelease\";\n};\nmodule.exports = $d61b01eb687284bf$var$diff;\n\n});\n\nparcelRegister(\"2aJGP\", function(module, exports) {\n\nvar $aMLnW = parcelRequire(\"aMLnW\");\nconst $194ff4fade75e049$var$major = (a, loose)=>new $aMLnW(a, loose).major;\nmodule.exports = $194ff4fade75e049$var$major;\n\n});\n\nparcelRegister(\"h6Ixq\", function(module, exports) {\n\nvar $aMLnW = parcelRequire(\"aMLnW\");\nconst $c7458b89940ed03b$var$minor = (a, loose)=>new $aMLnW(a, loose).minor;\nmodule.exports = $c7458b89940ed03b$var$minor;\n\n});\n\nparcelRegister(\"90ROK\", function(module, exports) {\n\nvar $aMLnW = parcelRequire(\"aMLnW\");\nconst $68fddc2c226bc011$var$patch = (a, loose)=>new $aMLnW(a, loose).patch;\nmodule.exports = $68fddc2c226bc011$var$patch;\n\n});\n\nparcelRegister(\"8m4O1\", function(module, exports) {\n\nvar $UI3XL = parcelRequire(\"UI3XL\");\nconst $61541b255fd4fd5d$var$prerelease = (version, options)=>{\n const parsed = $UI3XL(version, options);\n return parsed && parsed.prerelease.length ? parsed.prerelease : null;\n};\nmodule.exports = $61541b255fd4fd5d$var$prerelease;\n\n});\n\nparcelRegister(\"3uysP\", function(module, exports) {\n\nvar $aMLnW = parcelRequire(\"aMLnW\");\nconst $28aee843a4df7f72$var$compare = (a, b, loose)=>new $aMLnW(a, loose).compare(new $aMLnW(b, loose));\nmodule.exports = $28aee843a4df7f72$var$compare;\n\n});\n\nparcelRegister(\"hYBTv\", function(module, exports) {\n\nvar $3uysP = parcelRequire(\"3uysP\");\nconst $d1656f45798b406b$var$rcompare = (a, b, loose)=>$3uysP(b, a, loose);\nmodule.exports = $d1656f45798b406b$var$rcompare;\n\n});\n\nparcelRegister(\"ftcZo\", function(module, exports) {\n\nvar $3uysP = parcelRequire(\"3uysP\");\nconst $b433a3da1df2f705$var$compareLoose = (a, b)=>$3uysP(a, b, true);\nmodule.exports = $b433a3da1df2f705$var$compareLoose;\n\n});\n\nparcelRegister(\"1CIrW\", function(module, exports) {\n\nvar $aMLnW = parcelRequire(\"aMLnW\");\nconst $12ebd1da918dc016$var$compareBuild = (a, b, loose)=>{\n const versionA = new $aMLnW(a, loose);\n const versionB = new $aMLnW(b, loose);\n return versionA.compare(versionB) || versionA.compareBuild(versionB);\n};\nmodule.exports = $12ebd1da918dc016$var$compareBuild;\n\n});\n\nparcelRegister(\"exBHN\", function(module, exports) {\n\nvar $1CIrW = parcelRequire(\"1CIrW\");\nconst $a96165462e76b234$var$sort = (list, loose)=>list.sort((a, b)=>$1CIrW(a, b, loose));\nmodule.exports = $a96165462e76b234$var$sort;\n\n});\n\nparcelRegister(\"lm1lq\", function(module, exports) {\n\nvar $1CIrW = parcelRequire(\"1CIrW\");\nconst $f8bcb207b3a73186$var$rsort = (list, loose)=>list.sort((a, b)=>$1CIrW(b, a, loose));\nmodule.exports = $f8bcb207b3a73186$var$rsort;\n\n});\n\nparcelRegister(\"cPjhN\", function(module, exports) {\n\nvar $3uysP = parcelRequire(\"3uysP\");\nconst $0268ec36b6100c2c$var$gt = (a, b, loose)=>$3uysP(a, b, loose) > 0;\nmodule.exports = $0268ec36b6100c2c$var$gt;\n\n});\n\nparcelRegister(\"avz3V\", function(module, exports) {\n\nvar $3uysP = parcelRequire(\"3uysP\");\nconst $7a67ff4b4e69975e$var$lt = (a, b, loose)=>$3uysP(a, b, loose) < 0;\nmodule.exports = $7a67ff4b4e69975e$var$lt;\n\n});\n\nparcelRegister(\"fXQFJ\", function(module, exports) {\n\nvar $3uysP = parcelRequire(\"3uysP\");\nconst $b9f539425bdf4b62$var$eq = (a, b, loose)=>$3uysP(a, b, loose) === 0;\nmodule.exports = $b9f539425bdf4b62$var$eq;\n\n});\n\nparcelRegister(\"bu0Ra\", function(module, exports) {\n\nvar $3uysP = parcelRequire(\"3uysP\");\nconst $85c32928d6534f6b$var$neq = (a, b, loose)=>$3uysP(a, b, loose) !== 0;\nmodule.exports = $85c32928d6534f6b$var$neq;\n\n});\n\nparcelRegister(\"9xdhv\", function(module, exports) {\n\nvar $3uysP = parcelRequire(\"3uysP\");\nconst $6f117f82d38ad331$var$gte = (a, b, loose)=>$3uysP(a, b, loose) >= 0;\nmodule.exports = $6f117f82d38ad331$var$gte;\n\n});\n\nparcelRegister(\"8aNoG\", function(module, exports) {\n\nvar $3uysP = parcelRequire(\"3uysP\");\nconst $5f359321e34a81b1$var$lte = (a, b, loose)=>$3uysP(a, b, loose) <= 0;\nmodule.exports = $5f359321e34a81b1$var$lte;\n\n});\n\nparcelRegister(\"8gipG\", function(module, exports) {\n\nvar $fXQFJ = parcelRequire(\"fXQFJ\");\n\nvar $bu0Ra = parcelRequire(\"bu0Ra\");\n\nvar $cPjhN = parcelRequire(\"cPjhN\");\n\nvar $9xdhv = parcelRequire(\"9xdhv\");\n\nvar $avz3V = parcelRequire(\"avz3V\");\n\nvar $8aNoG = parcelRequire(\"8aNoG\");\nconst $603e19dc5fbb1a16$var$cmp = (a, op, b, loose)=>{\n switch(op){\n case \"===\":\n if (typeof a === \"object\") a = a.version;\n if (typeof b === \"object\") b = b.version;\n return a === b;\n case \"!==\":\n if (typeof a === \"object\") a = a.version;\n if (typeof b === \"object\") b = b.version;\n return a !== b;\n case \"\":\n case \"=\":\n case \"==\":\n return $fXQFJ(a, b, loose);\n case \"!=\":\n return $bu0Ra(a, b, loose);\n case \">\":\n return $cPjhN(a, b, loose);\n case \">=\":\n return $9xdhv(a, b, loose);\n case \"<\":\n return $avz3V(a, b, loose);\n case \"<=\":\n return $8aNoG(a, b, loose);\n default:\n throw new TypeError(`Invalid operator: ${op}`);\n }\n};\nmodule.exports = $603e19dc5fbb1a16$var$cmp;\n\n});\n\nparcelRegister(\"l8hao\", function(module, exports) {\n\nvar $aMLnW = parcelRequire(\"aMLnW\");\n\nvar $UI3XL = parcelRequire(\"UI3XL\");\n\nvar $9J5od = parcelRequire(\"9J5od\");\nvar $f627a93f3b8c4872$require$re = $9J5od.safeRe;\nvar $f627a93f3b8c4872$require$t = $9J5od.t;\nconst $f627a93f3b8c4872$var$coerce = (version, options)=>{\n if (version instanceof $aMLnW) return version;\n if (typeof version === \"number\") version = String(version);\n if (typeof version !== \"string\") return null;\n options = options || {};\n let match = null;\n if (!options.rtl) match = version.match(options.includePrerelease ? $f627a93f3b8c4872$require$re[$f627a93f3b8c4872$require$t.COERCEFULL] : $f627a93f3b8c4872$require$re[$f627a93f3b8c4872$require$t.COERCE]);\n else {\n // Find the right-most coercible string that does not share\n // a terminus with a more left-ward coercible string.\n // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'\n // With includePrerelease option set, '1.2.3.4-rc' wants to coerce '2.3.4-rc', not '2.3.4'\n //\n // Walk through the string checking with a /g regexp\n // Manually set the index so as to pick up overlapping matches.\n // Stop when we get a match that ends at the string end, since no\n // coercible string can be more right-ward without the same terminus.\n const coerceRtlRegex = options.includePrerelease ? $f627a93f3b8c4872$require$re[$f627a93f3b8c4872$require$t.COERCERTLFULL] : $f627a93f3b8c4872$require$re[$f627a93f3b8c4872$require$t.COERCERTL];\n let next;\n while((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)){\n if (!match || next.index + next[0].length !== match.index + match[0].length) match = next;\n coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;\n }\n // leave it in a clean state\n coerceRtlRegex.lastIndex = -1;\n }\n if (match === null) return null;\n const major = match[2];\n const minor = match[3] || \"0\";\n const patch = match[4] || \"0\";\n const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : \"\";\n const build = options.includePrerelease && match[6] ? `+${match[6]}` : \"\";\n return $UI3XL(`${major}.${minor}.${patch}${prerelease}${build}`, options);\n};\nmodule.exports = $f627a93f3b8c4872$var$coerce;\n\n});\n\nparcelRegister(\"dSz9p\", function(module, exports) {\nconst $a1ab95b4a6509cb8$var$ANY = Symbol(\"SemVer ANY\");\n// hoisted class for cyclic dependency\nclass $a1ab95b4a6509cb8$var$Comparator {\n static get ANY() {\n return $a1ab95b4a6509cb8$var$ANY;\n }\n constructor(comp, options){\n options = $6omBt(options);\n if (comp instanceof $a1ab95b4a6509cb8$var$Comparator) {\n if (comp.loose === !!options.loose) return comp;\n else comp = comp.value;\n }\n comp = comp.trim().split(/\\s+/).join(\" \");\n $3CqZ1(\"comparator\", comp, options);\n this.options = options;\n this.loose = !!options.loose;\n this.parse(comp);\n if (this.semver === $a1ab95b4a6509cb8$var$ANY) this.value = \"\";\n else this.value = this.operator + this.semver.version;\n $3CqZ1(\"comp\", this);\n }\n parse(comp) {\n const r = this.options.loose ? $a1ab95b4a6509cb8$require$re[$a1ab95b4a6509cb8$require$t.COMPARATORLOOSE] : $a1ab95b4a6509cb8$require$re[$a1ab95b4a6509cb8$require$t.COMPARATOR];\n const m = comp.match(r);\n if (!m) throw new TypeError(`Invalid comparator: ${comp}`);\n this.operator = m[1] !== undefined ? m[1] : \"\";\n if (this.operator === \"=\") this.operator = \"\";\n // if it literally is just '>' or '' then allow anything.\n if (!m[2]) this.semver = $a1ab95b4a6509cb8$var$ANY;\n else this.semver = new $aMLnW(m[2], this.options.loose);\n }\n toString() {\n return this.value;\n }\n test(version) {\n $3CqZ1(\"Comparator.test\", version, this.options.loose);\n if (this.semver === $a1ab95b4a6509cb8$var$ANY || version === $a1ab95b4a6509cb8$var$ANY) return true;\n if (typeof version === \"string\") try {\n version = new $aMLnW(version, this.options);\n } catch (er) {\n return false;\n }\n return $8gipG(version, this.operator, this.semver, this.options);\n }\n intersects(comp, options) {\n if (!(comp instanceof $a1ab95b4a6509cb8$var$Comparator)) throw new TypeError(\"a Comparator is required\");\n if (this.operator === \"\") {\n if (this.value === \"\") return true;\n return new $4FTez(comp.value, options).test(this.value);\n } else if (comp.operator === \"\") {\n if (comp.value === \"\") return true;\n return new $4FTez(this.value, options).test(comp.semver);\n }\n options = $6omBt(options);\n // Special cases where nothing can possibly be lower\n if (options.includePrerelease && (this.value === \"<0.0.0-0\" || comp.value === \"<0.0.0-0\")) return false;\n if (!options.includePrerelease && (this.value.startsWith(\"<0.0.0\") || comp.value.startsWith(\"<0.0.0\"))) return false;\n // Same direction increasing (> or >=)\n if (this.operator.startsWith(\">\") && comp.operator.startsWith(\">\")) return true;\n // Same direction decreasing (< or <=)\n if (this.operator.startsWith(\"<\") && comp.operator.startsWith(\"<\")) return true;\n // same SemVer and both sides are inclusive (<= or >=)\n if (this.semver.version === comp.semver.version && this.operator.includes(\"=\") && comp.operator.includes(\"=\")) return true;\n // opposite directions less than\n if ($8gipG(this.semver, \"<\", comp.semver, options) && this.operator.startsWith(\">\") && comp.operator.startsWith(\"<\")) return true;\n // opposite directions greater than\n if ($8gipG(this.semver, \">\", comp.semver, options) && this.operator.startsWith(\"<\") && comp.operator.startsWith(\">\")) return true;\n return false;\n }\n}\nmodule.exports = $a1ab95b4a6509cb8$var$Comparator;\n\nvar $6omBt = parcelRequire(\"6omBt\");\n\nvar $9J5od = parcelRequire(\"9J5od\");\nvar $a1ab95b4a6509cb8$require$re = $9J5od.safeRe;\nvar $a1ab95b4a6509cb8$require$t = $9J5od.t;\n\nvar $8gipG = parcelRequire(\"8gipG\");\n\nvar $3CqZ1 = parcelRequire(\"3CqZ1\");\n\nvar $aMLnW = parcelRequire(\"aMLnW\");\n\nvar $4FTez = parcelRequire(\"4FTez\");\n\n});\nparcelRegister(\"4FTez\", function(module, exports) {\n// hoisted class for cyclic dependency\nclass $3675d6171478137e$var$Range {\n constructor(range, options){\n options = $6omBt(options);\n if (range instanceof $3675d6171478137e$var$Range) {\n if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) return range;\n else return new $3675d6171478137e$var$Range(range.raw, options);\n }\n if (range instanceof $dSz9p) {\n // just put it in the set and return\n this.raw = range.value;\n this.set = [\n [\n range\n ]\n ];\n this.format();\n return this;\n }\n this.options = options;\n this.loose = !!options.loose;\n this.includePrerelease = !!options.includePrerelease;\n // First reduce all whitespace as much as possible so we do not have to rely\n // on potentially slow regexes like \\s*. This is then stored and used for\n // future error messages as well.\n this.raw = range.trim().split(/\\s+/).join(\" \");\n // First, split on ||\n this.set = this.raw.split(\"||\")// map the range to a 2d array of comparators\n .map((r)=>this.parseRange(r.trim()))// throw out any comparator lists that are empty\n // this generally means that it was not a valid range, which is allowed\n // in loose mode, but will still throw if the WHOLE range is invalid.\n .filter((c)=>c.length);\n if (!this.set.length) throw new TypeError(`Invalid SemVer Range: ${this.raw}`);\n // if we have any that are not the null set, throw out null sets.\n if (this.set.length > 1) {\n // keep the first one, in case they're all null sets\n const first = this.set[0];\n this.set = this.set.filter((c)=>!$3675d6171478137e$var$isNullSet(c[0]));\n if (this.set.length === 0) this.set = [\n first\n ];\n else if (this.set.length > 1) {\n // if we have any that are *, then the range is just *\n for (const c of this.set)if (c.length === 1 && $3675d6171478137e$var$isAny(c[0])) {\n this.set = [\n c\n ];\n break;\n }\n }\n }\n this.format();\n }\n format() {\n this.range = this.set.map((comps)=>comps.join(\" \").trim()).join(\"||\").trim();\n return this.range;\n }\n toString() {\n return this.range;\n }\n parseRange(range) {\n // memoize range parsing for performance.\n // this is a very hot path, and fully deterministic.\n const memoOpts = (this.options.includePrerelease && $3675d6171478137e$require$FLAG_INCLUDE_PRERELEASE) | (this.options.loose && $3675d6171478137e$require$FLAG_LOOSE);\n const memoKey = memoOpts + \":\" + range;\n const cached = $3675d6171478137e$var$cache.get(memoKey);\n if (cached) return cached;\n const loose = this.options.loose;\n // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`\n const hr = loose ? $3675d6171478137e$require$re[$3675d6171478137e$require$t.HYPHENRANGELOOSE] : $3675d6171478137e$require$re[$3675d6171478137e$require$t.HYPHENRANGE];\n range = range.replace(hr, $3675d6171478137e$var$hyphenReplace(this.options.includePrerelease));\n $3CqZ1(\"hyphen replace\", range);\n // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`\n range = range.replace($3675d6171478137e$require$re[$3675d6171478137e$require$t.COMPARATORTRIM], $3675d6171478137e$require$comparatorTrimReplace);\n $3CqZ1(\"comparator trim\", range);\n // `~ 1.2.3` => `~1.2.3`\n range = range.replace($3675d6171478137e$require$re[$3675d6171478137e$require$t.TILDETRIM], $3675d6171478137e$require$tildeTrimReplace);\n $3CqZ1(\"tilde trim\", range);\n // `^ 1.2.3` => `^1.2.3`\n range = range.replace($3675d6171478137e$require$re[$3675d6171478137e$require$t.CARETTRIM], $3675d6171478137e$require$caretTrimReplace);\n $3CqZ1(\"caret trim\", range);\n // At this point, the range is completely trimmed and\n // ready to be split into comparators.\n let rangeList = range.split(\" \").map((comp)=>$3675d6171478137e$var$parseComparator(comp, this.options)).join(\" \").split(/\\s+/)// >=0.0.0 is equivalent to *\n .map((comp)=>$3675d6171478137e$var$replaceGTE0(comp, this.options));\n if (loose) // in loose mode, throw out any that are not valid comparators\n rangeList = rangeList.filter((comp)=>{\n $3CqZ1(\"loose invalid filter\", comp, this.options);\n return !!comp.match($3675d6171478137e$require$re[$3675d6171478137e$require$t.COMPARATORLOOSE]);\n });\n $3CqZ1(\"range list\", rangeList);\n // if any comparators are the null set, then replace with JUST null set\n // if more than one comparator, remove any * comparators\n // also, don't include the same comparator more than once\n const rangeMap = new Map();\n const comparators = rangeList.map((comp)=>new $dSz9p(comp, this.options));\n for (const comp of comparators){\n if ($3675d6171478137e$var$isNullSet(comp)) return [\n comp\n ];\n rangeMap.set(comp.value, comp);\n }\n if (rangeMap.size > 1 && rangeMap.has(\"\")) rangeMap.delete(\"\");\n const result = [\n ...rangeMap.values()\n ];\n $3675d6171478137e$var$cache.set(memoKey, result);\n return result;\n }\n intersects(range, options) {\n if (!(range instanceof $3675d6171478137e$var$Range)) throw new TypeError(\"a Range is required\");\n return this.set.some((thisComparators)=>{\n return $3675d6171478137e$var$isSatisfiable(thisComparators, options) && range.set.some((rangeComparators)=>{\n return $3675d6171478137e$var$isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator)=>{\n return rangeComparators.every((rangeComparator)=>{\n return thisComparator.intersects(rangeComparator, options);\n });\n });\n });\n });\n }\n // if ANY of the sets match ALL of its comparators, then pass\n test(version) {\n if (!version) return false;\n if (typeof version === \"string\") try {\n version = new $aMLnW(version, this.options);\n } catch (er) {\n return false;\n }\n for(let i = 0; i < this.set.length; i++){\n if ($3675d6171478137e$var$testSet(this.set[i], version, this.options)) return true;\n }\n return false;\n }\n}\nmodule.exports = $3675d6171478137e$var$Range;\n\nvar $eGCLk = parcelRequire(\"eGCLk\");\nconst $3675d6171478137e$var$cache = new $eGCLk({\n max: 1000\n});\n\nvar $6omBt = parcelRequire(\"6omBt\");\n\nvar $dSz9p = parcelRequire(\"dSz9p\");\n\nvar $3CqZ1 = parcelRequire(\"3CqZ1\");\n\nvar $aMLnW = parcelRequire(\"aMLnW\");\n\nvar $9J5od = parcelRequire(\"9J5od\");\nvar $3675d6171478137e$require$re = $9J5od.safeRe;\nvar $3675d6171478137e$require$t = $9J5od.t;\nvar $3675d6171478137e$require$comparatorTrimReplace = $9J5od.comparatorTrimReplace;\nvar $3675d6171478137e$require$tildeTrimReplace = $9J5od.tildeTrimReplace;\nvar $3675d6171478137e$require$caretTrimReplace = $9J5od.caretTrimReplace;\n\nvar $3qgxS = parcelRequire(\"3qgxS\");\nvar $3675d6171478137e$require$FLAG_INCLUDE_PRERELEASE = $3qgxS.FLAG_INCLUDE_PRERELEASE;\nvar $3675d6171478137e$require$FLAG_LOOSE = $3qgxS.FLAG_LOOSE;\nconst $3675d6171478137e$var$isNullSet = (c)=>c.value === \"<0.0.0-0\";\nconst $3675d6171478137e$var$isAny = (c)=>c.value === \"\";\n// take a set of comparators and determine whether there\n// exists a version which can satisfy it\nconst $3675d6171478137e$var$isSatisfiable = (comparators, options)=>{\n let result = true;\n const remainingComparators = comparators.slice();\n let testComparator = remainingComparators.pop();\n while(result && remainingComparators.length){\n result = remainingComparators.every((otherComparator)=>{\n return testComparator.intersects(otherComparator, options);\n });\n testComparator = remainingComparators.pop();\n }\n return result;\n};\n// comprised of xranges, tildes, stars, and gtlt's at this point.\n// already replaced the hyphen ranges\n// turn into a set of JUST comparators.\nconst $3675d6171478137e$var$parseComparator = (comp, options)=>{\n $3CqZ1(\"comp\", comp, options);\n comp = $3675d6171478137e$var$replaceCarets(comp, options);\n $3CqZ1(\"caret\", comp);\n comp = $3675d6171478137e$var$replaceTildes(comp, options);\n $3CqZ1(\"tildes\", comp);\n comp = $3675d6171478137e$var$replaceXRanges(comp, options);\n $3CqZ1(\"xrange\", comp);\n comp = $3675d6171478137e$var$replaceStars(comp, options);\n $3CqZ1(\"stars\", comp);\n return comp;\n};\nconst $3675d6171478137e$var$isX = (id)=>!id || id.toLowerCase() === \"x\" || id === \"*\";\n// ~, ~> --> * (any, kinda silly)\n// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0\n// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0\n// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0\n// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0\n// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0\n// ~0.0.1 --> >=0.0.1 <0.1.0-0\nconst $3675d6171478137e$var$replaceTildes = (comp, options)=>{\n return comp.trim().split(/\\s+/).map((c)=>$3675d6171478137e$var$replaceTilde(c, options)).join(\" \");\n};\nconst $3675d6171478137e$var$replaceTilde = (comp, options)=>{\n const r = options.loose ? $3675d6171478137e$require$re[$3675d6171478137e$require$t.TILDELOOSE] : $3675d6171478137e$require$re[$3675d6171478137e$require$t.TILDE];\n return comp.replace(r, (_, M, m, p, pr)=>{\n $3CqZ1(\"tilde\", comp, _, M, m, p, pr);\n let ret;\n if ($3675d6171478137e$var$isX(M)) ret = \"\";\n else if ($3675d6171478137e$var$isX(m)) ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;\n else if ($3675d6171478137e$var$isX(p)) // ~1.2 == >=1.2.0 <1.3.0-0\n ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;\n else if (pr) {\n $3CqZ1(\"replaceTilde pr\", pr);\n ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;\n } else // ~1.2.3 == >=1.2.3 <1.3.0-0\n ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;\n $3CqZ1(\"tilde return\", ret);\n return ret;\n });\n};\n// ^ --> * (any, kinda silly)\n// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0\n// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0\n// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0\n// ^1.2.3 --> >=1.2.3 <2.0.0-0\n// ^1.2.0 --> >=1.2.0 <2.0.0-0\n// ^0.0.1 --> >=0.0.1 <0.0.2-0\n// ^0.1.0 --> >=0.1.0 <0.2.0-0\nconst $3675d6171478137e$var$replaceCarets = (comp, options)=>{\n return comp.trim().split(/\\s+/).map((c)=>$3675d6171478137e$var$replaceCaret(c, options)).join(\" \");\n};\nconst $3675d6171478137e$var$replaceCaret = (comp, options)=>{\n $3CqZ1(\"caret\", comp, options);\n const r = options.loose ? $3675d6171478137e$require$re[$3675d6171478137e$require$t.CARETLOOSE] : $3675d6171478137e$require$re[$3675d6171478137e$require$t.CARET];\n const z = options.includePrerelease ? \"-0\" : \"\";\n return comp.replace(r, (_, M, m, p, pr)=>{\n $3CqZ1(\"caret\", comp, _, M, m, p, pr);\n let ret;\n if ($3675d6171478137e$var$isX(M)) ret = \"\";\n else if ($3675d6171478137e$var$isX(m)) ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;\n else if ($3675d6171478137e$var$isX(p)) {\n if (M === \"0\") ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;\n else ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;\n } else if (pr) {\n $3CqZ1(\"replaceCaret pr\", pr);\n if (M === \"0\") {\n if (m === \"0\") ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;\n else ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;\n } else ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;\n } else {\n $3CqZ1(\"no pr\");\n if (M === \"0\") {\n if (m === \"0\") ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;\n else ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;\n } else ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;\n }\n $3CqZ1(\"caret return\", ret);\n return ret;\n });\n};\nconst $3675d6171478137e$var$replaceXRanges = (comp, options)=>{\n $3CqZ1(\"replaceXRanges\", comp, options);\n return comp.split(/\\s+/).map((c)=>$3675d6171478137e$var$replaceXRange(c, options)).join(\" \");\n};\nconst $3675d6171478137e$var$replaceXRange = (comp, options)=>{\n comp = comp.trim();\n const r = options.loose ? $3675d6171478137e$require$re[$3675d6171478137e$require$t.XRANGELOOSE] : $3675d6171478137e$require$re[$3675d6171478137e$require$t.XRANGE];\n return comp.replace(r, (ret, gtlt, M, m, p, pr)=>{\n $3CqZ1(\"xRange\", comp, ret, gtlt, M, m, p, pr);\n const xM = $3675d6171478137e$var$isX(M);\n const xm = xM || $3675d6171478137e$var$isX(m);\n const xp = xm || $3675d6171478137e$var$isX(p);\n const anyX = xp;\n if (gtlt === \"=\" && anyX) gtlt = \"\";\n // if we're including prereleases in the match, then we need\n // to fix this to -0, the lowest possible prerelease value\n pr = options.includePrerelease ? \"-0\" : \"\";\n if (xM) {\n if (gtlt === \">\" || gtlt === \"<\") // nothing is allowed\n ret = \"<0.0.0-0\";\n else // nothing is forbidden\n ret = \"*\";\n } else if (gtlt && anyX) {\n // we know patch is an x, because we have any x at all.\n // replace X with 0\n if (xm) m = 0;\n p = 0;\n if (gtlt === \">\") {\n // >1 => >=2.0.0\n // >1.2 => >=1.3.0\n gtlt = \">=\";\n if (xm) {\n M = +M + 1;\n m = 0;\n p = 0;\n } else {\n m = +m + 1;\n p = 0;\n }\n } else if (gtlt === \"<=\") {\n // <=0.7.x is actually <0.8.0, since any 0.7.x should\n // pass. Similarly, <=7.x is actually <8.0.0, etc.\n gtlt = \"<\";\n if (xm) M = +M + 1;\n else m = +m + 1;\n }\n if (gtlt === \"<\") pr = \"-0\";\n ret = `${gtlt + M}.${m}.${p}${pr}`;\n } else if (xm) ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;\n else if (xp) ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;\n $3CqZ1(\"xRange return\", ret);\n return ret;\n });\n};\n// Because * is AND-ed with everything else in the comparator,\n// and '' means \"any version\", just remove the *s entirely.\nconst $3675d6171478137e$var$replaceStars = (comp, options)=>{\n $3CqZ1(\"replaceStars\", comp, options);\n // Looseness is ignored here. star is always as loose as it gets!\n return comp.trim().replace($3675d6171478137e$require$re[$3675d6171478137e$require$t.STAR], \"\");\n};\nconst $3675d6171478137e$var$replaceGTE0 = (comp, options)=>{\n $3CqZ1(\"replaceGTE0\", comp, options);\n return comp.trim().replace($3675d6171478137e$require$re[options.includePrerelease ? $3675d6171478137e$require$t.GTE0PRE : $3675d6171478137e$require$t.GTE0], \"\");\n};\n// This function is passed to string.replace(re[t.HYPHENRANGE])\n// M, m, patch, prerelease, build\n// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5\n// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do\n// 1.2 - 3.4 => >=1.2.0 <3.5.0-0\nconst $3675d6171478137e$var$hyphenReplace = (incPr)=>($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb)=>{\n if ($3675d6171478137e$var$isX(fM)) from = \"\";\n else if ($3675d6171478137e$var$isX(fm)) from = `>=${fM}.0.0${incPr ? \"-0\" : \"\"}`;\n else if ($3675d6171478137e$var$isX(fp)) from = `>=${fM}.${fm}.0${incPr ? \"-0\" : \"\"}`;\n else if (fpr) from = `>=${from}`;\n else from = `>=${from}${incPr ? \"-0\" : \"\"}`;\n if ($3675d6171478137e$var$isX(tM)) to = \"\";\n else if ($3675d6171478137e$var$isX(tm)) to = `<${+tM + 1}.0.0-0`;\n else if ($3675d6171478137e$var$isX(tp)) to = `<${tM}.${+tm + 1}.0-0`;\n else if (tpr) to = `<=${tM}.${tm}.${tp}-${tpr}`;\n else if (incPr) to = `<${tM}.${tm}.${+tp + 1}-0`;\n else to = `<=${to}`;\n return `${from} ${to}`.trim();\n };\nconst $3675d6171478137e$var$testSet = (set, version, options)=>{\n for(let i = 0; i < set.length; i++){\n if (!set[i].test(version)) return false;\n }\n if (version.prerelease.length && !options.includePrerelease) {\n // Find the set of versions that are allowed to have prereleases\n // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0\n // That should allow `1.2.3-pr.2` to pass.\n // However, `1.2.4-alpha.notready` should NOT be allowed,\n // even though it's within the range set by the comparators.\n for(let i = 0; i < set.length; i++){\n $3CqZ1(set[i].semver);\n if (set[i].semver === $dSz9p.ANY) continue;\n if (set[i].semver.prerelease.length > 0) {\n const allowed = set[i].semver;\n if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) return true;\n }\n }\n // Version has a -pre, but it's not one of the ones we like.\n return false;\n }\n return true;\n};\n\n});\nparcelRegister(\"eGCLk\", function(module, exports) {\n\"use strict\";\n\nvar $JD6z9 = parcelRequire(\"JD6z9\");\nconst $ab130e548a2d4b38$var$MAX = Symbol(\"max\");\nconst $ab130e548a2d4b38$var$LENGTH = Symbol(\"length\");\nconst $ab130e548a2d4b38$var$LENGTH_CALCULATOR = Symbol(\"lengthCalculator\");\nconst $ab130e548a2d4b38$var$ALLOW_STALE = Symbol(\"allowStale\");\nconst $ab130e548a2d4b38$var$MAX_AGE = Symbol(\"maxAge\");\nconst $ab130e548a2d4b38$var$DISPOSE = Symbol(\"dispose\");\nconst $ab130e548a2d4b38$var$NO_DISPOSE_ON_SET = Symbol(\"noDisposeOnSet\");\nconst $ab130e548a2d4b38$var$LRU_LIST = Symbol(\"lruList\");\nconst $ab130e548a2d4b38$var$CACHE = Symbol(\"cache\");\nconst $ab130e548a2d4b38$var$UPDATE_AGE_ON_GET = Symbol(\"updateAgeOnGet\");\nconst $ab130e548a2d4b38$var$naiveLength = ()=>1;\n// lruList is a yallist where the head is the youngest\n// item, and the tail is the oldest. the list contains the Hit\n// objects as the entries.\n// Each Hit object has a reference to its Yallist.Node. This\n// never changes.\n//\n// cache is a Map (or PseudoMap) that matches the keys to\n// the Yallist.Node object.\nclass $ab130e548a2d4b38$var$LRUCache {\n constructor(options){\n if (typeof options === \"number\") options = {\n max: options\n };\n if (!options) options = {};\n if (options.max && (typeof options.max !== \"number\" || options.max < 0)) throw new TypeError(\"max must be a non-negative number\");\n // Kind of weird to have a default max of Infinity, but oh well.\n const max = this[$ab130e548a2d4b38$var$MAX] = options.max || Infinity;\n const lc = options.length || $ab130e548a2d4b38$var$naiveLength;\n this[$ab130e548a2d4b38$var$LENGTH_CALCULATOR] = typeof lc !== \"function\" ? $ab130e548a2d4b38$var$naiveLength : lc;\n this[$ab130e548a2d4b38$var$ALLOW_STALE] = options.stale || false;\n if (options.maxAge && typeof options.maxAge !== \"number\") throw new TypeError(\"maxAge must be a number\");\n this[$ab130e548a2d4b38$var$MAX_AGE] = options.maxAge || 0;\n this[$ab130e548a2d4b38$var$DISPOSE] = options.dispose;\n this[$ab130e548a2d4b38$var$NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;\n this[$ab130e548a2d4b38$var$UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;\n this.reset();\n }\n // resize the cache when the max changes.\n set max(mL) {\n if (typeof mL !== \"number\" || mL < 0) throw new TypeError(\"max must be a non-negative number\");\n this[$ab130e548a2d4b38$var$MAX] = mL || Infinity;\n $ab130e548a2d4b38$var$trim(this);\n }\n get max() {\n return this[$ab130e548a2d4b38$var$MAX];\n }\n set allowStale(allowStale) {\n this[$ab130e548a2d4b38$var$ALLOW_STALE] = !!allowStale;\n }\n get allowStale() {\n return this[$ab130e548a2d4b38$var$ALLOW_STALE];\n }\n set maxAge(mA) {\n if (typeof mA !== \"number\") throw new TypeError(\"maxAge must be a non-negative number\");\n this[$ab130e548a2d4b38$var$MAX_AGE] = mA;\n $ab130e548a2d4b38$var$trim(this);\n }\n get maxAge() {\n return this[$ab130e548a2d4b38$var$MAX_AGE];\n }\n // resize the cache when the lengthCalculator changes.\n set lengthCalculator(lC) {\n if (typeof lC !== \"function\") lC = $ab130e548a2d4b38$var$naiveLength;\n if (lC !== this[$ab130e548a2d4b38$var$LENGTH_CALCULATOR]) {\n this[$ab130e548a2d4b38$var$LENGTH_CALCULATOR] = lC;\n this[$ab130e548a2d4b38$var$LENGTH] = 0;\n this[$ab130e548a2d4b38$var$LRU_LIST].forEach((hit)=>{\n hit.length = this[$ab130e548a2d4b38$var$LENGTH_CALCULATOR](hit.value, hit.key);\n this[$ab130e548a2d4b38$var$LENGTH] += hit.length;\n });\n }\n $ab130e548a2d4b38$var$trim(this);\n }\n get lengthCalculator() {\n return this[$ab130e548a2d4b38$var$LENGTH_CALCULATOR];\n }\n get length() {\n return this[$ab130e548a2d4b38$var$LENGTH];\n }\n get itemCount() {\n return this[$ab130e548a2d4b38$var$LRU_LIST].length;\n }\n rforEach(fn, thisp) {\n thisp = thisp || this;\n for(let walker = this[$ab130e548a2d4b38$var$LRU_LIST].tail; walker !== null;){\n const prev = walker.prev;\n $ab130e548a2d4b38$var$forEachStep(this, fn, walker, thisp);\n walker = prev;\n }\n }\n forEach(fn, thisp) {\n thisp = thisp || this;\n for(let walker = this[$ab130e548a2d4b38$var$LRU_LIST].head; walker !== null;){\n const next = walker.next;\n $ab130e548a2d4b38$var$forEachStep(this, fn, walker, thisp);\n walker = next;\n }\n }\n keys() {\n return this[$ab130e548a2d4b38$var$LRU_LIST].toArray().map((k)=>k.key);\n }\n values() {\n return this[$ab130e548a2d4b38$var$LRU_LIST].toArray().map((k)=>k.value);\n }\n reset() {\n if (this[$ab130e548a2d4b38$var$DISPOSE] && this[$ab130e548a2d4b38$var$LRU_LIST] && this[$ab130e548a2d4b38$var$LRU_LIST].length) this[$ab130e548a2d4b38$var$LRU_LIST].forEach((hit)=>this[$ab130e548a2d4b38$var$DISPOSE](hit.key, hit.value));\n this[$ab130e548a2d4b38$var$CACHE] = new Map() // hash of items by key\n ;\n this[$ab130e548a2d4b38$var$LRU_LIST] = new $JD6z9() // list of items in order of use recency\n ;\n this[$ab130e548a2d4b38$var$LENGTH] = 0 // length of items in the list\n ;\n }\n dump() {\n return this[$ab130e548a2d4b38$var$LRU_LIST].map((hit)=>$ab130e548a2d4b38$var$isStale(this, hit) ? false : {\n k: hit.key,\n v: hit.value,\n e: hit.now + (hit.maxAge || 0)\n }).toArray().filter((h)=>h);\n }\n dumpLru() {\n return this[$ab130e548a2d4b38$var$LRU_LIST];\n }\n set(key, value, maxAge) {\n maxAge = maxAge || this[$ab130e548a2d4b38$var$MAX_AGE];\n if (maxAge && typeof maxAge !== \"number\") throw new TypeError(\"maxAge must be a number\");\n const now = maxAge ? Date.now() : 0;\n const len = this[$ab130e548a2d4b38$var$LENGTH_CALCULATOR](value, key);\n if (this[$ab130e548a2d4b38$var$CACHE].has(key)) {\n if (len > this[$ab130e548a2d4b38$var$MAX]) {\n $ab130e548a2d4b38$var$del(this, this[$ab130e548a2d4b38$var$CACHE].get(key));\n return false;\n }\n const node = this[$ab130e548a2d4b38$var$CACHE].get(key);\n const item = node.value;\n // dispose of the old one before overwriting\n // split out into 2 ifs for better coverage tracking\n if (this[$ab130e548a2d4b38$var$DISPOSE]) {\n if (!this[$ab130e548a2d4b38$var$NO_DISPOSE_ON_SET]) this[$ab130e548a2d4b38$var$DISPOSE](key, item.value);\n }\n item.now = now;\n item.maxAge = maxAge;\n item.value = value;\n this[$ab130e548a2d4b38$var$LENGTH] += len - item.length;\n item.length = len;\n this.get(key);\n $ab130e548a2d4b38$var$trim(this);\n return true;\n }\n const hit = new $ab130e548a2d4b38$var$Entry(key, value, len, now, maxAge);\n // oversized objects fall out of cache automatically.\n if (hit.length > this[$ab130e548a2d4b38$var$MAX]) {\n if (this[$ab130e548a2d4b38$var$DISPOSE]) this[$ab130e548a2d4b38$var$DISPOSE](key, value);\n return false;\n }\n this[$ab130e548a2d4b38$var$LENGTH] += hit.length;\n this[$ab130e548a2d4b38$var$LRU_LIST].unshift(hit);\n this[$ab130e548a2d4b38$var$CACHE].set(key, this[$ab130e548a2d4b38$var$LRU_LIST].head);\n $ab130e548a2d4b38$var$trim(this);\n return true;\n }\n has(key) {\n if (!this[$ab130e548a2d4b38$var$CACHE].has(key)) return false;\n const hit = this[$ab130e548a2d4b38$var$CACHE].get(key).value;\n return !$ab130e548a2d4b38$var$isStale(this, hit);\n }\n get(key) {\n return $ab130e548a2d4b38$var$get(this, key, true);\n }\n peek(key) {\n return $ab130e548a2d4b38$var$get(this, key, false);\n }\n pop() {\n const node = this[$ab130e548a2d4b38$var$LRU_LIST].tail;\n if (!node) return null;\n $ab130e548a2d4b38$var$del(this, node);\n return node.value;\n }\n del(key) {\n $ab130e548a2d4b38$var$del(this, this[$ab130e548a2d4b38$var$CACHE].get(key));\n }\n load(arr) {\n // reset the cache\n this.reset();\n const now = Date.now();\n // A previous serialized cache has the most recent items first\n for(let l = arr.length - 1; l >= 0; l--){\n const hit = arr[l];\n const expiresAt = hit.e || 0;\n if (expiresAt === 0) // the item was created without expiration in a non aged cache\n this.set(hit.k, hit.v);\n else {\n const maxAge = expiresAt - now;\n // dont add already expired items\n if (maxAge > 0) this.set(hit.k, hit.v, maxAge);\n }\n }\n }\n prune() {\n this[$ab130e548a2d4b38$var$CACHE].forEach((value, key)=>$ab130e548a2d4b38$var$get(this, key, false));\n }\n}\nconst $ab130e548a2d4b38$var$get = (self, key, doUse)=>{\n const node = self[$ab130e548a2d4b38$var$CACHE].get(key);\n if (node) {\n const hit = node.value;\n if ($ab130e548a2d4b38$var$isStale(self, hit)) {\n $ab130e548a2d4b38$var$del(self, node);\n if (!self[$ab130e548a2d4b38$var$ALLOW_STALE]) return undefined;\n } else if (doUse) {\n if (self[$ab130e548a2d4b38$var$UPDATE_AGE_ON_GET]) node.value.now = Date.now();\n self[$ab130e548a2d4b38$var$LRU_LIST].unshiftNode(node);\n }\n return hit.value;\n }\n};\nconst $ab130e548a2d4b38$var$isStale = (self, hit)=>{\n if (!hit || !hit.maxAge && !self[$ab130e548a2d4b38$var$MAX_AGE]) return false;\n const diff = Date.now() - hit.now;\n return hit.maxAge ? diff > hit.maxAge : self[$ab130e548a2d4b38$var$MAX_AGE] && diff > self[$ab130e548a2d4b38$var$MAX_AGE];\n};\nconst $ab130e548a2d4b38$var$trim = (self)=>{\n if (self[$ab130e548a2d4b38$var$LENGTH] > self[$ab130e548a2d4b38$var$MAX]) for(let walker = self[$ab130e548a2d4b38$var$LRU_LIST].tail; self[$ab130e548a2d4b38$var$LENGTH] > self[$ab130e548a2d4b38$var$MAX] && walker !== null;){\n // We know that we're about to delete this one, and also\n // what the next least recently used key will be, so just\n // go ahead and set it now.\n const prev = walker.prev;\n $ab130e548a2d4b38$var$del(self, walker);\n walker = prev;\n }\n};\nconst $ab130e548a2d4b38$var$del = (self, node)=>{\n if (node) {\n const hit = node.value;\n if (self[$ab130e548a2d4b38$var$DISPOSE]) self[$ab130e548a2d4b38$var$DISPOSE](hit.key, hit.value);\n self[$ab130e548a2d4b38$var$LENGTH] -= hit.length;\n self[$ab130e548a2d4b38$var$CACHE].delete(hit.key);\n self[$ab130e548a2d4b38$var$LRU_LIST].removeNode(node);\n }\n};\nclass $ab130e548a2d4b38$var$Entry {\n constructor(key, value, length, now, maxAge){\n this.key = key;\n this.value = value;\n this.length = length;\n this.now = now;\n this.maxAge = maxAge || 0;\n }\n}\nconst $ab130e548a2d4b38$var$forEachStep = (self, fn, node, thisp)=>{\n let hit = node.value;\n if ($ab130e548a2d4b38$var$isStale(self, hit)) {\n $ab130e548a2d4b38$var$del(self, node);\n if (!self[$ab130e548a2d4b38$var$ALLOW_STALE]) hit = undefined;\n }\n if (hit) fn.call(thisp, hit.value, hit.key, self);\n};\nmodule.exports = $ab130e548a2d4b38$var$LRUCache;\n\n});\nparcelRegister(\"JD6z9\", function(module, exports) {\n\"use strict\";\nmodule.exports = $08928980bda7e450$var$Yallist;\n$08928980bda7e450$var$Yallist.Node = $08928980bda7e450$var$Node;\n$08928980bda7e450$var$Yallist.create = $08928980bda7e450$var$Yallist;\nfunction $08928980bda7e450$var$Yallist(list) {\n var self = this;\n if (!(self instanceof $08928980bda7e450$var$Yallist)) self = new $08928980bda7e450$var$Yallist();\n self.tail = null;\n self.head = null;\n self.length = 0;\n if (list && typeof list.forEach === \"function\") list.forEach(function(item) {\n self.push(item);\n });\n else if (arguments.length > 0) for(var i = 0, l = arguments.length; i < l; i++)self.push(arguments[i]);\n return self;\n}\n$08928980bda7e450$var$Yallist.prototype.removeNode = function(node) {\n if (node.list !== this) throw new Error(\"removing node which does not belong to this list\");\n var next = node.next;\n var prev = node.prev;\n if (next) next.prev = prev;\n if (prev) prev.next = next;\n if (node === this.head) this.head = next;\n if (node === this.tail) this.tail = prev;\n node.list.length--;\n node.next = null;\n node.prev = null;\n node.list = null;\n return next;\n};\n$08928980bda7e450$var$Yallist.prototype.unshiftNode = function(node) {\n if (node === this.head) return;\n if (node.list) node.list.removeNode(node);\n var head = this.head;\n node.list = this;\n node.next = head;\n if (head) head.prev = node;\n this.head = node;\n if (!this.tail) this.tail = node;\n this.length++;\n};\n$08928980bda7e450$var$Yallist.prototype.pushNode = function(node) {\n if (node === this.tail) return;\n if (node.list) node.list.removeNode(node);\n var tail = this.tail;\n node.list = this;\n node.prev = tail;\n if (tail) tail.next = node;\n this.tail = node;\n if (!this.head) this.head = node;\n this.length++;\n};\n$08928980bda7e450$var$Yallist.prototype.push = function() {\n for(var i = 0, l = arguments.length; i < l; i++)$08928980bda7e450$var$push(this, arguments[i]);\n return this.length;\n};\n$08928980bda7e450$var$Yallist.prototype.unshift = function() {\n for(var i = 0, l = arguments.length; i < l; i++)$08928980bda7e450$var$unshift(this, arguments[i]);\n return this.length;\n};\n$08928980bda7e450$var$Yallist.prototype.pop = function() {\n if (!this.tail) return undefined;\n var res = this.tail.value;\n this.tail = this.tail.prev;\n if (this.tail) this.tail.next = null;\n else this.head = null;\n this.length--;\n return res;\n};\n$08928980bda7e450$var$Yallist.prototype.shift = function() {\n if (!this.head) return undefined;\n var res = this.head.value;\n this.head = this.head.next;\n if (this.head) this.head.prev = null;\n else this.tail = null;\n this.length--;\n return res;\n};\n$08928980bda7e450$var$Yallist.prototype.forEach = function(fn, thisp) {\n thisp = thisp || this;\n for(var walker = this.head, i = 0; walker !== null; i++){\n fn.call(thisp, walker.value, i, this);\n walker = walker.next;\n }\n};\n$08928980bda7e450$var$Yallist.prototype.forEachReverse = function(fn, thisp) {\n thisp = thisp || this;\n for(var walker = this.tail, i = this.length - 1; walker !== null; i--){\n fn.call(thisp, walker.value, i, this);\n walker = walker.prev;\n }\n};\n$08928980bda7e450$var$Yallist.prototype.get = function(n) {\n for(var i = 0, walker = this.head; walker !== null && i < n; i++)// abort out of the list early if we hit a cycle\n walker = walker.next;\n if (i === n && walker !== null) return walker.value;\n};\n$08928980bda7e450$var$Yallist.prototype.getReverse = function(n) {\n for(var i = 0, walker = this.tail; walker !== null && i < n; i++)// abort out of the list early if we hit a cycle\n walker = walker.prev;\n if (i === n && walker !== null) return walker.value;\n};\n$08928980bda7e450$var$Yallist.prototype.map = function(fn, thisp) {\n thisp = thisp || this;\n var res = new $08928980bda7e450$var$Yallist();\n for(var walker = this.head; walker !== null;){\n res.push(fn.call(thisp, walker.value, this));\n walker = walker.next;\n }\n return res;\n};\n$08928980bda7e450$var$Yallist.prototype.mapReverse = function(fn, thisp) {\n thisp = thisp || this;\n var res = new $08928980bda7e450$var$Yallist();\n for(var walker = this.tail; walker !== null;){\n res.push(fn.call(thisp, walker.value, this));\n walker = walker.prev;\n }\n return res;\n};\n$08928980bda7e450$var$Yallist.prototype.reduce = function(fn, initial) {\n var acc;\n var walker = this.head;\n if (arguments.length > 1) acc = initial;\n else if (this.head) {\n walker = this.head.next;\n acc = this.head.value;\n } else throw new TypeError(\"Reduce of empty list with no initial value\");\n for(var i = 0; walker !== null; i++){\n acc = fn(acc, walker.value, i);\n walker = walker.next;\n }\n return acc;\n};\n$08928980bda7e450$var$Yallist.prototype.reduceReverse = function(fn, initial) {\n var acc;\n var walker = this.tail;\n if (arguments.length > 1) acc = initial;\n else if (this.tail) {\n walker = this.tail.prev;\n acc = this.tail.value;\n } else throw new TypeError(\"Reduce of empty list with no initial value\");\n for(var i = this.length - 1; walker !== null; i--){\n acc = fn(acc, walker.value, i);\n walker = walker.prev;\n }\n return acc;\n};\n$08928980bda7e450$var$Yallist.prototype.toArray = function() {\n var arr = new Array(this.length);\n for(var i = 0, walker = this.head; walker !== null; i++){\n arr[i] = walker.value;\n walker = walker.next;\n }\n return arr;\n};\n$08928980bda7e450$var$Yallist.prototype.toArrayReverse = function() {\n var arr = new Array(this.length);\n for(var i = 0, walker = this.tail; walker !== null; i++){\n arr[i] = walker.value;\n walker = walker.prev;\n }\n return arr;\n};\n$08928980bda7e450$var$Yallist.prototype.slice = function(from, to) {\n to = to || this.length;\n if (to < 0) to += this.length;\n from = from || 0;\n if (from < 0) from += this.length;\n var ret = new $08928980bda7e450$var$Yallist();\n if (to < from || to < 0) return ret;\n if (from < 0) from = 0;\n if (to > this.length) to = this.length;\n for(var i = 0, walker = this.head; walker !== null && i < from; i++)walker = walker.next;\n for(; walker !== null && i < to; i++, walker = walker.next)ret.push(walker.value);\n return ret;\n};\n$08928980bda7e450$var$Yallist.prototype.sliceReverse = function(from, to) {\n to = to || this.length;\n if (to < 0) to += this.length;\n from = from || 0;\n if (from < 0) from += this.length;\n var ret = new $08928980bda7e450$var$Yallist();\n if (to < from || to < 0) return ret;\n if (from < 0) from = 0;\n if (to > this.length) to = this.length;\n for(var i = this.length, walker = this.tail; walker !== null && i > to; i--)walker = walker.prev;\n for(; walker !== null && i > from; i--, walker = walker.prev)ret.push(walker.value);\n return ret;\n};\n$08928980bda7e450$var$Yallist.prototype.splice = function(start, deleteCount, ...nodes) {\n if (start > this.length) start = this.length - 1;\n if (start < 0) start = this.length + start;\n for(var i = 0, walker = this.head; walker !== null && i < start; i++)walker = walker.next;\n var ret = [];\n for(var i = 0; walker && i < deleteCount; i++){\n ret.push(walker.value);\n walker = this.removeNode(walker);\n }\n if (walker === null) walker = this.tail;\n if (walker !== this.head && walker !== this.tail) walker = walker.prev;\n for(var i = 0; i < nodes.length; i++)walker = $08928980bda7e450$var$insert(this, walker, nodes[i]);\n return ret;\n};\n$08928980bda7e450$var$Yallist.prototype.reverse = function() {\n var head = this.head;\n var tail = this.tail;\n for(var walker = head; walker !== null; walker = walker.prev){\n var p = walker.prev;\n walker.prev = walker.next;\n walker.next = p;\n }\n this.head = tail;\n this.tail = head;\n return this;\n};\nfunction $08928980bda7e450$var$insert(self, node, value) {\n var inserted = node === self.head ? new $08928980bda7e450$var$Node(value, null, node, self) : new $08928980bda7e450$var$Node(value, node, node.next, self);\n if (inserted.next === null) self.tail = inserted;\n if (inserted.prev === null) self.head = inserted;\n self.length++;\n return inserted;\n}\nfunction $08928980bda7e450$var$push(self, item) {\n self.tail = new $08928980bda7e450$var$Node(item, self.tail, null, self);\n if (!self.head) self.head = self.tail;\n self.length++;\n}\nfunction $08928980bda7e450$var$unshift(self, item) {\n self.head = new $08928980bda7e450$var$Node(item, null, self.head, self);\n if (!self.tail) self.tail = self.head;\n self.length++;\n}\nfunction $08928980bda7e450$var$Node(value, prev, next, list) {\n if (!(this instanceof $08928980bda7e450$var$Node)) return new $08928980bda7e450$var$Node(value, prev, next, list);\n this.list = list;\n this.value = value;\n if (prev) {\n prev.next = this;\n this.prev = prev;\n } else this.prev = null;\n if (next) {\n next.prev = this;\n this.next = next;\n } else this.next = null;\n}\n\ntry {\n // add if support for Symbol.iterator is present\n (parcelRequire(\"6mmJJ\"))($08928980bda7e450$var$Yallist);\n} catch (er) {}\n\n});\nparcelRegister(\"6mmJJ\", function(module, exports) {\n\"use strict\";\nmodule.exports = function(Yallist) {\n Yallist.prototype[Symbol.iterator] = function*() {\n for(let walker = this.head; walker; walker = walker.next)yield walker.value;\n };\n};\n\n});\n\n\n\n\n\nparcelRegister(\"2bU8Y\", function(module, exports) {\n\nvar $4FTez = parcelRequire(\"4FTez\");\nconst $198828d4690f72ab$var$satisfies = (version, range, options)=>{\n try {\n range = new $4FTez(range, options);\n } catch (er) {\n return false;\n }\n return range.test(version);\n};\nmodule.exports = $198828d4690f72ab$var$satisfies;\n\n});\n\nparcelRegister(\"eRnrA\", function(module, exports) {\n\nvar $4FTez = parcelRequire(\"4FTez\");\n// Mostly just for testing and legacy API reasons\nconst $ad183366a1601ea2$var$toComparators = (range, options)=>new $4FTez(range, options).set.map((comp)=>comp.map((c)=>c.value).join(\" \").trim().split(\" \"));\nmodule.exports = $ad183366a1601ea2$var$toComparators;\n\n});\n\nparcelRegister(\"aAvhf\", function(module, exports) {\n\nvar $aMLnW = parcelRequire(\"aMLnW\");\n\nvar $4FTez = parcelRequire(\"4FTez\");\nconst $7b55873206bf39b9$var$maxSatisfying = (versions, range, options)=>{\n let max = null;\n let maxSV = null;\n let rangeObj = null;\n try {\n rangeObj = new $4FTez(range, options);\n } catch (er) {\n return null;\n }\n versions.forEach((v)=>{\n if (rangeObj.test(v)) // satisfies(v, range, options)\n {\n if (!max || maxSV.compare(v) === -1) {\n // compare(max, v, true)\n max = v;\n maxSV = new $aMLnW(max, options);\n }\n }\n });\n return max;\n};\nmodule.exports = $7b55873206bf39b9$var$maxSatisfying;\n\n});\n\nparcelRegister(\"iWAcu\", function(module, exports) {\n\nvar $aMLnW = parcelRequire(\"aMLnW\");\n\nvar $4FTez = parcelRequire(\"4FTez\");\nconst $dca9b97392366ccd$var$minSatisfying = (versions, range, options)=>{\n let min = null;\n let minSV = null;\n let rangeObj = null;\n try {\n rangeObj = new $4FTez(range, options);\n } catch (er) {\n return null;\n }\n versions.forEach((v)=>{\n if (rangeObj.test(v)) // satisfies(v, range, options)\n {\n if (!min || minSV.compare(v) === 1) {\n // compare(min, v, true)\n min = v;\n minSV = new $aMLnW(min, options);\n }\n }\n });\n return min;\n};\nmodule.exports = $dca9b97392366ccd$var$minSatisfying;\n\n});\n\nparcelRegister(\"32TwK\", function(module, exports) {\n\nvar $aMLnW = parcelRequire(\"aMLnW\");\n\nvar $4FTez = parcelRequire(\"4FTez\");\n\nvar $cPjhN = parcelRequire(\"cPjhN\");\nconst $237ca191c3ae55cc$var$minVersion = (range, loose)=>{\n range = new $4FTez(range, loose);\n let minver = new $aMLnW(\"0.0.0\");\n if (range.test(minver)) return minver;\n minver = new $aMLnW(\"0.0.0-0\");\n if (range.test(minver)) return minver;\n minver = null;\n for(let i = 0; i < range.set.length; ++i){\n const comparators = range.set[i];\n let setMin = null;\n comparators.forEach((comparator)=>{\n // Clone to avoid manipulating the comparator's semver object.\n const compver = new $aMLnW(comparator.semver.version);\n switch(comparator.operator){\n case \">\":\n if (compver.prerelease.length === 0) compver.patch++;\n else compver.prerelease.push(0);\n compver.raw = compver.format();\n /* fallthrough */ case \"\":\n case \">=\":\n if (!setMin || $cPjhN(compver, setMin)) setMin = compver;\n break;\n case \"<\":\n case \"<=\":\n break;\n /* istanbul ignore next */ default:\n throw new Error(`Unexpected operation: ${comparator.operator}`);\n }\n });\n if (setMin && (!minver || $cPjhN(minver, setMin))) minver = setMin;\n }\n if (minver && range.test(minver)) return minver;\n return null;\n};\nmodule.exports = $237ca191c3ae55cc$var$minVersion;\n\n});\n\nparcelRegister(\"194Ox\", function(module, exports) {\n\nvar $4FTez = parcelRequire(\"4FTez\");\nconst $0d5a5dad0eeb3de1$var$validRange = (range, options)=>{\n try {\n // Return '*' instead of '' so that truthiness works.\n // This will throw if it's invalid anyway\n return new $4FTez(range, options).range || \"*\";\n } catch (er) {\n return null;\n }\n};\nmodule.exports = $0d5a5dad0eeb3de1$var$validRange;\n\n});\n\nparcelRegister(\"a8VZj\", function(module, exports) {\n\nvar $aMLnW = parcelRequire(\"aMLnW\");\n\nvar $dSz9p = parcelRequire(\"dSz9p\");\nconst { ANY: $7627a1f1d8b68e56$var$ANY } = $dSz9p;\n\nvar $4FTez = parcelRequire(\"4FTez\");\n\nvar $2bU8Y = parcelRequire(\"2bU8Y\");\n\nvar $cPjhN = parcelRequire(\"cPjhN\");\n\nvar $avz3V = parcelRequire(\"avz3V\");\n\nvar $8aNoG = parcelRequire(\"8aNoG\");\n\nvar $9xdhv = parcelRequire(\"9xdhv\");\nconst $7627a1f1d8b68e56$var$outside = (version, range, hilo, options)=>{\n version = new $aMLnW(version, options);\n range = new $4FTez(range, options);\n let gtfn, ltefn, ltfn, comp, ecomp;\n switch(hilo){\n case \">\":\n gtfn = $cPjhN;\n ltefn = $8aNoG;\n ltfn = $avz3V;\n comp = \">\";\n ecomp = \">=\";\n break;\n case \"<\":\n gtfn = $avz3V;\n ltefn = $9xdhv;\n ltfn = $cPjhN;\n comp = \"<\";\n ecomp = \"<=\";\n break;\n default:\n throw new TypeError('Must provide a hilo val of \"<\" or \">\"');\n }\n // If it satisfies the range it is not outside\n if ($2bU8Y(version, range, options)) return false;\n // From now on, variable terms are as if we're in \"gtr\" mode.\n // but note that everything is flipped for the \"ltr\" function.\n for(let i = 0; i < range.set.length; ++i){\n const comparators = range.set[i];\n let high = null;\n let low = null;\n comparators.forEach((comparator)=>{\n if (comparator.semver === $7627a1f1d8b68e56$var$ANY) comparator = new $dSz9p(\">=0.0.0\");\n high = high || comparator;\n low = low || comparator;\n if (gtfn(comparator.semver, high.semver, options)) high = comparator;\n else if (ltfn(comparator.semver, low.semver, options)) low = comparator;\n });\n // If the edge version comparator has a operator then our version\n // isn't outside it\n if (high.operator === comp || high.operator === ecomp) return false;\n // If the lowest version comparator has an operator and our version\n // is less than it then it isn't higher than the range\n if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) return false;\n else if (low.operator === ecomp && ltfn(version, low.semver)) return false;\n }\n return true;\n};\nmodule.exports = $7627a1f1d8b68e56$var$outside;\n\n});\n\nparcelRegister(\"2yv5J\", function(module, exports) {\n// Determine if version is greater than all the versions possible in the range.\n\nvar $a8VZj = parcelRequire(\"a8VZj\");\nconst $1dc6dfd60f6d4b61$var$gtr = (version, range, options)=>$a8VZj(version, range, \">\", options);\nmodule.exports = $1dc6dfd60f6d4b61$var$gtr;\n\n});\n\nparcelRegister(\"46KXA\", function(module, exports) {\n\nvar $a8VZj = parcelRequire(\"a8VZj\");\n// Determine if version is less than all the versions possible in the range\nconst $2fdc264220ba3549$var$ltr = (version, range, options)=>$a8VZj(version, range, \"<\", options);\nmodule.exports = $2fdc264220ba3549$var$ltr;\n\n});\n\nparcelRegister(\"e3Thp\", function(module, exports) {\n\nvar $4FTez = parcelRequire(\"4FTez\");\nconst $a3cc39e8e39a0af8$var$intersects = (r1, r2, options)=>{\n r1 = new $4FTez(r1, options);\n r2 = new $4FTez(r2, options);\n return r1.intersects(r2, options);\n};\nmodule.exports = $a3cc39e8e39a0af8$var$intersects;\n\n});\n\nparcelRegister(\"8g51l\", function(module, exports) {\n// given a set of versions and a range, create a \"simplified\" range\n// that includes the same versions that the original range does\n// If the original range is shorter than the simplified one, return that.\n\nvar $2bU8Y = parcelRequire(\"2bU8Y\");\n\nvar $3uysP = parcelRequire(\"3uysP\");\nmodule.exports = (versions, range, options)=>{\n const set = [];\n let first = null;\n let prev = null;\n const v = versions.sort((a, b)=>$3uysP(a, b, options));\n for (const version of v){\n const included = $2bU8Y(version, range, options);\n if (included) {\n prev = version;\n if (!first) first = version;\n } else {\n if (prev) set.push([\n first,\n prev\n ]);\n prev = null;\n first = null;\n }\n }\n if (first) set.push([\n first,\n null\n ]);\n const ranges = [];\n for (const [min, max] of set){\n if (min === max) ranges.push(min);\n else if (!max && min === v[0]) ranges.push(\"*\");\n else if (!max) ranges.push(`>=${min}`);\n else if (min === v[0]) ranges.push(`<=${max}`);\n else ranges.push(`${min} - ${max}`);\n }\n const simplified = ranges.join(\" || \");\n const original = typeof range.raw === \"string\" ? range.raw : String(range);\n return simplified.length < original.length ? simplified : range;\n};\n\n});\n\nparcelRegister(\"96YVB\", function(module, exports) {\n\nvar $4FTez = parcelRequire(\"4FTez\");\n\nvar $dSz9p = parcelRequire(\"dSz9p\");\nconst { ANY: $6a23efa6855afc70$var$ANY } = $dSz9p;\n\nvar $2bU8Y = parcelRequire(\"2bU8Y\");\n\nvar $3uysP = parcelRequire(\"3uysP\");\n// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:\n// - Every simple range `r1, r2, ...` is a null set, OR\n// - Every simple range `r1, r2, ...` which is not a null set is a subset of\n// some `R1, R2, ...`\n//\n// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:\n// - If c is only the ANY comparator\n// - If C is only the ANY comparator, return true\n// - Else if in prerelease mode, return false\n// - else replace c with `[>=0.0.0]`\n// - If C is only the ANY comparator\n// - if in prerelease mode, return true\n// - else replace C with `[>=0.0.0]`\n// - Let EQ be the set of = comparators in c\n// - If EQ is more than one, return true (null set)\n// - Let GT be the highest > or >= comparator in c\n// - Let LT be the lowest < or <= comparator in c\n// - If GT and LT, and GT.semver > LT.semver, return true (null set)\n// - If any C is a = range, and GT or LT are set, return false\n// - If EQ\n// - If GT, and EQ does not satisfy GT, return true (null set)\n// - If LT, and EQ does not satisfy LT, return true (null set)\n// - If EQ satisfies every C, return true\n// - Else return false\n// - If GT\n// - If GT.semver is lower than any > or >= comp in C, return false\n// - If GT is >=, and GT.semver does not satisfy every C, return false\n// - If GT.semver has a prerelease, and not in prerelease mode\n// - If no C has a prerelease and the GT.semver tuple, return false\n// - If LT\n// - If LT.semver is greater than any < or <= comp in C, return false\n// - If LT is <=, and LT.semver does not satisfy every C, return false\n// - If GT.semver has a prerelease, and not in prerelease mode\n// - If no C has a prerelease and the LT.semver tuple, return false\n// - Else return true\nconst $6a23efa6855afc70$var$subset = (sub, dom, options = {})=>{\n if (sub === dom) return true;\n sub = new $4FTez(sub, options);\n dom = new $4FTez(dom, options);\n let sawNonNull = false;\n OUTER: for (const simpleSub of sub.set){\n for (const simpleDom of dom.set){\n const isSub = $6a23efa6855afc70$var$simpleSubset(simpleSub, simpleDom, options);\n sawNonNull = sawNonNull || isSub !== null;\n if (isSub) continue OUTER;\n }\n // the null set is a subset of everything, but null simple ranges in\n // a complex range should be ignored. so if we saw a non-null range,\n // then we know this isn't a subset, but if EVERY simple range was null,\n // then it is a subset.\n if (sawNonNull) return false;\n }\n return true;\n};\nconst $6a23efa6855afc70$var$minimumVersionWithPreRelease = [\n new $dSz9p(\">=0.0.0-0\")\n];\nconst $6a23efa6855afc70$var$minimumVersion = [\n new $dSz9p(\">=0.0.0\")\n];\nconst $6a23efa6855afc70$var$simpleSubset = (sub, dom, options)=>{\n if (sub === dom) return true;\n if (sub.length === 1 && sub[0].semver === $6a23efa6855afc70$var$ANY) {\n if (dom.length === 1 && dom[0].semver === $6a23efa6855afc70$var$ANY) return true;\n else if (options.includePrerelease) sub = $6a23efa6855afc70$var$minimumVersionWithPreRelease;\n else sub = $6a23efa6855afc70$var$minimumVersion;\n }\n if (dom.length === 1 && dom[0].semver === $6a23efa6855afc70$var$ANY) {\n if (options.includePrerelease) return true;\n else dom = $6a23efa6855afc70$var$minimumVersion;\n }\n const eqSet = new Set();\n let gt, lt;\n for (const c of sub){\n if (c.operator === \">\" || c.operator === \">=\") gt = $6a23efa6855afc70$var$higherGT(gt, c, options);\n else if (c.operator === \"<\" || c.operator === \"<=\") lt = $6a23efa6855afc70$var$lowerLT(lt, c, options);\n else eqSet.add(c.semver);\n }\n if (eqSet.size > 1) return null;\n let gtltComp;\n if (gt && lt) {\n gtltComp = $3uysP(gt.semver, lt.semver, options);\n if (gtltComp > 0) return null;\n else if (gtltComp === 0 && (gt.operator !== \">=\" || lt.operator !== \"<=\")) return null;\n }\n // will iterate one or zero times\n for (const eq of eqSet){\n if (gt && !$2bU8Y(eq, String(gt), options)) return null;\n if (lt && !$2bU8Y(eq, String(lt), options)) return null;\n for (const c of dom){\n if (!$2bU8Y(eq, String(c), options)) return false;\n }\n return true;\n }\n let higher, lower;\n let hasDomLT, hasDomGT;\n // if the subset has a prerelease, we need a comparator in the superset\n // with the same tuple and a prerelease, or it's not a subset\n let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;\n let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;\n // exception: <1.2.3-0 is the same as <1.2.3\n if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === \"<\" && needDomLTPre.prerelease[0] === 0) needDomLTPre = false;\n for (const c of dom){\n hasDomGT = hasDomGT || c.operator === \">\" || c.operator === \">=\";\n hasDomLT = hasDomLT || c.operator === \"<\" || c.operator === \"<=\";\n if (gt) {\n if (needDomGTPre) {\n if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) needDomGTPre = false;\n }\n if (c.operator === \">\" || c.operator === \">=\") {\n higher = $6a23efa6855afc70$var$higherGT(gt, c, options);\n if (higher === c && higher !== gt) return false;\n } else if (gt.operator === \">=\" && !$2bU8Y(gt.semver, String(c), options)) return false;\n }\n if (lt) {\n if (needDomLTPre) {\n if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) needDomLTPre = false;\n }\n if (c.operator === \"<\" || c.operator === \"<=\") {\n lower = $6a23efa6855afc70$var$lowerLT(lt, c, options);\n if (lower === c && lower !== lt) return false;\n } else if (lt.operator === \"<=\" && !$2bU8Y(lt.semver, String(c), options)) return false;\n }\n if (!c.operator && (lt || gt) && gtltComp !== 0) return false;\n }\n // if there was a < or >, and nothing in the dom, then must be false\n // UNLESS it was limited by another range in the other direction.\n // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0\n if (gt && hasDomLT && !lt && gtltComp !== 0) return false;\n if (lt && hasDomGT && !gt && gtltComp !== 0) return false;\n // we needed a prerelease range in a specific tuple, but didn't get one\n // then this isn't a subset. eg >=1.2.3-pre is not a subset of >=1.0.0,\n // because it includes prereleases in the 1.2.3 tuple\n if (needDomGTPre || needDomLTPre) return false;\n return true;\n};\n// >=1.2.3 is lower than >1.2.3\nconst $6a23efa6855afc70$var$higherGT = (a, b, options)=>{\n if (!a) return b;\n const comp = $3uysP(a.semver, b.semver, options);\n return comp > 0 ? a : comp < 0 ? b : b.operator === \">\" && a.operator === \">=\" ? b : a;\n};\n// <=1.2.3 is higher than <1.2.3\nconst $6a23efa6855afc70$var$lowerLT = (a, b, options)=>{\n if (!a) return b;\n const comp = $3uysP(a.semver, b.semver, options);\n return comp < 0 ? a : comp > 0 ? b : b.operator === \"<\" && a.operator === \"<=\" ? b : a;\n};\nmodule.exports = $6a23efa6855afc70$var$subset;\n\n});\n\n\nparcelRegister(\"i8A01\", function(module, exports) {\n\"use strict\";\nvar $d344e60cef0315df$var$matchOperatorsRe = /[|\\\\{}()[\\]^$+*?.]/g;\nmodule.exports = function(str) {\n if (typeof str !== \"string\") throw new TypeError(\"Expected a string\");\n return str.replace($d344e60cef0315df$var$matchOperatorsRe, \"\\\\$&\");\n};\n\n});\n\nparcelRegister(\"kY0n1\", function(module, exports) {\n\n$parcel$export(module.exports, \"pathExists\", () => $f439b2cda090cb68$export$f8b9fb4db095815b);\n\nasync function $f439b2cda090cb68$export$f8b9fb4db095815b(path) {\n try {\n await (0, $d7DIX$nodefs.promises).access(path);\n return true;\n } catch {\n return false;\n }\n}\nfunction $f439b2cda090cb68$export$d878061e34fd0f5a(path) {\n try {\n (0, ($parcel$interopDefault($d7DIX$nodefs))).accessSync(path);\n return true;\n } catch {\n return false;\n }\n}\n\n});\n\nparcelRegister(\"bzNgi\", function(module, exports) {\n\n$parcel$export(module.exports, \"addExeExt\", () => $3294af0a12e8cafb$export$2d20c564cade3c93);\n$parcel$export(module.exports, \"addShExt\", () => $3294af0a12e8cafb$export$609be29b80b555e1);\n$parcel$export(module.exports, \"addShRelativePrefix\", () => $3294af0a12e8cafb$export$e1f23f8d3e53fe6);\n$parcel$export(module.exports, \"dirname\", () => $d7DIX$path.dirname);\n$parcel$export(module.exports, \"join\", () => $d7DIX$path.join);\n\n\nvar $iNGpn = parcelRequire(\"iNGpn\");\n\nvar $axeRu = parcelRequire(\"axeRu\");\nfunction $3294af0a12e8cafb$var$e(e, a) {\n return Object.keys(a).forEach((r)=>{\n \"default\" === r || \"__esModule\" === r || e.hasOwnProperty(r) || Object.defineProperty(e, r, {\n enumerable: !0,\n get () {\n return a[r];\n }\n });\n }), e;\n}\nfunction $3294af0a12e8cafb$var$a(e, a, r, s) {\n Object.defineProperty(e, a, {\n get: r,\n set: s,\n enumerable: !0,\n configurable: !0\n });\n}\nfunction $3294af0a12e8cafb$export$a8ff84c12d48cfa6(e, a = !0) {\n return a ? (0, $d7DIX$path.basename)(e) : (0, $d7DIX$path.basename)(e, (0, $d7DIX$path.extname)(e));\n}\nfunction $3294af0a12e8cafb$export$873fead74fe2f1ff(e) {\n return (0, $d7DIX$path.normalize)(e).replace(RegExp((0, $iNGpn.default)((0, $d7DIX$path.sep)) + \"$\"), \"\");\n}\nfunction $3294af0a12e8cafb$export$2d20c564cade3c93(e, a = \".exe\", r = \"\") {\n return \"win32\" === process.platform ? `${e}${a}` : `${e}${r}`;\n}\nfunction $3294af0a12e8cafb$export$3e333f8cb13439c(e, a) {\n const r = (0, $d7DIX$path.extname)(e), s = `${a}${(0, $d7DIX$path.basename)(e, r)}${r}`;\n return (0, $d7DIX$path.join)((0, $d7DIX$path.dirname)(e), s);\n}\nfunction $3294af0a12e8cafb$export$3b60a3e9bd1aef9d(e, a) {\n const r = (0, $d7DIX$path.extname)(e), s = `${(0, $d7DIX$path.basename)(e, r)}${a}${r}`;\n return (0, $d7DIX$path.join)((0, $d7DIX$path.dirname)(e), s);\n}\nfunction $3294af0a12e8cafb$export$609be29b80b555e1(e, a = \".cmd\", r = \".sh\") {\n return \"win32\" === process.platform ? `${e}${a}` : `${e}${r}`;\n}\nfunction $3294af0a12e8cafb$export$e1f23f8d3e53fe6(e) {\n return \"win32\" === process.platform ? e : \"./\" + e;\n}\nfunction $3294af0a12e8cafb$export$19c5468f88f6e968(e) {\n const a = (0, $d7DIX$path.extname)(e).length;\n return e.slice(0, -a);\n}\nfunction $3294af0a12e8cafb$export$e9c34737ac8e53d2(e, a) {\n return (0, (/*@__PURE__*/$parcel$interopDefault($axeRu)))(e, a);\n}\nfunction $3294af0a12e8cafb$export$7d0573375890d05c(e, a) {\n const r = (0, $d7DIX$path.relative)(a, e);\n return !(!r || \"..\" === r || r.startsWith(\"..\" + (0, $d7DIX$path.sep)) || r === (0, $d7DIX$path.resolve)(e));\n}\nvar $3294af0a12e8cafb$var$O = {}, $3294af0a12e8cafb$var$R = {};\n$3294af0a12e8cafb$var$a($3294af0a12e8cafb$var$R, \"name\", ()=>$3294af0a12e8cafb$export$a8ff84c12d48cfa6);\nvar $3294af0a12e8cafb$var$A = {};\n$3294af0a12e8cafb$var$a($3294af0a12e8cafb$var$A, \"normalizeTrim\", ()=>$3294af0a12e8cafb$export$873fead74fe2f1ff);\nvar $3294af0a12e8cafb$var$I = {};\n$3294af0a12e8cafb$var$a($3294af0a12e8cafb$var$I, \"addExeExt\", ()=>$3294af0a12e8cafb$export$2d20c564cade3c93);\nvar $3294af0a12e8cafb$var$T = {};\n$3294af0a12e8cafb$var$a($3294af0a12e8cafb$var$T, \"addNamePrefix\", ()=>$3294af0a12e8cafb$export$3e333f8cb13439c);\nvar $3294af0a12e8cafb$var$_ = {};\n$3294af0a12e8cafb$var$a($3294af0a12e8cafb$var$_, \"addNameSuffix\", ()=>$3294af0a12e8cafb$export$3b60a3e9bd1aef9d);\nvar $3294af0a12e8cafb$var$k = {};\n$3294af0a12e8cafb$var$a($3294af0a12e8cafb$var$k, \"addShExt\", ()=>$3294af0a12e8cafb$export$609be29b80b555e1);\nvar $3294af0a12e8cafb$var$M = {};\n$3294af0a12e8cafb$var$a($3294af0a12e8cafb$var$M, \"addShRelativePrefix\", ()=>$3294af0a12e8cafb$export$e1f23f8d3e53fe6);\nvar $3294af0a12e8cafb$var$W = {};\n$3294af0a12e8cafb$var$a($3294af0a12e8cafb$var$W, \"removeExt\", ()=>$3294af0a12e8cafb$export$19c5468f88f6e968);\nvar $3294af0a12e8cafb$var$q = {};\n$3294af0a12e8cafb$var$a($3294af0a12e8cafb$var$q, \"replaceExt\", ()=>$3294af0a12e8cafb$export$e9c34737ac8e53d2);\nvar $3294af0a12e8cafb$var$B = {};\n$3294af0a12e8cafb$var$a($3294af0a12e8cafb$var$B, \"isPathInside\", ()=>$3294af0a12e8cafb$export$7d0573375890d05c), $3294af0a12e8cafb$var$e($3294af0a12e8cafb$var$O, $3294af0a12e8cafb$var$R), $3294af0a12e8cafb$var$e($3294af0a12e8cafb$var$O, $3294af0a12e8cafb$var$A), $3294af0a12e8cafb$var$e($3294af0a12e8cafb$var$O, $3294af0a12e8cafb$var$I), $3294af0a12e8cafb$var$e($3294af0a12e8cafb$var$O, $3294af0a12e8cafb$var$T), $3294af0a12e8cafb$var$e($3294af0a12e8cafb$var$O, $3294af0a12e8cafb$var$_), $3294af0a12e8cafb$var$e($3294af0a12e8cafb$var$O, $3294af0a12e8cafb$var$k), $3294af0a12e8cafb$var$e($3294af0a12e8cafb$var$O, $3294af0a12e8cafb$var$M), $3294af0a12e8cafb$var$e($3294af0a12e8cafb$var$O, $3294af0a12e8cafb$var$W), $3294af0a12e8cafb$var$e($3294af0a12e8cafb$var$O, $3294af0a12e8cafb$var$q), $3294af0a12e8cafb$var$e($3294af0a12e8cafb$var$O, $3294af0a12e8cafb$var$B);\n\n});\nparcelRegister(\"iNGpn\", function(module, exports) {\n\n$parcel$export(module.exports, \"default\", () => $dafdb304e43595c1$export$2e2bcd8739ae039);\nfunction $dafdb304e43595c1$export$2e2bcd8739ae039(string) {\n if (typeof string !== \"string\") throw new TypeError(\"Expected a string\");\n // Escape characters with special meaning either inside or outside character sets.\n // Use a simple backslash escape when it’s always valid, and a `\\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.\n return string.replace(/[|\\\\{}()[\\]^$+*?.]/g, \"\\\\$&\").replace(/-/g, \"\\\\x2d\");\n}\n\n});\n\nparcelRegister(\"axeRu\", function(module, exports) {\n\"use strict\";\n\nfunction $7ab883abb47fe1b1$var$replaceExt(npath, ext) {\n if (typeof npath !== \"string\") return npath;\n if (npath.length === 0) return npath;\n var nFileName = $d7DIX$path.basename(npath, $d7DIX$path.extname(npath)) + ext;\n var nFilepath = $d7DIX$path.join($d7DIX$path.dirname(npath), nFileName);\n // Because `path.join` removes the head './' from the given path.\n // This removal can cause a problem when passing the result to `require` or\n // `import`.\n if ($7ab883abb47fe1b1$var$startsWithSingleDot(npath)) return \".\" + $d7DIX$path.sep + nFilepath;\n return nFilepath;\n}\nfunction $7ab883abb47fe1b1$var$startsWithSingleDot(fpath) {\n var first2chars = fpath.slice(0, 2);\n return first2chars === \".\" + $d7DIX$path.sep || first2chars === \"./\";\n}\nmodule.exports = $7ab883abb47fe1b1$var$replaceExt;\n\n});\n\n\nparcelRegister(\"hZdK0\", function(module, exports) {\n\"use strict\";\nvar $d182cae0c6b8c393$var$__createBinding = module.exports && module.exports.__createBinding || (Object.create ? function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n Object.defineProperty(o, k2, {\n enumerable: true,\n get: function() {\n return m[k];\n }\n });\n} : function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n o[k2] = m[k];\n});\nvar $d182cae0c6b8c393$var$__setModuleDefault = module.exports && module.exports.__setModuleDefault || (Object.create ? function(o, v) {\n Object.defineProperty(o, \"default\", {\n enumerable: true,\n value: v\n });\n} : function(o, v) {\n o[\"default\"] = v;\n});\nvar $d182cae0c6b8c393$var$__importStar = module.exports && module.exports.__importStar || function(mod) {\n if (mod && mod.__esModule) return mod;\n var result = {};\n if (mod != null) {\n for(var k in mod)if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) $d182cae0c6b8c393$var$__createBinding(result, mod, k);\n }\n $d182cae0c6b8c393$var$__setModuleDefault(result, mod);\n return result;\n};\nvar $d182cae0c6b8c393$var$__awaiter = module.exports && module.exports.__awaiter || function(thisArg, _arguments, P, generator) {\n function adopt(value) {\n return value instanceof P ? value : new P(function(resolve) {\n resolve(value);\n });\n }\n return new (P || (P = Promise))(function(resolve, reject) {\n function fulfilled(value) {\n try {\n step(generator.next(value));\n } catch (e) {\n reject(e);\n }\n }\n function rejected(value) {\n try {\n step(generator[\"throw\"](value));\n } catch (e) {\n reject(e);\n }\n }\n function step(result) {\n result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);\n }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nObject.defineProperty(module.exports, \"__esModule\", {\n value: true\n});\nmodule.exports.findInPath = module.exports.which = module.exports.mkdirP = module.exports.rmRF = module.exports.mv = module.exports.cp = void 0;\n\n\nconst $d182cae0c6b8c393$var$path = $d182cae0c6b8c393$var$__importStar($d7DIX$path);\n\nconst $d182cae0c6b8c393$var$ioUtil = $d182cae0c6b8c393$var$__importStar((parcelRequire(\"ipB3d\")));\n/**\n * Copies a file or folder.\n * Based off of shelljs - https://github.com/shelljs/shelljs/blob/9237f66c52e5daa40458f94f9565e18e8132f5a6/src/cp.js\n *\n * @param source source path\n * @param dest destination path\n * @param options optional. See CopyOptions.\n */ function $d182cae0c6b8c393$var$cp(source, dest, options = {}) {\n return $d182cae0c6b8c393$var$__awaiter(this, void 0, void 0, function*() {\n const { force: force, recursive: recursive, copySourceDirectory: copySourceDirectory } = $d182cae0c6b8c393$var$readCopyOptions(options);\n const destStat = (yield $d182cae0c6b8c393$var$ioUtil.exists(dest)) ? yield $d182cae0c6b8c393$var$ioUtil.stat(dest) : null;\n // Dest is an existing file, but not forcing\n if (destStat && destStat.isFile() && !force) return;\n // If dest is an existing directory, should copy inside.\n const newDest = destStat && destStat.isDirectory() && copySourceDirectory ? $d182cae0c6b8c393$var$path.join(dest, $d182cae0c6b8c393$var$path.basename(source)) : dest;\n if (!(yield $d182cae0c6b8c393$var$ioUtil.exists(source))) throw new Error(`no such file or directory: ${source}`);\n const sourceStat = yield $d182cae0c6b8c393$var$ioUtil.stat(source);\n if (sourceStat.isDirectory()) {\n if (!recursive) throw new Error(`Failed to copy. ${source} is a directory, but tried to copy without recursive flag.`);\n else yield $d182cae0c6b8c393$var$cpDirRecursive(source, newDest, 0, force);\n } else {\n if ($d182cae0c6b8c393$var$path.relative(source, newDest) === \"\") // a file cannot be copied to itself\n throw new Error(`'${newDest}' and '${source}' are the same file`);\n yield $d182cae0c6b8c393$var$copyFile(source, newDest, force);\n }\n });\n}\nmodule.exports.cp = $d182cae0c6b8c393$var$cp;\n/**\n * Moves a path.\n *\n * @param source source path\n * @param dest destination path\n * @param options optional. See MoveOptions.\n */ function $d182cae0c6b8c393$var$mv(source, dest, options = {}) {\n return $d182cae0c6b8c393$var$__awaiter(this, void 0, void 0, function*() {\n if (yield $d182cae0c6b8c393$var$ioUtil.exists(dest)) {\n let destExists = true;\n if (yield $d182cae0c6b8c393$var$ioUtil.isDirectory(dest)) {\n // If dest is directory copy src into dest\n dest = $d182cae0c6b8c393$var$path.join(dest, $d182cae0c6b8c393$var$path.basename(source));\n destExists = yield $d182cae0c6b8c393$var$ioUtil.exists(dest);\n }\n if (destExists) {\n if (options.force == null || options.force) yield $d182cae0c6b8c393$var$rmRF(dest);\n else throw new Error(\"Destination already exists\");\n }\n }\n yield $d182cae0c6b8c393$var$mkdirP($d182cae0c6b8c393$var$path.dirname(dest));\n yield $d182cae0c6b8c393$var$ioUtil.rename(source, dest);\n });\n}\nmodule.exports.mv = $d182cae0c6b8c393$var$mv;\n/**\n * Remove a path recursively with force\n *\n * @param inputPath path to remove\n */ function $d182cae0c6b8c393$var$rmRF(inputPath) {\n return $d182cae0c6b8c393$var$__awaiter(this, void 0, void 0, function*() {\n if ($d182cae0c6b8c393$var$ioUtil.IS_WINDOWS) {\n // Check for invalid characters\n // https://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file\n if (/[*\"<>|]/.test(inputPath)) throw new Error('File path must not contain `*`, `\"`, `<`, `>` or `|` on Windows');\n }\n try {\n // note if path does not exist, error is silent\n yield $d182cae0c6b8c393$var$ioUtil.rm(inputPath, {\n force: true,\n maxRetries: 3,\n recursive: true,\n retryDelay: 300\n });\n } catch (err) {\n throw new Error(`File was unable to be removed ${err}`);\n }\n });\n}\nmodule.exports.rmRF = $d182cae0c6b8c393$var$rmRF;\n/**\n * Make a directory. Creates the full path with folders in between\n * Will throw if it fails\n *\n * @param fsPath path to create\n * @returns Promise\n */ function $d182cae0c6b8c393$var$mkdirP(fsPath) {\n return $d182cae0c6b8c393$var$__awaiter(this, void 0, void 0, function*() {\n $d7DIX$assert.ok(fsPath, \"a path argument must be provided\");\n yield $d182cae0c6b8c393$var$ioUtil.mkdir(fsPath, {\n recursive: true\n });\n });\n}\nmodule.exports.mkdirP = $d182cae0c6b8c393$var$mkdirP;\n/**\n * Returns path of a tool had the tool actually been invoked. Resolves via paths.\n * If you check and the tool does not exist, it will throw.\n *\n * @param tool name of the tool\n * @param check whether to check if tool exists\n * @returns Promise path to tool\n */ function $d182cae0c6b8c393$var$which(tool, check) {\n return $d182cae0c6b8c393$var$__awaiter(this, void 0, void 0, function*() {\n if (!tool) throw new Error(\"parameter 'tool' is required\");\n // recursive when check=true\n if (check) {\n const result = yield $d182cae0c6b8c393$var$which(tool, false);\n if (!result) {\n if ($d182cae0c6b8c393$var$ioUtil.IS_WINDOWS) throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`);\n else throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`);\n }\n return result;\n }\n const matches = yield $d182cae0c6b8c393$var$findInPath(tool);\n if (matches && matches.length > 0) return matches[0];\n return \"\";\n });\n}\nmodule.exports.which = $d182cae0c6b8c393$var$which;\n/**\n * Returns a list of all occurrences of the given tool on the system path.\n *\n * @returns Promise the paths of the tool\n */ function $d182cae0c6b8c393$var$findInPath(tool) {\n return $d182cae0c6b8c393$var$__awaiter(this, void 0, void 0, function*() {\n if (!tool) throw new Error(\"parameter 'tool' is required\");\n // build the list of extensions to try\n const extensions = [];\n if ($d182cae0c6b8c393$var$ioUtil.IS_WINDOWS && process.env[\"PATHEXT\"]) {\n for (const extension of process.env[\"PATHEXT\"].split($d182cae0c6b8c393$var$path.delimiter))if (extension) extensions.push(extension);\n }\n // if it's rooted, return it if exists. otherwise return empty.\n if ($d182cae0c6b8c393$var$ioUtil.isRooted(tool)) {\n const filePath = yield $d182cae0c6b8c393$var$ioUtil.tryGetExecutablePath(tool, extensions);\n if (filePath) return [\n filePath\n ];\n return [];\n }\n // if any path separators, return empty\n if (tool.includes($d182cae0c6b8c393$var$path.sep)) return [];\n // build the list of directories\n //\n // Note, technically \"where\" checks the current directory on Windows. From a toolkit perspective,\n // it feels like we should not do this. Checking the current directory seems like more of a use\n // case of a shell, and the which() function exposed by the toolkit should strive for consistency\n // across platforms.\n const directories = [];\n if (process.env.PATH) {\n for (const p of process.env.PATH.split($d182cae0c6b8c393$var$path.delimiter))if (p) directories.push(p);\n }\n // find all matches\n const matches = [];\n for (const directory of directories){\n const filePath = yield $d182cae0c6b8c393$var$ioUtil.tryGetExecutablePath($d182cae0c6b8c393$var$path.join(directory, tool), extensions);\n if (filePath) matches.push(filePath);\n }\n return matches;\n });\n}\nmodule.exports.findInPath = $d182cae0c6b8c393$var$findInPath;\nfunction $d182cae0c6b8c393$var$readCopyOptions(options) {\n const force = options.force == null ? true : options.force;\n const recursive = Boolean(options.recursive);\n const copySourceDirectory = options.copySourceDirectory == null ? true : Boolean(options.copySourceDirectory);\n return {\n force: force,\n recursive: recursive,\n copySourceDirectory: copySourceDirectory\n };\n}\nfunction $d182cae0c6b8c393$var$cpDirRecursive(sourceDir, destDir, currentDepth, force) {\n return $d182cae0c6b8c393$var$__awaiter(this, void 0, void 0, function*() {\n // Ensure there is not a run away recursive copy\n if (currentDepth >= 255) return;\n currentDepth++;\n yield $d182cae0c6b8c393$var$mkdirP(destDir);\n const files = yield $d182cae0c6b8c393$var$ioUtil.readdir(sourceDir);\n for (const fileName of files){\n const srcFile = `${sourceDir}/${fileName}`;\n const destFile = `${destDir}/${fileName}`;\n const srcFileStat = yield $d182cae0c6b8c393$var$ioUtil.lstat(srcFile);\n if (srcFileStat.isDirectory()) // Recurse\n yield $d182cae0c6b8c393$var$cpDirRecursive(srcFile, destFile, currentDepth, force);\n else yield $d182cae0c6b8c393$var$copyFile(srcFile, destFile, force);\n }\n // Change the mode for the newly created directory\n yield $d182cae0c6b8c393$var$ioUtil.chmod(destDir, (yield $d182cae0c6b8c393$var$ioUtil.stat(sourceDir)).mode);\n });\n}\n// Buffered file copy\nfunction $d182cae0c6b8c393$var$copyFile(srcFile, destFile, force) {\n return $d182cae0c6b8c393$var$__awaiter(this, void 0, void 0, function*() {\n if ((yield $d182cae0c6b8c393$var$ioUtil.lstat(srcFile)).isSymbolicLink()) {\n // unlink/re-link it\n try {\n yield $d182cae0c6b8c393$var$ioUtil.lstat(destFile);\n yield $d182cae0c6b8c393$var$ioUtil.unlink(destFile);\n } catch (e) {\n // Try to override file permission\n if (e.code === \"EPERM\") {\n yield $d182cae0c6b8c393$var$ioUtil.chmod(destFile, \"0666\");\n yield $d182cae0c6b8c393$var$ioUtil.unlink(destFile);\n }\n // other errors = it doesn't exist, no work to do\n }\n // Copy over symlink\n const symlinkFull = yield $d182cae0c6b8c393$var$ioUtil.readlink(srcFile);\n yield $d182cae0c6b8c393$var$ioUtil.symlink(symlinkFull, destFile, $d182cae0c6b8c393$var$ioUtil.IS_WINDOWS ? \"junction\" : null);\n } else if (!(yield $d182cae0c6b8c393$var$ioUtil.exists(destFile)) || force) yield $d182cae0c6b8c393$var$ioUtil.copyFile(srcFile, destFile);\n });\n}\n\n});\nparcelRegister(\"ipB3d\", function(module, exports) {\n\"use strict\";\nvar $d6774d525a29799d$var$__createBinding = module.exports && module.exports.__createBinding || (Object.create ? function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n Object.defineProperty(o, k2, {\n enumerable: true,\n get: function() {\n return m[k];\n }\n });\n} : function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n o[k2] = m[k];\n});\nvar $d6774d525a29799d$var$__setModuleDefault = module.exports && module.exports.__setModuleDefault || (Object.create ? function(o, v) {\n Object.defineProperty(o, \"default\", {\n enumerable: true,\n value: v\n });\n} : function(o, v) {\n o[\"default\"] = v;\n});\nvar $d6774d525a29799d$var$__importStar = module.exports && module.exports.__importStar || function(mod) {\n if (mod && mod.__esModule) return mod;\n var result = {};\n if (mod != null) {\n for(var k in mod)if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) $d6774d525a29799d$var$__createBinding(result, mod, k);\n }\n $d6774d525a29799d$var$__setModuleDefault(result, mod);\n return result;\n};\nvar $d6774d525a29799d$var$__awaiter = module.exports && module.exports.__awaiter || function(thisArg, _arguments, P, generator) {\n function adopt(value) {\n return value instanceof P ? value : new P(function(resolve) {\n resolve(value);\n });\n }\n return new (P || (P = Promise))(function(resolve, reject) {\n function fulfilled(value) {\n try {\n step(generator.next(value));\n } catch (e) {\n reject(e);\n }\n }\n function rejected(value) {\n try {\n step(generator[\"throw\"](value));\n } catch (e) {\n reject(e);\n }\n }\n function step(result) {\n result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);\n }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nvar $d6774d525a29799d$var$_a;\nObject.defineProperty(module.exports, \"__esModule\", {\n value: true\n});\nmodule.exports.getCmdPath = module.exports.tryGetExecutablePath = module.exports.isRooted = module.exports.isDirectory = module.exports.exists = module.exports.READONLY = module.exports.UV_FS_O_EXLOCK = module.exports.IS_WINDOWS = module.exports.unlink = module.exports.symlink = module.exports.stat = module.exports.rmdir = module.exports.rm = module.exports.rename = module.exports.readlink = module.exports.readdir = module.exports.open = module.exports.mkdir = module.exports.lstat = module.exports.copyFile = module.exports.chmod = void 0;\n\nconst $d6774d525a29799d$var$fs = $d6774d525a29799d$var$__importStar($d7DIX$fs);\n\nconst $d6774d525a29799d$var$path = $d6774d525a29799d$var$__importStar($d7DIX$path);\n$d6774d525a29799d$var$_a = $d6774d525a29799d$var$fs.promises, module.exports.chmod = $d6774d525a29799d$var$_a.chmod, module.exports.copyFile = $d6774d525a29799d$var$_a.copyFile, module.exports.lstat = $d6774d525a29799d$var$_a.lstat, module.exports.mkdir = $d6774d525a29799d$var$_a.mkdir, module.exports.open = $d6774d525a29799d$var$_a.open, module.exports.readdir = $d6774d525a29799d$var$_a.readdir, module.exports.readlink = $d6774d525a29799d$var$_a.readlink, module.exports.rename = $d6774d525a29799d$var$_a.rename, module.exports.rm = $d6774d525a29799d$var$_a.rm, module.exports.rmdir = $d6774d525a29799d$var$_a.rmdir, module.exports.stat = $d6774d525a29799d$var$_a.stat, module.exports.symlink = $d6774d525a29799d$var$_a.symlink, module.exports.unlink = $d6774d525a29799d$var$_a.unlink;\n// export const {open} = 'fs'\nmodule.exports.IS_WINDOWS = process.platform === \"win32\";\n// See https://github.com/nodejs/node/blob/d0153aee367422d0858105abec186da4dff0a0c5/deps/uv/include/uv/win.h#L691\nmodule.exports.UV_FS_O_EXLOCK = 0x10000000;\nmodule.exports.READONLY = $d6774d525a29799d$var$fs.constants.O_RDONLY;\nfunction $d6774d525a29799d$var$exists(fsPath) {\n return $d6774d525a29799d$var$__awaiter(this, void 0, void 0, function*() {\n try {\n yield module.exports.stat(fsPath);\n } catch (err) {\n if (err.code === \"ENOENT\") return false;\n throw err;\n }\n return true;\n });\n}\nmodule.exports.exists = $d6774d525a29799d$var$exists;\nfunction $d6774d525a29799d$var$isDirectory(fsPath, useStat = false) {\n return $d6774d525a29799d$var$__awaiter(this, void 0, void 0, function*() {\n const stats = useStat ? yield module.exports.stat(fsPath) : yield module.exports.lstat(fsPath);\n return stats.isDirectory();\n });\n}\nmodule.exports.isDirectory = $d6774d525a29799d$var$isDirectory;\n/**\n * On OSX/Linux, true if path starts with '/'. On Windows, true for paths like:\n * \\, \\hello, \\\\hello\\share, C:, and C:\\hello (and corresponding alternate separator cases).\n */ function $d6774d525a29799d$var$isRooted(p) {\n p = $d6774d525a29799d$var$normalizeSeparators(p);\n if (!p) throw new Error('isRooted() parameter \"p\" cannot be empty');\n if (module.exports.IS_WINDOWS) return p.startsWith(\"\\\\\") || /^[A-Z]:/i.test(p) // e.g. \\ or \\hello or \\\\hello\n ; // e.g. C: or C:\\hello\n return p.startsWith(\"/\");\n}\nmodule.exports.isRooted = $d6774d525a29799d$var$isRooted;\n/**\n * Best effort attempt to determine whether a file exists and is executable.\n * @param filePath file path to check\n * @param extensions additional file extensions to try\n * @return if file exists and is executable, returns the file path. otherwise empty string.\n */ function $d6774d525a29799d$var$tryGetExecutablePath(filePath, extensions) {\n return $d6774d525a29799d$var$__awaiter(this, void 0, void 0, function*() {\n let stats = undefined;\n try {\n // test file exists\n stats = yield module.exports.stat(filePath);\n } catch (err) {\n if (err.code !== \"ENOENT\") // eslint-disable-next-line no-console\n console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`);\n }\n if (stats && stats.isFile()) {\n if (module.exports.IS_WINDOWS) {\n // on Windows, test for valid extension\n const upperExt = $d6774d525a29799d$var$path.extname(filePath).toUpperCase();\n if (extensions.some((validExt)=>validExt.toUpperCase() === upperExt)) return filePath;\n } else {\n if ($d6774d525a29799d$var$isUnixExecutable(stats)) return filePath;\n }\n }\n // try each extension\n const originalFilePath = filePath;\n for (const extension of extensions){\n filePath = originalFilePath + extension;\n stats = undefined;\n try {\n stats = yield module.exports.stat(filePath);\n } catch (err) {\n if (err.code !== \"ENOENT\") // eslint-disable-next-line no-console\n console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`);\n }\n if (stats && stats.isFile()) {\n if (module.exports.IS_WINDOWS) {\n // preserve the case of the actual file (since an extension was appended)\n try {\n const directory = $d6774d525a29799d$var$path.dirname(filePath);\n const upperName = $d6774d525a29799d$var$path.basename(filePath).toUpperCase();\n for (const actualName of yield module.exports.readdir(directory))if (upperName === actualName.toUpperCase()) {\n filePath = $d6774d525a29799d$var$path.join(directory, actualName);\n break;\n }\n } catch (err) {\n // eslint-disable-next-line no-console\n console.log(`Unexpected error attempting to determine the actual case of the file '${filePath}': ${err}`);\n }\n return filePath;\n } else {\n if ($d6774d525a29799d$var$isUnixExecutable(stats)) return filePath;\n }\n }\n }\n return \"\";\n });\n}\nmodule.exports.tryGetExecutablePath = $d6774d525a29799d$var$tryGetExecutablePath;\nfunction $d6774d525a29799d$var$normalizeSeparators(p) {\n p = p || \"\";\n if (module.exports.IS_WINDOWS) {\n // convert slashes on Windows\n p = p.replace(/\\//g, \"\\\\\");\n // remove redundant slashes\n return p.replace(/\\\\\\\\+/g, \"\\\\\");\n }\n // remove redundant slashes\n return p.replace(/\\/\\/+/g, \"/\");\n}\n// on Mac/Linux, test the execute bit\n// R W X R W X R W X\n// 256 128 64 32 16 8 4 2 1\nfunction $d6774d525a29799d$var$isUnixExecutable(stats) {\n return (stats.mode & 1) > 0 || (stats.mode & 8) > 0 && stats.gid === process.getgid() || (stats.mode & 64) > 0 && stats.uid === process.getuid();\n}\n// Get the path of cmd.exe in windows\nfunction $d6774d525a29799d$var$getCmdPath() {\n var _a;\n return (_a = process.env[\"COMSPEC\"]) !== null && _a !== void 0 ? _a : `cmd.exe`;\n}\nmodule.exports.getCmdPath = $d6774d525a29799d$var$getCmdPath;\n\n});\n\n\nparcelRegister(\"42L4Y\", function(module, exports) {\n\"use strict\";\nvar $2f1bde43f3e1d36b$var$__createBinding = module.exports && module.exports.__createBinding || (Object.create ? function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n Object.defineProperty(o, k2, {\n enumerable: true,\n get: function() {\n return m[k];\n }\n });\n} : function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n o[k2] = m[k];\n});\nvar $2f1bde43f3e1d36b$var$__setModuleDefault = module.exports && module.exports.__setModuleDefault || (Object.create ? function(o, v) {\n Object.defineProperty(o, \"default\", {\n enumerable: true,\n value: v\n });\n} : function(o, v) {\n o[\"default\"] = v;\n});\nvar $2f1bde43f3e1d36b$var$__importStar = module.exports && module.exports.__importStar || function(mod) {\n if (mod && mod.__esModule) return mod;\n var result = {};\n if (mod != null) {\n for(var k in mod)if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) $2f1bde43f3e1d36b$var$__createBinding(result, mod, k);\n }\n $2f1bde43f3e1d36b$var$__setModuleDefault(result, mod);\n return result;\n};\nvar $2f1bde43f3e1d36b$var$__awaiter = module.exports && module.exports.__awaiter || function(thisArg, _arguments, P, generator) {\n function adopt(value) {\n return value instanceof P ? value : new P(function(resolve) {\n resolve(value);\n });\n }\n return new (P || (P = Promise))(function(resolve, reject) {\n function fulfilled(value) {\n try {\n step(generator.next(value));\n } catch (e) {\n reject(e);\n }\n }\n function rejected(value) {\n try {\n step(generator[\"throw\"](value));\n } catch (e) {\n reject(e);\n }\n }\n function step(result) {\n result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);\n }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nObject.defineProperty(module.exports, \"__esModule\", {\n value: true\n});\nmodule.exports._readLinuxVersionFile = module.exports._getOsVersion = module.exports._findMatch = void 0;\n\nconst $2f1bde43f3e1d36b$var$semver = $2f1bde43f3e1d36b$var$__importStar((parcelRequire(\"lroIv\")));\n\nvar $4t50X = parcelRequire(\"4t50X\");\n\n\n\nfunction $2f1bde43f3e1d36b$var$_findMatch(versionSpec, stable, candidates, archFilter) {\n return $2f1bde43f3e1d36b$var$__awaiter(this, void 0, void 0, function*() {\n const platFilter = $d7DIX$os.platform();\n let result;\n let match;\n let file;\n for (const candidate of candidates){\n const version = candidate.version;\n $4t50X.debug(`check ${version} satisfies ${versionSpec}`);\n if ($2f1bde43f3e1d36b$var$semver.satisfies(version, versionSpec) && (!stable || candidate.stable === stable)) {\n file = candidate.files.find((item)=>{\n $4t50X.debug(`${item.arch}===${archFilter} && ${item.platform}===${platFilter}`);\n let chk = item.arch === archFilter && item.platform === platFilter;\n if (chk && item.platform_version) {\n const osVersion = module.exports._getOsVersion();\n if (osVersion === item.platform_version) chk = true;\n else chk = $2f1bde43f3e1d36b$var$semver.satisfies(osVersion, item.platform_version);\n }\n return chk;\n });\n if (file) {\n $4t50X.debug(`matched ${candidate.version}`);\n match = candidate;\n break;\n }\n }\n }\n if (match && file) {\n // clone since we're mutating the file list to be only the file that matches\n result = Object.assign({}, match);\n result.files = [\n file\n ];\n }\n return result;\n });\n}\nmodule.exports._findMatch = $2f1bde43f3e1d36b$var$_findMatch;\nfunction $2f1bde43f3e1d36b$var$_getOsVersion() {\n // TODO: add windows and other linux, arm variants\n // right now filtering on version is only an ubuntu and macos scenario for tools we build for hosted (python)\n const plat = $d7DIX$os.platform();\n let version = \"\";\n if (plat === \"darwin\") version = $d7DIX$child_process.execSync(\"sw_vers -productVersion\").toString();\n else if (plat === \"linux\") {\n // lsb_release process not in some containers, readfile\n // Run cat /etc/lsb-release\n // DISTRIB_ID=Ubuntu\n // DISTRIB_RELEASE=18.04\n // DISTRIB_CODENAME=bionic\n // DISTRIB_DESCRIPTION=\"Ubuntu 18.04.4 LTS\"\n const lsbContents = module.exports._readLinuxVersionFile();\n if (lsbContents) {\n const lines = lsbContents.split(\"\\n\");\n for (const line of lines){\n const parts = line.split(\"=\");\n if (parts.length === 2 && (parts[0].trim() === \"VERSION_ID\" || parts[0].trim() === \"DISTRIB_RELEASE\")) {\n version = parts[1].trim().replace(/^\"/, \"\").replace(/\"$/, \"\");\n break;\n }\n }\n }\n }\n return version;\n}\nmodule.exports._getOsVersion = $2f1bde43f3e1d36b$var$_getOsVersion;\nfunction $2f1bde43f3e1d36b$var$_readLinuxVersionFile() {\n const lsbReleaseFile = \"/etc/lsb-release\";\n const osReleaseFile = \"/etc/os-release\";\n let contents = \"\";\n if ($d7DIX$fs.existsSync(lsbReleaseFile)) contents = $d7DIX$fs.readFileSync(lsbReleaseFile).toString();\n else if ($d7DIX$fs.existsSync(osReleaseFile)) contents = $d7DIX$fs.readFileSync(osReleaseFile).toString();\n return contents;\n}\nmodule.exports._readLinuxVersionFile = $2f1bde43f3e1d36b$var$_readLinuxVersionFile;\n\n});\nparcelRegister(\"lroIv\", function(module, exports) {\nexports = module.exports = SemVer;\nvar debug;\n/* istanbul ignore next */ if (typeof process === \"object\" && process.env && process.env.NODE_DEBUG && /\\bsemver\\b/i.test(process.env.NODE_DEBUG)) debug = function() {\n var args = Array.prototype.slice.call(arguments, 0);\n args.unshift(\"SEMVER\");\n console.log.apply(console, args);\n};\nelse debug = function() {};\n// Note: this is the semver.org version of the spec that it implements\n// Not necessarily the package version of this code.\nexports.SEMVER_SPEC_VERSION = \"2.0.0\";\nvar MAX_LENGTH = 256;\nvar MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */ 9007199254740991;\n// Max safe segment length for coercion.\nvar MAX_SAFE_COMPONENT_LENGTH = 16;\nvar MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;\n// The actual regexps go on exports.re\nvar re = exports.re = [];\nvar safeRe = exports.safeRe = [];\nvar src = exports.src = [];\nvar t = exports.tokens = {};\nvar R = 0;\nfunction tok(n) {\n t[n] = R++;\n}\nvar LETTERDASHNUMBER = \"[a-zA-Z0-9-]\";\n// Replace some greedy regex tokens to prevent regex dos issues. These regex are\n// used internally via the safeRe object since all inputs in this library get\n// normalized first to trim and collapse all extra whitespace. The original\n// regexes are exported for userland consumption and lower level usage. A\n// future breaking change could export the safer regex only with a note that\n// all input should have extra whitespace removed.\nvar safeRegexReplacements = [\n [\n \"\\\\s\",\n 1\n ],\n [\n \"\\\\d\",\n MAX_LENGTH\n ],\n [\n LETTERDASHNUMBER,\n MAX_SAFE_BUILD_LENGTH\n ]\n];\nfunction makeSafeRe(value) {\n for(var i = 0; i < safeRegexReplacements.length; i++){\n var token = safeRegexReplacements[i][0];\n var max = safeRegexReplacements[i][1];\n value = value.split(token + \"*\").join(token + \"{0,\" + max + \"}\").split(token + \"+\").join(token + \"{1,\" + max + \"}\");\n }\n return value;\n}\n// The following Regular Expressions can be used for tokenizing,\n// validating, and parsing SemVer version strings.\n// ## Numeric Identifier\n// A single `0`, or a non-zero digit followed by zero or more digits.\ntok(\"NUMERICIDENTIFIER\");\nsrc[t.NUMERICIDENTIFIER] = \"0|[1-9]\\\\d*\";\ntok(\"NUMERICIDENTIFIERLOOSE\");\nsrc[t.NUMERICIDENTIFIERLOOSE] = \"\\\\d+\";\n// ## Non-numeric Identifier\n// Zero or more digits, followed by a letter or hyphen, and then zero or\n// more letters, digits, or hyphens.\ntok(\"NONNUMERICIDENTIFIER\");\nsrc[t.NONNUMERICIDENTIFIER] = \"\\\\d*[a-zA-Z-]\" + LETTERDASHNUMBER + \"*\";\n// ## Main Version\n// Three dot-separated numeric identifiers.\ntok(\"MAINVERSION\");\nsrc[t.MAINVERSION] = \"(\" + src[t.NUMERICIDENTIFIER] + \")\\\\.\" + \"(\" + src[t.NUMERICIDENTIFIER] + \")\\\\.\" + \"(\" + src[t.NUMERICIDENTIFIER] + \")\";\ntok(\"MAINVERSIONLOOSE\");\nsrc[t.MAINVERSIONLOOSE] = \"(\" + src[t.NUMERICIDENTIFIERLOOSE] + \")\\\\.\" + \"(\" + src[t.NUMERICIDENTIFIERLOOSE] + \")\\\\.\" + \"(\" + src[t.NUMERICIDENTIFIERLOOSE] + \")\";\n// ## Pre-release Version Identifier\n// A numeric identifier, or a non-numeric identifier.\ntok(\"PRERELEASEIDENTIFIER\");\nsrc[t.PRERELEASEIDENTIFIER] = \"(?:\" + src[t.NUMERICIDENTIFIER] + \"|\" + src[t.NONNUMERICIDENTIFIER] + \")\";\ntok(\"PRERELEASEIDENTIFIERLOOSE\");\nsrc[t.PRERELEASEIDENTIFIERLOOSE] = \"(?:\" + src[t.NUMERICIDENTIFIERLOOSE] + \"|\" + src[t.NONNUMERICIDENTIFIER] + \")\";\n// ## Pre-release Version\n// Hyphen, followed by one or more dot-separated pre-release version\n// identifiers.\ntok(\"PRERELEASE\");\nsrc[t.PRERELEASE] = \"(?:-(\" + src[t.PRERELEASEIDENTIFIER] + \"(?:\\\\.\" + src[t.PRERELEASEIDENTIFIER] + \")*))\";\ntok(\"PRERELEASELOOSE\");\nsrc[t.PRERELEASELOOSE] = \"(?:-?(\" + src[t.PRERELEASEIDENTIFIERLOOSE] + \"(?:\\\\.\" + src[t.PRERELEASEIDENTIFIERLOOSE] + \")*))\";\n// ## Build Metadata Identifier\n// Any combination of digits, letters, or hyphens.\ntok(\"BUILDIDENTIFIER\");\nsrc[t.BUILDIDENTIFIER] = LETTERDASHNUMBER + \"+\";\n// ## Build Metadata\n// Plus sign, followed by one or more period-separated build metadata\n// identifiers.\ntok(\"BUILD\");\nsrc[t.BUILD] = \"(?:\\\\+(\" + src[t.BUILDIDENTIFIER] + \"(?:\\\\.\" + src[t.BUILDIDENTIFIER] + \")*))\";\n// ## Full Version String\n// A main version, followed optionally by a pre-release version and\n// build metadata.\n// Note that the only major, minor, patch, and pre-release sections of\n// the version string are capturing groups. The build metadata is not a\n// capturing group, because it should not ever be used in version\n// comparison.\ntok(\"FULL\");\ntok(\"FULLPLAIN\");\nsrc[t.FULLPLAIN] = \"v?\" + src[t.MAINVERSION] + src[t.PRERELEASE] + \"?\" + src[t.BUILD] + \"?\";\nsrc[t.FULL] = \"^\" + src[t.FULLPLAIN] + \"$\";\n// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.\n// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty\n// common in the npm registry.\ntok(\"LOOSEPLAIN\");\nsrc[t.LOOSEPLAIN] = \"[v=\\\\s]*\" + src[t.MAINVERSIONLOOSE] + src[t.PRERELEASELOOSE] + \"?\" + src[t.BUILD] + \"?\";\ntok(\"LOOSE\");\nsrc[t.LOOSE] = \"^\" + src[t.LOOSEPLAIN] + \"$\";\ntok(\"GTLT\");\nsrc[t.GTLT] = \"((?:<|>)?=?)\";\n// Something like \"2.*\" or \"1.2.x\".\n// Note that \"x.x\" is a valid xRange identifer, meaning \"any version\"\n// Only the first item is strictly required.\ntok(\"XRANGEIDENTIFIERLOOSE\");\nsrc[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + \"|x|X|\\\\*\";\ntok(\"XRANGEIDENTIFIER\");\nsrc[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + \"|x|X|\\\\*\";\ntok(\"XRANGEPLAIN\");\nsrc[t.XRANGEPLAIN] = \"[v=\\\\s]*(\" + src[t.XRANGEIDENTIFIER] + \")\" + \"(?:\\\\.(\" + src[t.XRANGEIDENTIFIER] + \")\" + \"(?:\\\\.(\" + src[t.XRANGEIDENTIFIER] + \")\" + \"(?:\" + src[t.PRERELEASE] + \")?\" + src[t.BUILD] + \"?\" + \")?)?\";\ntok(\"XRANGEPLAINLOOSE\");\nsrc[t.XRANGEPLAINLOOSE] = \"[v=\\\\s]*(\" + src[t.XRANGEIDENTIFIERLOOSE] + \")\" + \"(?:\\\\.(\" + src[t.XRANGEIDENTIFIERLOOSE] + \")\" + \"(?:\\\\.(\" + src[t.XRANGEIDENTIFIERLOOSE] + \")\" + \"(?:\" + src[t.PRERELEASELOOSE] + \")?\" + src[t.BUILD] + \"?\" + \")?)?\";\ntok(\"XRANGE\");\nsrc[t.XRANGE] = \"^\" + src[t.GTLT] + \"\\\\s*\" + src[t.XRANGEPLAIN] + \"$\";\ntok(\"XRANGELOOSE\");\nsrc[t.XRANGELOOSE] = \"^\" + src[t.GTLT] + \"\\\\s*\" + src[t.XRANGEPLAINLOOSE] + \"$\";\n// Coercion.\n// Extract anything that could conceivably be a part of a valid semver\ntok(\"COERCE\");\nsrc[t.COERCE] = \"(^|[^\\\\d])(\\\\d{1,\" + MAX_SAFE_COMPONENT_LENGTH + \"})\" + \"(?:\\\\.(\\\\d{1,\" + MAX_SAFE_COMPONENT_LENGTH + \"}))?\" + \"(?:\\\\.(\\\\d{1,\" + MAX_SAFE_COMPONENT_LENGTH + \"}))?\" + \"(?:$|[^\\\\d])\";\ntok(\"COERCERTL\");\nre[t.COERCERTL] = new RegExp(src[t.COERCE], \"g\");\nsafeRe[t.COERCERTL] = new RegExp(makeSafeRe(src[t.COERCE]), \"g\");\n// Tilde ranges.\n// Meaning is \"reasonably at or greater than\"\ntok(\"LONETILDE\");\nsrc[t.LONETILDE] = \"(?:~>?)\";\ntok(\"TILDETRIM\");\nsrc[t.TILDETRIM] = \"(\\\\s*)\" + src[t.LONETILDE] + \"\\\\s+\";\nre[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], \"g\");\nsafeRe[t.TILDETRIM] = new RegExp(makeSafeRe(src[t.TILDETRIM]), \"g\");\nvar tildeTrimReplace = \"$1~\";\ntok(\"TILDE\");\nsrc[t.TILDE] = \"^\" + src[t.LONETILDE] + src[t.XRANGEPLAIN] + \"$\";\ntok(\"TILDELOOSE\");\nsrc[t.TILDELOOSE] = \"^\" + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + \"$\";\n// Caret ranges.\n// Meaning is \"at least and backwards compatible with\"\ntok(\"LONECARET\");\nsrc[t.LONECARET] = \"(?:\\\\^)\";\ntok(\"CARETTRIM\");\nsrc[t.CARETTRIM] = \"(\\\\s*)\" + src[t.LONECARET] + \"\\\\s+\";\nre[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], \"g\");\nsafeRe[t.CARETTRIM] = new RegExp(makeSafeRe(src[t.CARETTRIM]), \"g\");\nvar caretTrimReplace = \"$1^\";\ntok(\"CARET\");\nsrc[t.CARET] = \"^\" + src[t.LONECARET] + src[t.XRANGEPLAIN] + \"$\";\ntok(\"CARETLOOSE\");\nsrc[t.CARETLOOSE] = \"^\" + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + \"$\";\n// A simple gt/lt/eq thing, or just \"\" to indicate \"any version\"\ntok(\"COMPARATORLOOSE\");\nsrc[t.COMPARATORLOOSE] = \"^\" + src[t.GTLT] + \"\\\\s*(\" + src[t.LOOSEPLAIN] + \")$|^$\";\ntok(\"COMPARATOR\");\nsrc[t.COMPARATOR] = \"^\" + src[t.GTLT] + \"\\\\s*(\" + src[t.FULLPLAIN] + \")$|^$\";\n// An expression to strip any whitespace between the gtlt and the thing\n// it modifies, so that `> 1.2.3` ==> `>1.2.3`\ntok(\"COMPARATORTRIM\");\nsrc[t.COMPARATORTRIM] = \"(\\\\s*)\" + src[t.GTLT] + \"\\\\s*(\" + src[t.LOOSEPLAIN] + \"|\" + src[t.XRANGEPLAIN] + \")\";\n// this one has to use the /g flag\nre[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], \"g\");\nsafeRe[t.COMPARATORTRIM] = new RegExp(makeSafeRe(src[t.COMPARATORTRIM]), \"g\");\nvar comparatorTrimReplace = \"$1$2$3\";\n// Something like `1.2.3 - 1.2.4`\n// Note that these all use the loose form, because they'll be\n// checked against either the strict or loose comparator form\n// later.\ntok(\"HYPHENRANGE\");\nsrc[t.HYPHENRANGE] = \"^\\\\s*(\" + src[t.XRANGEPLAIN] + \")\" + \"\\\\s+-\\\\s+\" + \"(\" + src[t.XRANGEPLAIN] + \")\" + \"\\\\s*$\";\ntok(\"HYPHENRANGELOOSE\");\nsrc[t.HYPHENRANGELOOSE] = \"^\\\\s*(\" + src[t.XRANGEPLAINLOOSE] + \")\" + \"\\\\s+-\\\\s+\" + \"(\" + src[t.XRANGEPLAINLOOSE] + \")\" + \"\\\\s*$\";\n// Star ranges basically just allow anything at all.\ntok(\"STAR\");\nsrc[t.STAR] = \"(<|>)?=?\\\\s*\\\\*\";\n// Compile to actual regexp objects.\n// All are flag-free, unless they were created above with a flag.\nfor(var i = 0; i < R; i++){\n debug(i, src[i]);\n if (!re[i]) {\n re[i] = new RegExp(src[i]);\n // Replace all greedy whitespace to prevent regex dos issues. These regex are\n // used internally via the safeRe object since all inputs in this library get\n // normalized first to trim and collapse all extra whitespace. The original\n // regexes are exported for userland consumption and lower level usage. A\n // future breaking change could export the safer regex only with a note that\n // all input should have extra whitespace removed.\n safeRe[i] = new RegExp(makeSafeRe(src[i]));\n }\n}\nexports.parse = parse;\nfunction parse(version, options) {\n if (!options || typeof options !== \"object\") options = {\n loose: !!options,\n includePrerelease: false\n };\n if (version instanceof SemVer) return version;\n if (typeof version !== \"string\") return null;\n if (version.length > MAX_LENGTH) return null;\n var r = options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL];\n if (!r.test(version)) return null;\n try {\n return new SemVer(version, options);\n } catch (er) {\n return null;\n }\n}\nexports.valid = valid;\nfunction valid(version, options) {\n var v = parse(version, options);\n return v ? v.version : null;\n}\nexports.clean = clean;\nfunction clean(version, options) {\n var s = parse(version.trim().replace(/^[=v]+/, \"\"), options);\n return s ? s.version : null;\n}\nexports.SemVer = SemVer;\nfunction SemVer(version, options) {\n if (!options || typeof options !== \"object\") options = {\n loose: !!options,\n includePrerelease: false\n };\n if (version instanceof SemVer) {\n if (version.loose === options.loose) return version;\n else version = version.version;\n } else if (typeof version !== \"string\") throw new TypeError(\"Invalid Version: \" + version);\n if (version.length > MAX_LENGTH) throw new TypeError(\"version is longer than \" + MAX_LENGTH + \" characters\");\n if (!(this instanceof SemVer)) return new SemVer(version, options);\n debug(\"SemVer\", version, options);\n this.options = options;\n this.loose = !!options.loose;\n var m = version.trim().match(options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL]);\n if (!m) throw new TypeError(\"Invalid Version: \" + version);\n this.raw = version;\n // these are actually numbers\n this.major = +m[1];\n this.minor = +m[2];\n this.patch = +m[3];\n if (this.major > MAX_SAFE_INTEGER || this.major < 0) throw new TypeError(\"Invalid major version\");\n if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) throw new TypeError(\"Invalid minor version\");\n if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) throw new TypeError(\"Invalid patch version\");\n // numberify any prerelease numeric ids\n if (!m[4]) this.prerelease = [];\n else this.prerelease = m[4].split(\".\").map(function(id) {\n if (/^[0-9]+$/.test(id)) {\n var num = +id;\n if (num >= 0 && num < MAX_SAFE_INTEGER) return num;\n }\n return id;\n });\n this.build = m[5] ? m[5].split(\".\") : [];\n this.format();\n}\nSemVer.prototype.format = function() {\n this.version = this.major + \".\" + this.minor + \".\" + this.patch;\n if (this.prerelease.length) this.version += \"-\" + this.prerelease.join(\".\");\n return this.version;\n};\nSemVer.prototype.toString = function() {\n return this.version;\n};\nSemVer.prototype.compare = function(other) {\n debug(\"SemVer.compare\", this.version, this.options, other);\n if (!(other instanceof SemVer)) other = new SemVer(other, this.options);\n return this.compareMain(other) || this.comparePre(other);\n};\nSemVer.prototype.compareMain = function(other) {\n if (!(other instanceof SemVer)) other = new SemVer(other, this.options);\n return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);\n};\nSemVer.prototype.comparePre = function(other) {\n if (!(other instanceof SemVer)) other = new SemVer(other, this.options);\n // NOT having a prerelease is > having one\n if (this.prerelease.length && !other.prerelease.length) return -1;\n else if (!this.prerelease.length && other.prerelease.length) return 1;\n else if (!this.prerelease.length && !other.prerelease.length) return 0;\n var i = 0;\n do {\n var a = this.prerelease[i];\n var b = other.prerelease[i];\n debug(\"prerelease compare\", i, a, b);\n if (a === undefined && b === undefined) return 0;\n else if (b === undefined) return 1;\n else if (a === undefined) return -1;\n else if (a === b) continue;\n else return compareIdentifiers(a, b);\n }while (++i);\n};\nSemVer.prototype.compareBuild = function(other) {\n if (!(other instanceof SemVer)) other = new SemVer(other, this.options);\n var i = 0;\n do {\n var a = this.build[i];\n var b = other.build[i];\n debug(\"prerelease compare\", i, a, b);\n if (a === undefined && b === undefined) return 0;\n else if (b === undefined) return 1;\n else if (a === undefined) return -1;\n else if (a === b) continue;\n else return compareIdentifiers(a, b);\n }while (++i);\n};\n// preminor will bump the version up to the next minor release, and immediately\n// down to pre-release. premajor and prepatch work the same way.\nSemVer.prototype.inc = function(release, identifier) {\n switch(release){\n case \"premajor\":\n this.prerelease.length = 0;\n this.patch = 0;\n this.minor = 0;\n this.major++;\n this.inc(\"pre\", identifier);\n break;\n case \"preminor\":\n this.prerelease.length = 0;\n this.patch = 0;\n this.minor++;\n this.inc(\"pre\", identifier);\n break;\n case \"prepatch\":\n // If this is already a prerelease, it will bump to the next version\n // drop any prereleases that might already exist, since they are not\n // relevant at this point.\n this.prerelease.length = 0;\n this.inc(\"patch\", identifier);\n this.inc(\"pre\", identifier);\n break;\n // If the input is a non-prerelease version, this acts the same as\n // prepatch.\n case \"prerelease\":\n if (this.prerelease.length === 0) this.inc(\"patch\", identifier);\n this.inc(\"pre\", identifier);\n break;\n case \"major\":\n // If this is a pre-major version, bump up to the same major version.\n // Otherwise increment major.\n // 1.0.0-5 bumps to 1.0.0\n // 1.1.0 bumps to 2.0.0\n if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) this.major++;\n this.minor = 0;\n this.patch = 0;\n this.prerelease = [];\n break;\n case \"minor\":\n // If this is a pre-minor version, bump up to the same minor version.\n // Otherwise increment minor.\n // 1.2.0-5 bumps to 1.2.0\n // 1.2.1 bumps to 1.3.0\n if (this.patch !== 0 || this.prerelease.length === 0) this.minor++;\n this.patch = 0;\n this.prerelease = [];\n break;\n case \"patch\":\n // If this is not a pre-release version, it will increment the patch.\n // If it is a pre-release it will bump up to the same patch version.\n // 1.2.0-5 patches to 1.2.0\n // 1.2.0 patches to 1.2.1\n if (this.prerelease.length === 0) this.patch++;\n this.prerelease = [];\n break;\n // This probably shouldn't be used publicly.\n // 1.0.0 \"pre\" would become 1.0.0-0 which is the wrong direction.\n case \"pre\":\n if (this.prerelease.length === 0) this.prerelease = [\n 0\n ];\n else {\n var i = this.prerelease.length;\n while(--i >= 0)if (typeof this.prerelease[i] === \"number\") {\n this.prerelease[i]++;\n i = -2;\n }\n if (i === -1) // didn't increment anything\n this.prerelease.push(0);\n }\n if (identifier) {\n // 1.2.0-beta.1 bumps to 1.2.0-beta.2,\n // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0\n if (this.prerelease[0] === identifier) {\n if (isNaN(this.prerelease[1])) this.prerelease = [\n identifier,\n 0\n ];\n } else this.prerelease = [\n identifier,\n 0\n ];\n }\n break;\n default:\n throw new Error(\"invalid increment argument: \" + release);\n }\n this.format();\n this.raw = this.version;\n return this;\n};\nexports.inc = inc;\nfunction inc(version, release, loose, identifier) {\n if (typeof loose === \"string\") {\n identifier = loose;\n loose = undefined;\n }\n try {\n return new SemVer(version, loose).inc(release, identifier).version;\n } catch (er) {\n return null;\n }\n}\nexports.diff = diff;\nfunction diff(version1, version2) {\n if (eq(version1, version2)) return null;\n else {\n var v1 = parse(version1);\n var v2 = parse(version2);\n var prefix = \"\";\n if (v1.prerelease.length || v2.prerelease.length) {\n prefix = \"pre\";\n var defaultResult = \"prerelease\";\n }\n for(var key in v1)if (key === \"major\" || key === \"minor\" || key === \"patch\") {\n if (v1[key] !== v2[key]) return prefix + key;\n }\n return defaultResult // may be undefined\n ;\n }\n}\nexports.compareIdentifiers = compareIdentifiers;\nvar numeric = /^[0-9]+$/;\nfunction compareIdentifiers(a, b) {\n var anum = numeric.test(a);\n var bnum = numeric.test(b);\n if (anum && bnum) {\n a = +a;\n b = +b;\n }\n return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;\n}\nexports.rcompareIdentifiers = rcompareIdentifiers;\nfunction rcompareIdentifiers(a, b) {\n return compareIdentifiers(b, a);\n}\nexports.major = major;\nfunction major(a, loose) {\n return new SemVer(a, loose).major;\n}\nexports.minor = minor;\nfunction minor(a, loose) {\n return new SemVer(a, loose).minor;\n}\nexports.patch = patch;\nfunction patch(a, loose) {\n return new SemVer(a, loose).patch;\n}\nexports.compare = compare;\nfunction compare(a, b, loose) {\n return new SemVer(a, loose).compare(new SemVer(b, loose));\n}\nexports.compareLoose = compareLoose;\nfunction compareLoose(a, b) {\n return compare(a, b, true);\n}\nexports.compareBuild = compareBuild;\nfunction compareBuild(a, b, loose) {\n var versionA = new SemVer(a, loose);\n var versionB = new SemVer(b, loose);\n return versionA.compare(versionB) || versionA.compareBuild(versionB);\n}\nexports.rcompare = rcompare;\nfunction rcompare(a, b, loose) {\n return compare(b, a, loose);\n}\nexports.sort = sort;\nfunction sort(list, loose) {\n return list.sort(function(a, b) {\n return exports.compareBuild(a, b, loose);\n });\n}\nexports.rsort = rsort;\nfunction rsort(list, loose) {\n return list.sort(function(a, b) {\n return exports.compareBuild(b, a, loose);\n });\n}\nexports.gt = gt;\nfunction gt(a, b, loose) {\n return compare(a, b, loose) > 0;\n}\nexports.lt = lt;\nfunction lt(a, b, loose) {\n return compare(a, b, loose) < 0;\n}\nexports.eq = eq;\nfunction eq(a, b, loose) {\n return compare(a, b, loose) === 0;\n}\nexports.neq = neq;\nfunction neq(a, b, loose) {\n return compare(a, b, loose) !== 0;\n}\nexports.gte = gte;\nfunction gte(a, b, loose) {\n return compare(a, b, loose) >= 0;\n}\nexports.lte = lte;\nfunction lte(a, b, loose) {\n return compare(a, b, loose) <= 0;\n}\nexports.cmp = cmp;\nfunction cmp(a, op, b, loose) {\n switch(op){\n case \"===\":\n if (typeof a === \"object\") a = a.version;\n if (typeof b === \"object\") b = b.version;\n return a === b;\n case \"!==\":\n if (typeof a === \"object\") a = a.version;\n if (typeof b === \"object\") b = b.version;\n return a !== b;\n case \"\":\n case \"=\":\n case \"==\":\n return eq(a, b, loose);\n case \"!=\":\n return neq(a, b, loose);\n case \">\":\n return gt(a, b, loose);\n case \">=\":\n return gte(a, b, loose);\n case \"<\":\n return lt(a, b, loose);\n case \"<=\":\n return lte(a, b, loose);\n default:\n throw new TypeError(\"Invalid operator: \" + op);\n }\n}\nexports.Comparator = Comparator;\nfunction Comparator(comp, options) {\n if (!options || typeof options !== \"object\") options = {\n loose: !!options,\n includePrerelease: false\n };\n if (comp instanceof Comparator) {\n if (comp.loose === !!options.loose) return comp;\n else comp = comp.value;\n }\n if (!(this instanceof Comparator)) return new Comparator(comp, options);\n comp = comp.trim().split(/\\s+/).join(\" \");\n debug(\"comparator\", comp, options);\n this.options = options;\n this.loose = !!options.loose;\n this.parse(comp);\n if (this.semver === ANY) this.value = \"\";\n else this.value = this.operator + this.semver.version;\n debug(\"comp\", this);\n}\nvar ANY = {};\nComparator.prototype.parse = function(comp) {\n var r = this.options.loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR];\n var m = comp.match(r);\n if (!m) throw new TypeError(\"Invalid comparator: \" + comp);\n this.operator = m[1] !== undefined ? m[1] : \"\";\n if (this.operator === \"=\") this.operator = \"\";\n // if it literally is just '>' or '' then allow anything.\n if (!m[2]) this.semver = ANY;\n else this.semver = new SemVer(m[2], this.options.loose);\n};\nComparator.prototype.toString = function() {\n return this.value;\n};\nComparator.prototype.test = function(version) {\n debug(\"Comparator.test\", version, this.options.loose);\n if (this.semver === ANY || version === ANY) return true;\n if (typeof version === \"string\") try {\n version = new SemVer(version, this.options);\n } catch (er) {\n return false;\n }\n return cmp(version, this.operator, this.semver, this.options);\n};\nComparator.prototype.intersects = function(comp, options) {\n if (!(comp instanceof Comparator)) throw new TypeError(\"a Comparator is required\");\n if (!options || typeof options !== \"object\") options = {\n loose: !!options,\n includePrerelease: false\n };\n var rangeTmp;\n if (this.operator === \"\") {\n if (this.value === \"\") return true;\n rangeTmp = new Range(comp.value, options);\n return satisfies(this.value, rangeTmp, options);\n } else if (comp.operator === \"\") {\n if (comp.value === \"\") return true;\n rangeTmp = new Range(this.value, options);\n return satisfies(comp.semver, rangeTmp, options);\n }\n var sameDirectionIncreasing = (this.operator === \">=\" || this.operator === \">\") && (comp.operator === \">=\" || comp.operator === \">\");\n var sameDirectionDecreasing = (this.operator === \"<=\" || this.operator === \"<\") && (comp.operator === \"<=\" || comp.operator === \"<\");\n var sameSemVer = this.semver.version === comp.semver.version;\n var differentDirectionsInclusive = (this.operator === \">=\" || this.operator === \"<=\") && (comp.operator === \">=\" || comp.operator === \"<=\");\n var oppositeDirectionsLessThan = cmp(this.semver, \"<\", comp.semver, options) && (this.operator === \">=\" || this.operator === \">\") && (comp.operator === \"<=\" || comp.operator === \"<\");\n var oppositeDirectionsGreaterThan = cmp(this.semver, \">\", comp.semver, options) && (this.operator === \"<=\" || this.operator === \"<\") && (comp.operator === \">=\" || comp.operator === \">\");\n return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;\n};\nexports.Range = Range;\nfunction Range(range, options) {\n if (!options || typeof options !== \"object\") options = {\n loose: !!options,\n includePrerelease: false\n };\n if (range instanceof Range) {\n if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) return range;\n else return new Range(range.raw, options);\n }\n if (range instanceof Comparator) return new Range(range.value, options);\n if (!(this instanceof Range)) return new Range(range, options);\n this.options = options;\n this.loose = !!options.loose;\n this.includePrerelease = !!options.includePrerelease;\n // First reduce all whitespace as much as possible so we do not have to rely\n // on potentially slow regexes like \\s*. This is then stored and used for\n // future error messages as well.\n this.raw = range.trim().split(/\\s+/).join(\" \");\n // First, split based on boolean or ||\n this.set = this.raw.split(\"||\").map(function(range) {\n return this.parseRange(range.trim());\n }, this).filter(function(c) {\n // throw out any that are not relevant for whatever reason\n return c.length;\n });\n if (!this.set.length) throw new TypeError(\"Invalid SemVer Range: \" + this.raw);\n this.format();\n}\nRange.prototype.format = function() {\n this.range = this.set.map(function(comps) {\n return comps.join(\" \").trim();\n }).join(\"||\").trim();\n return this.range;\n};\nRange.prototype.toString = function() {\n return this.range;\n};\nRange.prototype.parseRange = function(range) {\n var loose = this.options.loose;\n // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`\n var hr = loose ? safeRe[t.HYPHENRANGELOOSE] : safeRe[t.HYPHENRANGE];\n range = range.replace(hr, hyphenReplace);\n debug(\"hyphen replace\", range);\n // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`\n range = range.replace(safeRe[t.COMPARATORTRIM], comparatorTrimReplace);\n debug(\"comparator trim\", range, safeRe[t.COMPARATORTRIM]);\n // `~ 1.2.3` => `~1.2.3`\n range = range.replace(safeRe[t.TILDETRIM], tildeTrimReplace);\n // `^ 1.2.3` => `^1.2.3`\n range = range.replace(safeRe[t.CARETTRIM], caretTrimReplace);\n // normalize spaces\n range = range.split(/\\s+/).join(\" \");\n // At this point, the range is completely trimmed and\n // ready to be split into comparators.\n var compRe = loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR];\n var set = range.split(\" \").map(function(comp) {\n return parseComparator(comp, this.options);\n }, this).join(\" \").split(/\\s+/);\n if (this.options.loose) // in loose mode, throw out any that are not valid comparators\n set = set.filter(function(comp) {\n return !!comp.match(compRe);\n });\n set = set.map(function(comp) {\n return new Comparator(comp, this.options);\n }, this);\n return set;\n};\nRange.prototype.intersects = function(range, options) {\n if (!(range instanceof Range)) throw new TypeError(\"a Range is required\");\n return this.set.some(function(thisComparators) {\n return isSatisfiable(thisComparators, options) && range.set.some(function(rangeComparators) {\n return isSatisfiable(rangeComparators, options) && thisComparators.every(function(thisComparator) {\n return rangeComparators.every(function(rangeComparator) {\n return thisComparator.intersects(rangeComparator, options);\n });\n });\n });\n });\n};\n// take a set of comparators and determine whether there\n// exists a version which can satisfy it\nfunction isSatisfiable(comparators, options) {\n var result = true;\n var remainingComparators = comparators.slice();\n var testComparator = remainingComparators.pop();\n while(result && remainingComparators.length){\n result = remainingComparators.every(function(otherComparator) {\n return testComparator.intersects(otherComparator, options);\n });\n testComparator = remainingComparators.pop();\n }\n return result;\n}\n// Mostly just for testing and legacy API reasons\nexports.toComparators = toComparators;\nfunction toComparators(range, options) {\n return new Range(range, options).set.map(function(comp) {\n return comp.map(function(c) {\n return c.value;\n }).join(\" \").trim().split(\" \");\n });\n}\n// comprised of xranges, tildes, stars, and gtlt's at this point.\n// already replaced the hyphen ranges\n// turn into a set of JUST comparators.\nfunction parseComparator(comp, options) {\n debug(\"comp\", comp, options);\n comp = replaceCarets(comp, options);\n debug(\"caret\", comp);\n comp = replaceTildes(comp, options);\n debug(\"tildes\", comp);\n comp = replaceXRanges(comp, options);\n debug(\"xrange\", comp);\n comp = replaceStars(comp, options);\n debug(\"stars\", comp);\n return comp;\n}\nfunction isX(id) {\n return !id || id.toLowerCase() === \"x\" || id === \"*\";\n}\n// ~, ~> --> * (any, kinda silly)\n// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0\n// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0\n// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0\n// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0\n// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0\nfunction replaceTildes(comp, options) {\n return comp.trim().split(/\\s+/).map(function(comp) {\n return replaceTilde(comp, options);\n }).join(\" \");\n}\nfunction replaceTilde(comp, options) {\n var r = options.loose ? safeRe[t.TILDELOOSE] : safeRe[t.TILDE];\n return comp.replace(r, function(_, M, m, p, pr) {\n debug(\"tilde\", comp, _, M, m, p, pr);\n var ret;\n if (isX(M)) ret = \"\";\n else if (isX(m)) ret = \">=\" + M + \".0.0 <\" + (+M + 1) + \".0.0\";\n else if (isX(p)) // ~1.2 == >=1.2.0 <1.3.0\n ret = \">=\" + M + \".\" + m + \".0 <\" + M + \".\" + (+m + 1) + \".0\";\n else if (pr) {\n debug(\"replaceTilde pr\", pr);\n ret = \">=\" + M + \".\" + m + \".\" + p + \"-\" + pr + \" <\" + M + \".\" + (+m + 1) + \".0\";\n } else // ~1.2.3 == >=1.2.3 <1.3.0\n ret = \">=\" + M + \".\" + m + \".\" + p + \" <\" + M + \".\" + (+m + 1) + \".0\";\n debug(\"tilde return\", ret);\n return ret;\n });\n}\n// ^ --> * (any, kinda silly)\n// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0\n// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0\n// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0\n// ^1.2.3 --> >=1.2.3 <2.0.0\n// ^1.2.0 --> >=1.2.0 <2.0.0\nfunction replaceCarets(comp, options) {\n return comp.trim().split(/\\s+/).map(function(comp) {\n return replaceCaret(comp, options);\n }).join(\" \");\n}\nfunction replaceCaret(comp, options) {\n debug(\"caret\", comp, options);\n var r = options.loose ? safeRe[t.CARETLOOSE] : safeRe[t.CARET];\n return comp.replace(r, function(_, M, m, p, pr) {\n debug(\"caret\", comp, _, M, m, p, pr);\n var ret;\n if (isX(M)) ret = \"\";\n else if (isX(m)) ret = \">=\" + M + \".0.0 <\" + (+M + 1) + \".0.0\";\n else if (isX(p)) {\n if (M === \"0\") ret = \">=\" + M + \".\" + m + \".0 <\" + M + \".\" + (+m + 1) + \".0\";\n else ret = \">=\" + M + \".\" + m + \".0 <\" + (+M + 1) + \".0.0\";\n } else if (pr) {\n debug(\"replaceCaret pr\", pr);\n if (M === \"0\") {\n if (m === \"0\") ret = \">=\" + M + \".\" + m + \".\" + p + \"-\" + pr + \" <\" + M + \".\" + m + \".\" + (+p + 1);\n else ret = \">=\" + M + \".\" + m + \".\" + p + \"-\" + pr + \" <\" + M + \".\" + (+m + 1) + \".0\";\n } else ret = \">=\" + M + \".\" + m + \".\" + p + \"-\" + pr + \" <\" + (+M + 1) + \".0.0\";\n } else {\n debug(\"no pr\");\n if (M === \"0\") {\n if (m === \"0\") ret = \">=\" + M + \".\" + m + \".\" + p + \" <\" + M + \".\" + m + \".\" + (+p + 1);\n else ret = \">=\" + M + \".\" + m + \".\" + p + \" <\" + M + \".\" + (+m + 1) + \".0\";\n } else ret = \">=\" + M + \".\" + m + \".\" + p + \" <\" + (+M + 1) + \".0.0\";\n }\n debug(\"caret return\", ret);\n return ret;\n });\n}\nfunction replaceXRanges(comp, options) {\n debug(\"replaceXRanges\", comp, options);\n return comp.split(/\\s+/).map(function(comp) {\n return replaceXRange(comp, options);\n }).join(\" \");\n}\nfunction replaceXRange(comp, options) {\n comp = comp.trim();\n var r = options.loose ? safeRe[t.XRANGELOOSE] : safeRe[t.XRANGE];\n return comp.replace(r, function(ret, gtlt, M, m, p, pr) {\n debug(\"xRange\", comp, ret, gtlt, M, m, p, pr);\n var xM = isX(M);\n var xm = xM || isX(m);\n var xp = xm || isX(p);\n var anyX = xp;\n if (gtlt === \"=\" && anyX) gtlt = \"\";\n // if we're including prereleases in the match, then we need\n // to fix this to -0, the lowest possible prerelease value\n pr = options.includePrerelease ? \"-0\" : \"\";\n if (xM) {\n if (gtlt === \">\" || gtlt === \"<\") // nothing is allowed\n ret = \"<0.0.0-0\";\n else // nothing is forbidden\n ret = \"*\";\n } else if (gtlt && anyX) {\n // we know patch is an x, because we have any x at all.\n // replace X with 0\n if (xm) m = 0;\n p = 0;\n if (gtlt === \">\") {\n // >1 => >=2.0.0\n // >1.2 => >=1.3.0\n // >1.2.3 => >= 1.2.4\n gtlt = \">=\";\n if (xm) {\n M = +M + 1;\n m = 0;\n p = 0;\n } else {\n m = +m + 1;\n p = 0;\n }\n } else if (gtlt === \"<=\") {\n // <=0.7.x is actually <0.8.0, since any 0.7.x should\n // pass. Similarly, <=7.x is actually <8.0.0, etc.\n gtlt = \"<\";\n if (xm) M = +M + 1;\n else m = +m + 1;\n }\n ret = gtlt + M + \".\" + m + \".\" + p + pr;\n } else if (xm) ret = \">=\" + M + \".0.0\" + pr + \" <\" + (+M + 1) + \".0.0\" + pr;\n else if (xp) ret = \">=\" + M + \".\" + m + \".0\" + pr + \" <\" + M + \".\" + (+m + 1) + \".0\" + pr;\n debug(\"xRange return\", ret);\n return ret;\n });\n}\n// Because * is AND-ed with everything else in the comparator,\n// and '' means \"any version\", just remove the *s entirely.\nfunction replaceStars(comp, options) {\n debug(\"replaceStars\", comp, options);\n // Looseness is ignored here. star is always as loose as it gets!\n return comp.trim().replace(safeRe[t.STAR], \"\");\n}\n// This function is passed to string.replace(re[t.HYPHENRANGE])\n// M, m, patch, prerelease, build\n// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5\n// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do\n// 1.2 - 3.4 => >=1.2.0 <3.5.0\nfunction hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {\n if (isX(fM)) from = \"\";\n else if (isX(fm)) from = \">=\" + fM + \".0.0\";\n else if (isX(fp)) from = \">=\" + fM + \".\" + fm + \".0\";\n else from = \">=\" + from;\n if (isX(tM)) to = \"\";\n else if (isX(tm)) to = \"<\" + (+tM + 1) + \".0.0\";\n else if (isX(tp)) to = \"<\" + tM + \".\" + (+tm + 1) + \".0\";\n else if (tpr) to = \"<=\" + tM + \".\" + tm + \".\" + tp + \"-\" + tpr;\n else to = \"<=\" + to;\n return (from + \" \" + to).trim();\n}\n// if ANY of the sets match ALL of its comparators, then pass\nRange.prototype.test = function(version) {\n if (!version) return false;\n if (typeof version === \"string\") try {\n version = new SemVer(version, this.options);\n } catch (er) {\n return false;\n }\n for(var i = 0; i < this.set.length; i++){\n if (testSet(this.set[i], version, this.options)) return true;\n }\n return false;\n};\nfunction testSet(set, version, options) {\n for(var i = 0; i < set.length; i++){\n if (!set[i].test(version)) return false;\n }\n if (version.prerelease.length && !options.includePrerelease) {\n // Find the set of versions that are allowed to have prereleases\n // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0\n // That should allow `1.2.3-pr.2` to pass.\n // However, `1.2.4-alpha.notready` should NOT be allowed,\n // even though it's within the range set by the comparators.\n for(i = 0; i < set.length; i++){\n debug(set[i].semver);\n if (set[i].semver === ANY) continue;\n if (set[i].semver.prerelease.length > 0) {\n var allowed = set[i].semver;\n if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) return true;\n }\n }\n // Version has a -pre, but it's not one of the ones we like.\n return false;\n }\n return true;\n}\nexports.satisfies = satisfies;\nfunction satisfies(version, range, options) {\n try {\n range = new Range(range, options);\n } catch (er) {\n return false;\n }\n return range.test(version);\n}\nexports.maxSatisfying = maxSatisfying;\nfunction maxSatisfying(versions, range, options) {\n var max = null;\n var maxSV = null;\n try {\n var rangeObj = new Range(range, options);\n } catch (er) {\n return null;\n }\n versions.forEach(function(v) {\n if (rangeObj.test(v)) // satisfies(v, range, options)\n {\n if (!max || maxSV.compare(v) === -1) {\n // compare(max, v, true)\n max = v;\n maxSV = new SemVer(max, options);\n }\n }\n });\n return max;\n}\nexports.minSatisfying = minSatisfying;\nfunction minSatisfying(versions, range, options) {\n var min = null;\n var minSV = null;\n try {\n var rangeObj = new Range(range, options);\n } catch (er) {\n return null;\n }\n versions.forEach(function(v) {\n if (rangeObj.test(v)) // satisfies(v, range, options)\n {\n if (!min || minSV.compare(v) === 1) {\n // compare(min, v, true)\n min = v;\n minSV = new SemVer(min, options);\n }\n }\n });\n return min;\n}\nexports.minVersion = minVersion;\nfunction minVersion(range, loose) {\n range = new Range(range, loose);\n var minver = new SemVer(\"0.0.0\");\n if (range.test(minver)) return minver;\n minver = new SemVer(\"0.0.0-0\");\n if (range.test(minver)) return minver;\n minver = null;\n for(var i = 0; i < range.set.length; ++i){\n var comparators = range.set[i];\n comparators.forEach(function(comparator) {\n // Clone to avoid manipulating the comparator's semver object.\n var compver = new SemVer(comparator.semver.version);\n switch(comparator.operator){\n case \">\":\n if (compver.prerelease.length === 0) compver.patch++;\n else compver.prerelease.push(0);\n compver.raw = compver.format();\n /* fallthrough */ case \"\":\n case \">=\":\n if (!minver || gt(minver, compver)) minver = compver;\n break;\n case \"<\":\n case \"<=\":\n break;\n /* istanbul ignore next */ default:\n throw new Error(\"Unexpected operation: \" + comparator.operator);\n }\n });\n }\n if (minver && range.test(minver)) return minver;\n return null;\n}\nexports.validRange = validRange;\nfunction validRange(range, options) {\n try {\n // Return '*' instead of '' so that truthiness works.\n // This will throw if it's invalid anyway\n return new Range(range, options).range || \"*\";\n } catch (er) {\n return null;\n }\n}\n// Determine if version is less than all the versions possible in the range\nexports.ltr = ltr;\nfunction ltr(version, range, options) {\n return outside(version, range, \"<\", options);\n}\n// Determine if version is greater than all the versions possible in the range.\nexports.gtr = gtr;\nfunction gtr(version, range, options) {\n return outside(version, range, \">\", options);\n}\nexports.outside = outside;\nfunction outside(version, range, hilo, options) {\n version = new SemVer(version, options);\n range = new Range(range, options);\n var gtfn, ltefn, ltfn, comp, ecomp;\n switch(hilo){\n case \">\":\n gtfn = gt;\n ltefn = lte;\n ltfn = lt;\n comp = \">\";\n ecomp = \">=\";\n break;\n case \"<\":\n gtfn = lt;\n ltefn = gte;\n ltfn = gt;\n comp = \"<\";\n ecomp = \"<=\";\n break;\n default:\n throw new TypeError('Must provide a hilo val of \"<\" or \">\"');\n }\n // If it satisifes the range it is not outside\n if (satisfies(version, range, options)) return false;\n // From now on, variable terms are as if we're in \"gtr\" mode.\n // but note that everything is flipped for the \"ltr\" function.\n for(var i = 0; i < range.set.length; ++i){\n var comparators = range.set[i];\n var high = null;\n var low = null;\n comparators.forEach(function(comparator) {\n if (comparator.semver === ANY) comparator = new Comparator(\">=0.0.0\");\n high = high || comparator;\n low = low || comparator;\n if (gtfn(comparator.semver, high.semver, options)) high = comparator;\n else if (ltfn(comparator.semver, low.semver, options)) low = comparator;\n });\n // If the edge version comparator has a operator then our version\n // isn't outside it\n if (high.operator === comp || high.operator === ecomp) return false;\n // If the lowest version comparator has an operator and our version\n // is less than it then it isn't higher than the range\n if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) return false;\n else if (low.operator === ecomp && ltfn(version, low.semver)) return false;\n }\n return true;\n}\nexports.prerelease = prerelease;\nfunction prerelease(version, options) {\n var parsed = parse(version, options);\n return parsed && parsed.prerelease.length ? parsed.prerelease : null;\n}\nexports.intersects = intersects;\nfunction intersects(r1, r2, options) {\n r1 = new Range(r1, options);\n r2 = new Range(r2, options);\n return r1.intersects(r2);\n}\nexports.coerce = coerce;\nfunction coerce(version, options) {\n if (version instanceof SemVer) return version;\n if (typeof version === \"number\") version = String(version);\n if (typeof version !== \"string\") return null;\n options = options || {};\n var match = null;\n if (!options.rtl) match = version.match(safeRe[t.COERCE]);\n else {\n // Find the right-most coercible string that does not share\n // a terminus with a more left-ward coercible string.\n // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'\n //\n // Walk through the string checking with a /g regexp\n // Manually set the index so as to pick up overlapping matches.\n // Stop when we get a match that ends at the string end, since no\n // coercible string can be more right-ward without the same terminus.\n var next;\n while((next = safeRe[t.COERCERTL].exec(version)) && (!match || match.index + match[0].length !== version.length)){\n if (!match || next.index + next[0].length !== match.index + match[0].length) match = next;\n safeRe[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;\n }\n // leave it in a clean state\n safeRe[t.COERCERTL].lastIndex = -1;\n }\n if (match === null) return null;\n return parse(match[2] + \".\" + (match[3] || \"0\") + \".\" + (match[4] || \"0\"), options);\n}\n\n});\n\n\nparcelRegister(\"eAF86\", function(module, exports) {\n\nvar $1W8as = parcelRequire(\"1W8as\");\n\nvar $hTpVN = parcelRequire(\"hTpVN\");\nfunction $a9f454f8e288d649$var$v4(options, buf, offset) {\n var i = buf && offset || 0;\n if (typeof options == \"string\") {\n buf = options === \"binary\" ? new Array(16) : null;\n options = null;\n }\n options = options || {};\n var rnds = options.random || (options.rng || $1W8as)();\n // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n rnds[6] = rnds[6] & 0x0f | 0x40;\n rnds[8] = rnds[8] & 0x3f | 0x80;\n // Copy bytes to buffer, if provided\n if (buf) for(var ii = 0; ii < 16; ++ii)buf[i + ii] = rnds[ii];\n return buf || $hTpVN(rnds);\n}\nmodule.exports = $a9f454f8e288d649$var$v4;\n\n});\nparcelRegister(\"1W8as\", function(module, exports) {\n// Unique ID creation requires a high quality random # generator. In node.js\n// this is pretty straight-forward - we use the crypto API.\n\nmodule.exports = function nodeRNG() {\n return $d7DIX$crypto.randomBytes(16);\n};\n\n});\n\nparcelRegister(\"hTpVN\", function(module, exports) {\n/**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */ var $d06bb019f71e9144$var$byteToHex = [];\nfor(var $d06bb019f71e9144$var$i = 0; $d06bb019f71e9144$var$i < 256; ++$d06bb019f71e9144$var$i)$d06bb019f71e9144$var$byteToHex[$d06bb019f71e9144$var$i] = ($d06bb019f71e9144$var$i + 0x100).toString(16).substr(1);\nfunction $d06bb019f71e9144$var$bytesToUuid(buf, offset) {\n var i = offset || 0;\n var bth = $d06bb019f71e9144$var$byteToHex;\n // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4\n return [\n bth[buf[i++]],\n bth[buf[i++]],\n bth[buf[i++]],\n bth[buf[i++]],\n \"-\",\n bth[buf[i++]],\n bth[buf[i++]],\n \"-\",\n bth[buf[i++]],\n bth[buf[i++]],\n \"-\",\n bth[buf[i++]],\n bth[buf[i++]],\n \"-\",\n bth[buf[i++]],\n bth[buf[i++]],\n bth[buf[i++]],\n bth[buf[i++]],\n bth[buf[i++]],\n bth[buf[i++]]\n ].join(\"\");\n}\nmodule.exports = $d06bb019f71e9144$var$bytesToUuid;\n\n});\n\n\nparcelRegister(\"1f6JF\", function(module, exports) {\n\"use strict\";\nvar $0e7c6aae7f120a88$var$__createBinding = module.exports && module.exports.__createBinding || (Object.create ? function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n Object.defineProperty(o, k2, {\n enumerable: true,\n get: function() {\n return m[k];\n }\n });\n} : function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n o[k2] = m[k];\n});\nvar $0e7c6aae7f120a88$var$__setModuleDefault = module.exports && module.exports.__setModuleDefault || (Object.create ? function(o, v) {\n Object.defineProperty(o, \"default\", {\n enumerable: true,\n value: v\n });\n} : function(o, v) {\n o[\"default\"] = v;\n});\nvar $0e7c6aae7f120a88$var$__importStar = module.exports && module.exports.__importStar || function(mod) {\n if (mod && mod.__esModule) return mod;\n var result = {};\n if (mod != null) {\n for(var k in mod)if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) $0e7c6aae7f120a88$var$__createBinding(result, mod, k);\n }\n $0e7c6aae7f120a88$var$__setModuleDefault(result, mod);\n return result;\n};\nvar $0e7c6aae7f120a88$var$__awaiter = module.exports && module.exports.__awaiter || function(thisArg, _arguments, P, generator) {\n function adopt(value) {\n return value instanceof P ? value : new P(function(resolve) {\n resolve(value);\n });\n }\n return new (P || (P = Promise))(function(resolve, reject) {\n function fulfilled(value) {\n try {\n step(generator.next(value));\n } catch (e) {\n reject(e);\n }\n }\n function rejected(value) {\n try {\n step(generator[\"throw\"](value));\n } catch (e) {\n reject(e);\n }\n }\n function step(result) {\n result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);\n }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nObject.defineProperty(module.exports, \"__esModule\", {\n value: true\n});\nmodule.exports.getExecOutput = module.exports.exec = void 0;\n\n\nconst $0e7c6aae7f120a88$var$tr = $0e7c6aae7f120a88$var$__importStar((parcelRequire(\"4B2AJ\")));\n/**\n * Exec a command.\n * Output will be streamed to the live console.\n * Returns promise with return code\n *\n * @param commandLine command to execute (can include additional args). Must be correctly escaped.\n * @param args optional arguments for tool. Escaping is handled by the lib.\n * @param options optional exec options. See ExecOptions\n * @returns Promise exit code\n */ function $0e7c6aae7f120a88$var$exec(commandLine, args, options) {\n return $0e7c6aae7f120a88$var$__awaiter(this, void 0, void 0, function*() {\n const commandArgs = $0e7c6aae7f120a88$var$tr.argStringToArray(commandLine);\n if (commandArgs.length === 0) throw new Error(`Parameter 'commandLine' cannot be null or empty.`);\n // Path to tool to execute should be first arg\n const toolPath = commandArgs[0];\n args = commandArgs.slice(1).concat(args || []);\n const runner = new $0e7c6aae7f120a88$var$tr.ToolRunner(toolPath, args, options);\n return runner.exec();\n });\n}\nmodule.exports.exec = $0e7c6aae7f120a88$var$exec;\n/**\n * Exec a command and get the output.\n * Output will be streamed to the live console.\n * Returns promise with the exit code and collected stdout and stderr\n *\n * @param commandLine command to execute (can include additional args). Must be correctly escaped.\n * @param args optional arguments for tool. Escaping is handled by the lib.\n * @param options optional exec options. See ExecOptions\n * @returns Promise exit code, stdout, and stderr\n */ function $0e7c6aae7f120a88$var$getExecOutput(commandLine, args, options) {\n var _a, _b;\n return $0e7c6aae7f120a88$var$__awaiter(this, void 0, void 0, function*() {\n let stdout = \"\";\n let stderr = \"\";\n //Using string decoder covers the case where a mult-byte character is split\n const stdoutDecoder = new $d7DIX$string_decoder.StringDecoder(\"utf8\");\n const stderrDecoder = new $d7DIX$string_decoder.StringDecoder(\"utf8\");\n const originalStdoutListener = (_a = options === null || options === void 0 ? void 0 : options.listeners) === null || _a === void 0 ? void 0 : _a.stdout;\n const originalStdErrListener = (_b = options === null || options === void 0 ? void 0 : options.listeners) === null || _b === void 0 ? void 0 : _b.stderr;\n const stdErrListener = (data)=>{\n stderr += stderrDecoder.write(data);\n if (originalStdErrListener) originalStdErrListener(data);\n };\n const stdOutListener = (data)=>{\n stdout += stdoutDecoder.write(data);\n if (originalStdoutListener) originalStdoutListener(data);\n };\n const listeners = Object.assign(Object.assign({}, options === null || options === void 0 ? void 0 : options.listeners), {\n stdout: stdOutListener,\n stderr: stdErrListener\n });\n const exitCode = yield $0e7c6aae7f120a88$var$exec(commandLine, args, Object.assign(Object.assign({}, options), {\n listeners: listeners\n }));\n //flush any remaining characters\n stdout += stdoutDecoder.end();\n stderr += stderrDecoder.end();\n return {\n exitCode: exitCode,\n stdout: stdout,\n stderr: stderr\n };\n });\n}\nmodule.exports.getExecOutput = $0e7c6aae7f120a88$var$getExecOutput;\n\n});\nparcelRegister(\"4B2AJ\", function(module, exports) {\n\"use strict\";\nvar $358ca0c13f34538f$var$__createBinding = module.exports && module.exports.__createBinding || (Object.create ? function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n Object.defineProperty(o, k2, {\n enumerable: true,\n get: function() {\n return m[k];\n }\n });\n} : function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n o[k2] = m[k];\n});\nvar $358ca0c13f34538f$var$__setModuleDefault = module.exports && module.exports.__setModuleDefault || (Object.create ? function(o, v) {\n Object.defineProperty(o, \"default\", {\n enumerable: true,\n value: v\n });\n} : function(o, v) {\n o[\"default\"] = v;\n});\nvar $358ca0c13f34538f$var$__importStar = module.exports && module.exports.__importStar || function(mod) {\n if (mod && mod.__esModule) return mod;\n var result = {};\n if (mod != null) {\n for(var k in mod)if (k !== \"default\" && Object.hasOwnProperty.call(mod, k)) $358ca0c13f34538f$var$__createBinding(result, mod, k);\n }\n $358ca0c13f34538f$var$__setModuleDefault(result, mod);\n return result;\n};\nvar $358ca0c13f34538f$var$__awaiter = module.exports && module.exports.__awaiter || function(thisArg, _arguments, P, generator) {\n function adopt(value) {\n return value instanceof P ? value : new P(function(resolve) {\n resolve(value);\n });\n }\n return new (P || (P = Promise))(function(resolve, reject) {\n function fulfilled(value) {\n try {\n step(generator.next(value));\n } catch (e) {\n reject(e);\n }\n }\n function rejected(value) {\n try {\n step(generator[\"throw\"](value));\n } catch (e) {\n reject(e);\n }\n }\n function step(result) {\n result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);\n }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nObject.defineProperty(module.exports, \"__esModule\", {\n value: true\n});\nmodule.exports.argStringToArray = module.exports.ToolRunner = void 0;\n\nconst $358ca0c13f34538f$var$os = $358ca0c13f34538f$var$__importStar($d7DIX$os);\n\nconst $358ca0c13f34538f$var$events = $358ca0c13f34538f$var$__importStar($d7DIX$events);\n\nconst $358ca0c13f34538f$var$child = $358ca0c13f34538f$var$__importStar($d7DIX$child_process);\n\nconst $358ca0c13f34538f$var$path = $358ca0c13f34538f$var$__importStar($d7DIX$path);\n\nconst $358ca0c13f34538f$var$io = $358ca0c13f34538f$var$__importStar((parcelRequire(\"hZdK0\")));\n\nconst $358ca0c13f34538f$var$ioUtil = $358ca0c13f34538f$var$__importStar((parcelRequire(\"ipB3d\")));\n\n/* eslint-disable @typescript-eslint/unbound-method */ const $358ca0c13f34538f$var$IS_WINDOWS = process.platform === \"win32\";\n/*\n * Class for running command line tools. Handles quoting and arg parsing in a platform agnostic way.\n */ class $358ca0c13f34538f$var$ToolRunner extends $358ca0c13f34538f$var$events.EventEmitter {\n constructor(toolPath, args, options){\n super();\n if (!toolPath) throw new Error(\"Parameter 'toolPath' cannot be null or empty.\");\n this.toolPath = toolPath;\n this.args = args || [];\n this.options = options || {};\n }\n _debug(message) {\n if (this.options.listeners && this.options.listeners.debug) this.options.listeners.debug(message);\n }\n _getCommandString(options, noPrefix) {\n const toolPath = this._getSpawnFileName();\n const args = this._getSpawnArgs(options);\n let cmd = noPrefix ? \"\" : \"[command]\"; // omit prefix when piped to a second tool\n if ($358ca0c13f34538f$var$IS_WINDOWS) {\n // Windows + cmd file\n if (this._isCmdFile()) {\n cmd += toolPath;\n for (const a of args)cmd += ` ${a}`;\n } else if (options.windowsVerbatimArguments) {\n cmd += `\"${toolPath}\"`;\n for (const a of args)cmd += ` ${a}`;\n } else {\n cmd += this._windowsQuoteCmdArg(toolPath);\n for (const a of args)cmd += ` ${this._windowsQuoteCmdArg(a)}`;\n }\n } else {\n // OSX/Linux - this can likely be improved with some form of quoting.\n // creating processes on Unix is fundamentally different than Windows.\n // on Unix, execvp() takes an arg array.\n cmd += toolPath;\n for (const a of args)cmd += ` ${a}`;\n }\n return cmd;\n }\n _processLineBuffer(data, strBuffer, onLine) {\n try {\n let s = strBuffer + data.toString();\n let n = s.indexOf($358ca0c13f34538f$var$os.EOL);\n while(n > -1){\n const line = s.substring(0, n);\n onLine(line);\n // the rest of the string ...\n s = s.substring(n + $358ca0c13f34538f$var$os.EOL.length);\n n = s.indexOf($358ca0c13f34538f$var$os.EOL);\n }\n return s;\n } catch (err) {\n // streaming lines to console is best effort. Don't fail a build.\n this._debug(`error processing line. Failed with error ${err}`);\n return \"\";\n }\n }\n _getSpawnFileName() {\n if ($358ca0c13f34538f$var$IS_WINDOWS) {\n if (this._isCmdFile()) return process.env[\"COMSPEC\"] || \"cmd.exe\";\n }\n return this.toolPath;\n }\n _getSpawnArgs(options) {\n if ($358ca0c13f34538f$var$IS_WINDOWS) {\n if (this._isCmdFile()) {\n let argline = `/D /S /C \"${this._windowsQuoteCmdArg(this.toolPath)}`;\n for (const a of this.args){\n argline += \" \";\n argline += options.windowsVerbatimArguments ? a : this._windowsQuoteCmdArg(a);\n }\n argline += '\"';\n return [\n argline\n ];\n }\n }\n return this.args;\n }\n _endsWith(str, end) {\n return str.endsWith(end);\n }\n _isCmdFile() {\n const upperToolPath = this.toolPath.toUpperCase();\n return this._endsWith(upperToolPath, \".CMD\") || this._endsWith(upperToolPath, \".BAT\");\n }\n _windowsQuoteCmdArg(arg) {\n // for .exe, apply the normal quoting rules that libuv applies\n if (!this._isCmdFile()) return this._uvQuoteCmdArg(arg);\n // otherwise apply quoting rules specific to the cmd.exe command line parser.\n // the libuv rules are generic and are not designed specifically for cmd.exe\n // command line parser.\n //\n // for a detailed description of the cmd.exe command line parser, refer to\n // http://stackoverflow.com/questions/4094699/how-does-the-windows-command-interpreter-cmd-exe-parse-scripts/7970912#7970912\n // need quotes for empty arg\n if (!arg) return '\"\"';\n // determine whether the arg needs to be quoted\n const cmdSpecialChars = [\n \" \",\n \"\t\",\n \"&\",\n \"(\",\n \")\",\n \"[\",\n \"]\",\n \"{\",\n \"}\",\n \"^\",\n \"=\",\n \";\",\n \"!\",\n \"'\",\n \"+\",\n \",\",\n \"`\",\n \"~\",\n \"|\",\n \"<\",\n \">\",\n '\"'\n ];\n let needsQuotes = false;\n for (const char of arg)if (cmdSpecialChars.some((x)=>x === char)) {\n needsQuotes = true;\n break;\n }\n // short-circuit if quotes not needed\n if (!needsQuotes) return arg;\n // the following quoting rules are very similar to the rules that by libuv applies.\n //\n // 1) wrap the string in quotes\n //\n // 2) double-up quotes - i.e. \" => \"\"\n //\n // this is different from the libuv quoting rules. libuv replaces \" with \\\", which unfortunately\n // doesn't work well with a cmd.exe command line.\n //\n // note, replacing \" with \"\" also works well if the arg is passed to a downstream .NET console app.\n // for example, the command line:\n // foo.exe \"myarg:\"\"my val\"\"\"\n // is parsed by a .NET console app into an arg array:\n // [ \"myarg:\\\"my val\\\"\" ]\n // which is the same end result when applying libuv quoting rules. although the actual\n // command line from libuv quoting rules would look like:\n // foo.exe \"myarg:\\\"my val\\\"\"\n //\n // 3) double-up slashes that precede a quote,\n // e.g. hello \\world => \"hello \\world\"\n // hello\\\"world => \"hello\\\\\"\"world\"\n // hello\\\\\"world => \"hello\\\\\\\\\"\"world\"\n // hello world\\ => \"hello world\\\\\"\n //\n // technically this is not required for a cmd.exe command line, or the batch argument parser.\n // the reasons for including this as a .cmd quoting rule are:\n //\n // a) this is optimized for the scenario where the argument is passed from the .cmd file to an\n // external program. many programs (e.g. .NET console apps) rely on the slash-doubling rule.\n //\n // b) it's what we've been doing previously (by deferring to node default behavior) and we\n // haven't heard any complaints about that aspect.\n //\n // note, a weakness of the quoting rules chosen here, is that % is not escaped. in fact, % cannot be\n // escaped when used on the command line directly - even though within a .cmd file % can be escaped\n // by using %%.\n //\n // the saving grace is, on the command line, %var% is left as-is if var is not defined. this contrasts\n // the line parsing rules within a .cmd file, where if var is not defined it is replaced with nothing.\n //\n // one option that was explored was replacing % with ^% - i.e. %var% => ^%var^%. this hack would\n // often work, since it is unlikely that var^ would exist, and the ^ character is removed when the\n // variable is used. the problem, however, is that ^ is not removed when %* is used to pass the args\n // to an external program.\n //\n // an unexplored potential solution for the % escaping problem, is to create a wrapper .cmd file.\n // % can be escaped within a .cmd file.\n let reverse = '\"';\n let quoteHit = true;\n for(let i = arg.length; i > 0; i--){\n // walk the string in reverse\n reverse += arg[i - 1];\n if (quoteHit && arg[i - 1] === \"\\\\\") reverse += \"\\\\\"; // double the slash\n else if (arg[i - 1] === '\"') {\n quoteHit = true;\n reverse += '\"'; // double the quote\n } else quoteHit = false;\n }\n reverse += '\"';\n return reverse.split(\"\").reverse().join(\"\");\n }\n _uvQuoteCmdArg(arg) {\n // Tool runner wraps child_process.spawn() and needs to apply the same quoting as\n // Node in certain cases where the undocumented spawn option windowsVerbatimArguments\n // is used.\n //\n // Since this function is a port of quote_cmd_arg from Node 4.x (technically, lib UV,\n // see https://github.com/nodejs/node/blob/v4.x/deps/uv/src/win/process.c for details),\n // pasting copyright notice from Node within this function:\n //\n // Copyright Joyent, Inc. and other Node contributors. All rights reserved.\n //\n // Permission is hereby granted, free of charge, to any person obtaining a copy\n // of this software and associated documentation files (the \"Software\"), to\n // deal in the Software without restriction, including without limitation the\n // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n // sell copies of the Software, and to permit persons to whom the Software is\n // furnished to do so, subject to the following conditions:\n //\n // The above copyright notice and this permission notice shall be included in\n // all copies or substantial portions of the Software.\n //\n // THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n // IN THE SOFTWARE.\n if (!arg) // Need double quotation for empty argument\n return '\"\"';\n if (!arg.includes(\" \") && !arg.includes(\"\t\") && !arg.includes('\"')) // No quotation needed\n return arg;\n if (!arg.includes('\"') && !arg.includes(\"\\\\\")) // No embedded double quotes or backslashes, so I can just wrap\n // quote marks around the whole thing.\n return `\"${arg}\"`;\n // Expected input/output:\n // input : hello\"world\n // output: \"hello\\\"world\"\n // input : hello\"\"world\n // output: \"hello\\\"\\\"world\"\n // input : hello\\world\n // output: hello\\world\n // input : hello\\\\world\n // output: hello\\\\world\n // input : hello\\\"world\n // output: \"hello\\\\\\\"world\"\n // input : hello\\\\\"world\n // output: \"hello\\\\\\\\\\\"world\"\n // input : hello world\\\n // output: \"hello world\\\\\" - note the comment in libuv actually reads \"hello world\\\"\n // but it appears the comment is wrong, it should be \"hello world\\\\\"\n let reverse = '\"';\n let quoteHit = true;\n for(let i = arg.length; i > 0; i--){\n // walk the string in reverse\n reverse += arg[i - 1];\n if (quoteHit && arg[i - 1] === \"\\\\\") reverse += \"\\\\\";\n else if (arg[i - 1] === '\"') {\n quoteHit = true;\n reverse += \"\\\\\";\n } else quoteHit = false;\n }\n reverse += '\"';\n return reverse.split(\"\").reverse().join(\"\");\n }\n _cloneExecOptions(options) {\n options = options || {};\n const result = {\n cwd: options.cwd || process.cwd(),\n env: options.env || process.env,\n silent: options.silent || false,\n windowsVerbatimArguments: options.windowsVerbatimArguments || false,\n failOnStdErr: options.failOnStdErr || false,\n ignoreReturnCode: options.ignoreReturnCode || false,\n delay: options.delay || 10000\n };\n result.outStream = options.outStream || process.stdout;\n result.errStream = options.errStream || process.stderr;\n return result;\n }\n _getSpawnOptions(options, toolPath) {\n options = options || {};\n const result = {};\n result.cwd = options.cwd;\n result.env = options.env;\n result[\"windowsVerbatimArguments\"] = options.windowsVerbatimArguments || this._isCmdFile();\n if (options.windowsVerbatimArguments) result.argv0 = `\"${toolPath}\"`;\n return result;\n }\n /**\n * Exec a tool.\n * Output will be streamed to the live console.\n * Returns promise with return code\n *\n * @param tool path to tool to exec\n * @param options optional exec options. See ExecOptions\n * @returns number\n */ exec() {\n return $358ca0c13f34538f$var$__awaiter(this, void 0, void 0, function*() {\n // root the tool path if it is unrooted and contains relative pathing\n if (!$358ca0c13f34538f$var$ioUtil.isRooted(this.toolPath) && (this.toolPath.includes(\"/\") || $358ca0c13f34538f$var$IS_WINDOWS && this.toolPath.includes(\"\\\\\"))) // prefer options.cwd if it is specified, however options.cwd may also need to be rooted\n this.toolPath = $358ca0c13f34538f$var$path.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath);\n // if the tool is only a file name, then resolve it from the PATH\n // otherwise verify it exists (add extension on Windows if necessary)\n this.toolPath = yield $358ca0c13f34538f$var$io.which(this.toolPath, true);\n return new Promise((resolve, reject)=>$358ca0c13f34538f$var$__awaiter(this, void 0, void 0, function*() {\n this._debug(`exec tool: ${this.toolPath}`);\n this._debug(\"arguments:\");\n for (const arg of this.args)this._debug(` ${arg}`);\n const optionsNonNull = this._cloneExecOptions(this.options);\n if (!optionsNonNull.silent && optionsNonNull.outStream) optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + $358ca0c13f34538f$var$os.EOL);\n const state = new $358ca0c13f34538f$var$ExecState(optionsNonNull, this.toolPath);\n state.on(\"debug\", (message)=>{\n this._debug(message);\n });\n if (this.options.cwd && !(yield $358ca0c13f34538f$var$ioUtil.exists(this.options.cwd))) return reject(new Error(`The cwd: ${this.options.cwd} does not exist!`));\n const fileName = this._getSpawnFileName();\n const cp = $358ca0c13f34538f$var$child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName));\n let stdbuffer = \"\";\n if (cp.stdout) cp.stdout.on(\"data\", (data)=>{\n if (this.options.listeners && this.options.listeners.stdout) this.options.listeners.stdout(data);\n if (!optionsNonNull.silent && optionsNonNull.outStream) optionsNonNull.outStream.write(data);\n stdbuffer = this._processLineBuffer(data, stdbuffer, (line)=>{\n if (this.options.listeners && this.options.listeners.stdline) this.options.listeners.stdline(line);\n });\n });\n let errbuffer = \"\";\n if (cp.stderr) cp.stderr.on(\"data\", (data)=>{\n state.processStderr = true;\n if (this.options.listeners && this.options.listeners.stderr) this.options.listeners.stderr(data);\n if (!optionsNonNull.silent && optionsNonNull.errStream && optionsNonNull.outStream) {\n const s = optionsNonNull.failOnStdErr ? optionsNonNull.errStream : optionsNonNull.outStream;\n s.write(data);\n }\n errbuffer = this._processLineBuffer(data, errbuffer, (line)=>{\n if (this.options.listeners && this.options.listeners.errline) this.options.listeners.errline(line);\n });\n });\n cp.on(\"error\", (err)=>{\n state.processError = err.message;\n state.processExited = true;\n state.processClosed = true;\n state.CheckComplete();\n });\n cp.on(\"exit\", (code)=>{\n state.processExitCode = code;\n state.processExited = true;\n this._debug(`Exit code ${code} received from tool '${this.toolPath}'`);\n state.CheckComplete();\n });\n cp.on(\"close\", (code)=>{\n state.processExitCode = code;\n state.processExited = true;\n state.processClosed = true;\n this._debug(`STDIO streams have closed for tool '${this.toolPath}'`);\n state.CheckComplete();\n });\n state.on(\"done\", (error, exitCode)=>{\n if (stdbuffer.length > 0) this.emit(\"stdline\", stdbuffer);\n if (errbuffer.length > 0) this.emit(\"errline\", errbuffer);\n cp.removeAllListeners();\n if (error) reject(error);\n else resolve(exitCode);\n });\n if (this.options.input) {\n if (!cp.stdin) throw new Error(\"child process missing stdin\");\n cp.stdin.end(this.options.input);\n }\n }));\n });\n }\n}\nmodule.exports.ToolRunner = $358ca0c13f34538f$var$ToolRunner;\n/**\n * Convert an arg string to an array of args. Handles escaping\n *\n * @param argString string of arguments\n * @returns string[] array of arguments\n */ function $358ca0c13f34538f$var$argStringToArray(argString) {\n const args = [];\n let inQuotes = false;\n let escaped = false;\n let arg = \"\";\n function append(c) {\n // we only escape double quotes.\n if (escaped && c !== '\"') arg += \"\\\\\";\n arg += c;\n escaped = false;\n }\n for(let i = 0; i < argString.length; i++){\n const c = argString.charAt(i);\n if (c === '\"') {\n if (!escaped) inQuotes = !inQuotes;\n else append(c);\n continue;\n }\n if (c === \"\\\\\" && escaped) {\n append(c);\n continue;\n }\n if (c === \"\\\\\" && inQuotes) {\n escaped = true;\n continue;\n }\n if (c === \" \" && !inQuotes) {\n if (arg.length > 0) {\n args.push(arg);\n arg = \"\";\n }\n continue;\n }\n append(c);\n }\n if (arg.length > 0) args.push(arg.trim());\n return args;\n}\nmodule.exports.argStringToArray = $358ca0c13f34538f$var$argStringToArray;\nclass $358ca0c13f34538f$var$ExecState extends $358ca0c13f34538f$var$events.EventEmitter {\n constructor(options, toolPath){\n super();\n this.processClosed = false; // tracks whether the process has exited and stdio is closed\n this.processError = \"\";\n this.processExitCode = 0;\n this.processExited = false; // tracks whether the process has exited\n this.processStderr = false; // tracks whether stderr was written to\n this.delay = 10000; // 10 seconds\n this.done = false;\n this.timeout = null;\n if (!toolPath) throw new Error(\"toolPath must not be empty\");\n this.options = options;\n this.toolPath = toolPath;\n if (options.delay) this.delay = options.delay;\n }\n CheckComplete() {\n if (this.done) return;\n if (this.processClosed) this._setResult();\n else if (this.processExited) this.timeout = $d7DIX$timers.setTimeout($358ca0c13f34538f$var$ExecState.HandleTimeout, this.delay, this);\n }\n _debug(message) {\n this.emit(\"debug\", message);\n }\n _setResult() {\n // determine whether there is an error\n let error;\n if (this.processExited) {\n if (this.processError) error = new Error(`There was an error when attempting to execute the process '${this.toolPath}'. This may indicate the process failed to start. Error: ${this.processError}`);\n else if (this.processExitCode !== 0 && !this.options.ignoreReturnCode) error = new Error(`The process '${this.toolPath}' failed with exit code ${this.processExitCode}`);\n else if (this.processStderr && this.options.failOnStdErr) error = new Error(`The process '${this.toolPath}' failed because one or more lines were written to the STDERR stream`);\n }\n // clear the timeout\n if (this.timeout) {\n clearTimeout(this.timeout);\n this.timeout = null;\n }\n this.done = true;\n this.emit(\"done\", error, this.processExitCode);\n }\n static HandleTimeout(state) {\n if (state.done) return;\n if (!state.processClosed && state.processExited) {\n const message = `The STDIO streams did not close within ${state.delay / 1000} seconds of the exit event from process '${state.toolPath}'. This may indicate a child process inherited the STDIO streams and has not yet exited.`;\n state._debug(message);\n }\n state._setResult();\n }\n}\n\n});\n\n\nparcelRegister(\"4JiFg\", function(module, exports) {\nmodule.exports = Promise.resolve(require(\"./actions_python.4fb6b558.js\")).then(()=>parcelRequire(\"4kQHk\"));\n\n});\n\nparcelRegister(\"i9SYz\", function(module, exports) {\n\n$parcel$export(module.exports, \"DOMParser\", () => $d383b6561dce1487$export$1059c6e7d2ce5669, (v) => $d383b6561dce1487$export$1059c6e7d2ce5669 = v);\nvar $d383b6561dce1487$export$181392475aa39887;\nvar $d383b6561dce1487$export$ba13e0e2f19e61a1;\nvar $d383b6561dce1487$export$1059c6e7d2ce5669;\n\nvar $12jBw = parcelRequire(\"12jBw\");\n\nvar $fSAop = parcelRequire(\"fSAop\");\n\nvar $g5ebD = parcelRequire(\"g5ebD\");\n\nvar $gqQA6 = parcelRequire(\"gqQA6\");\nvar $d383b6561dce1487$var$DOMImplementation = $fSAop.DOMImplementation;\nvar $d383b6561dce1487$var$NAMESPACE = $12jBw.NAMESPACE;\nvar $d383b6561dce1487$var$ParseError = $gqQA6.ParseError;\nvar $d383b6561dce1487$var$XMLReader = $gqQA6.XMLReader;\n/**\n * Normalizes line ending according to https://www.w3.org/TR/xml11/#sec-line-ends:\n *\n * > XML parsed entities are often stored in computer files which,\n * > for editing convenience, are organized into lines.\n * > These lines are typically separated by some combination\n * > of the characters CARRIAGE RETURN (#xD) and LINE FEED (#xA).\n * >\n * > To simplify the tasks of applications, the XML processor must behave\n * > as if it normalized all line breaks in external parsed entities (including the document entity)\n * > on input, before parsing, by translating all of the following to a single #xA character:\n * >\n * > 1. the two-character sequence #xD #xA\n * > 2. the two-character sequence #xD #x85\n * > 3. the single character #x85\n * > 4. the single character #x2028\n * > 5. any #xD character that is not immediately followed by #xA or #x85.\n *\n * @param {string} input\n * @returns {string}\n */ function $d383b6561dce1487$var$normalizeLineEndings(input) {\n return input.replace(/\\r[\\n\\u0085]/g, \"\\n\").replace(/[\\r\\u0085\\u2028]/g, \"\\n\");\n}\n/**\n * @typedef Locator\n * @property {number} [columnNumber]\n * @property {number} [lineNumber]\n */ /**\n * @typedef DOMParserOptions\n * @property {DOMHandler} [domBuilder]\n * @property {Function} [errorHandler]\n * @property {(string) => string} [normalizeLineEndings] used to replace line endings before parsing\n * \t\t\t\t\t\tdefaults to `normalizeLineEndings`\n * @property {Locator} [locator]\n * @property {Record} [xmlns]\n *\n * @see normalizeLineEndings\n */ /**\n * The DOMParser interface provides the ability to parse XML or HTML source code\n * from a string into a DOM `Document`.\n *\n * _xmldom is different from the spec in that it allows an `options` parameter,\n * to override the default behavior._\n *\n * @param {DOMParserOptions} [options]\n * @constructor\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser\n * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-parsing-and-serialization\n */ function $d383b6561dce1487$var$DOMParser(options) {\n this.options = options || {\n locator: {}\n };\n}\n$d383b6561dce1487$var$DOMParser.prototype.parseFromString = function(source, mimeType) {\n var options = this.options;\n var sax = new $d383b6561dce1487$var$XMLReader();\n var domBuilder = options.domBuilder || new $d383b6561dce1487$var$DOMHandler(); //contentHandler and LexicalHandler\n var errorHandler = options.errorHandler;\n var locator = options.locator;\n var defaultNSMap = options.xmlns || {};\n var isHTML = /\\/x?html?$/.test(mimeType); //mimeType.toLowerCase().indexOf('html') > -1;\n var entityMap = isHTML ? $g5ebD.HTML_ENTITIES : $g5ebD.XML_ENTITIES;\n if (locator) domBuilder.setDocumentLocator(locator);\n sax.errorHandler = $d383b6561dce1487$var$buildErrorHandler(errorHandler, domBuilder, locator);\n sax.domBuilder = options.domBuilder || domBuilder;\n if (isHTML) defaultNSMap[\"\"] = $d383b6561dce1487$var$NAMESPACE.HTML;\n defaultNSMap.xml = defaultNSMap.xml || $d383b6561dce1487$var$NAMESPACE.XML;\n var normalize = options.normalizeLineEndings || $d383b6561dce1487$var$normalizeLineEndings;\n if (source && typeof source === \"string\") sax.parse(normalize(source), defaultNSMap, entityMap);\n else sax.errorHandler.error(\"invalid doc source\");\n return domBuilder.doc;\n};\nfunction $d383b6561dce1487$var$buildErrorHandler(errorImpl, domBuilder, locator) {\n if (!errorImpl) {\n if (domBuilder instanceof $d383b6561dce1487$var$DOMHandler) return domBuilder;\n errorImpl = domBuilder;\n }\n var errorHandler = {};\n var isCallback = errorImpl instanceof Function;\n locator = locator || {};\n function build(key) {\n var fn = errorImpl[key];\n if (!fn && isCallback) fn = errorImpl.length == 2 ? function(msg) {\n errorImpl(key, msg);\n } : errorImpl;\n errorHandler[key] = fn && function(msg) {\n fn(\"[xmldom \" + key + \"]\t\" + msg + $d383b6561dce1487$var$_locator(locator));\n } || function() {};\n }\n build(\"warning\");\n build(\"error\");\n build(\"fatalError\");\n return errorHandler;\n}\n//console.log('#\\n\\n\\n\\n\\n\\n\\n####')\n/**\n * +ContentHandler+ErrorHandler\n * +LexicalHandler+EntityResolver2\n * -DeclHandler-DTDHandler\n *\n * DefaultHandler:EntityResolver, DTDHandler, ContentHandler, ErrorHandler\n * DefaultHandler2:DefaultHandler,LexicalHandler, DeclHandler, EntityResolver2\n * @link http://www.saxproject.org/apidoc/org/xml/sax/helpers/DefaultHandler.html\n */ function $d383b6561dce1487$var$DOMHandler() {\n this.cdata = false;\n}\nfunction $d383b6561dce1487$var$position(locator, node) {\n node.lineNumber = locator.lineNumber;\n node.columnNumber = locator.columnNumber;\n}\n/**\n * @see org.xml.sax.ContentHandler#startDocument\n * @link http://www.saxproject.org/apidoc/org/xml/sax/ContentHandler.html\n */ $d383b6561dce1487$var$DOMHandler.prototype = {\n startDocument: function() {\n this.doc = new $d383b6561dce1487$var$DOMImplementation().createDocument(null, null, null);\n if (this.locator) this.doc.documentURI = this.locator.systemId;\n },\n startElement: function(namespaceURI, localName, qName, attrs) {\n var doc = this.doc;\n var el = doc.createElementNS(namespaceURI, qName || localName);\n var len = attrs.length;\n $d383b6561dce1487$var$appendElement(this, el);\n this.currentElement = el;\n this.locator && $d383b6561dce1487$var$position(this.locator, el);\n for(var i = 0; i < len; i++){\n var namespaceURI = attrs.getURI(i);\n var value = attrs.getValue(i);\n var qName = attrs.getQName(i);\n var attr = doc.createAttributeNS(namespaceURI, qName);\n this.locator && $d383b6561dce1487$var$position(attrs.getLocator(i), attr);\n attr.value = attr.nodeValue = value;\n el.setAttributeNode(attr);\n }\n },\n endElement: function(namespaceURI, localName, qName) {\n var current = this.currentElement;\n var tagName = current.tagName;\n this.currentElement = current.parentNode;\n },\n startPrefixMapping: function(prefix, uri) {},\n endPrefixMapping: function(prefix) {},\n processingInstruction: function(target, data) {\n var ins = this.doc.createProcessingInstruction(target, data);\n this.locator && $d383b6561dce1487$var$position(this.locator, ins);\n $d383b6561dce1487$var$appendElement(this, ins);\n },\n ignorableWhitespace: function(ch, start, length) {},\n characters: function(chars, start, length) {\n chars = $d383b6561dce1487$var$_toString.apply(this, arguments);\n //console.log(chars)\n if (chars) {\n if (this.cdata) var charNode = this.doc.createCDATASection(chars);\n else var charNode = this.doc.createTextNode(chars);\n if (this.currentElement) this.currentElement.appendChild(charNode);\n else if (/^\\s*$/.test(chars)) this.doc.appendChild(charNode);\n this.locator && $d383b6561dce1487$var$position(this.locator, charNode);\n }\n },\n skippedEntity: function(name) {},\n endDocument: function() {\n this.doc.normalize();\n },\n setDocumentLocator: function(locator) {\n if (this.locator = locator) locator.lineNumber = 0;\n },\n //LexicalHandler\n comment: function(chars, start, length) {\n chars = $d383b6561dce1487$var$_toString.apply(this, arguments);\n var comm = this.doc.createComment(chars);\n this.locator && $d383b6561dce1487$var$position(this.locator, comm);\n $d383b6561dce1487$var$appendElement(this, comm);\n },\n startCDATA: function() {\n //used in characters() methods\n this.cdata = true;\n },\n endCDATA: function() {\n this.cdata = false;\n },\n startDTD: function(name, publicId, systemId) {\n var impl = this.doc.implementation;\n if (impl && impl.createDocumentType) {\n var dt = impl.createDocumentType(name, publicId, systemId);\n this.locator && $d383b6561dce1487$var$position(this.locator, dt);\n $d383b6561dce1487$var$appendElement(this, dt);\n this.doc.doctype = dt;\n }\n },\n /**\n\t * @see org.xml.sax.ErrorHandler\n\t * @link http://www.saxproject.org/apidoc/org/xml/sax/ErrorHandler.html\n\t */ warning: function(error) {\n console.warn(\"[xmldom warning]\t\" + error, $d383b6561dce1487$var$_locator(this.locator));\n },\n error: function(error) {\n console.error(\"[xmldom error]\t\" + error, $d383b6561dce1487$var$_locator(this.locator));\n },\n fatalError: function(error) {\n throw new $d383b6561dce1487$var$ParseError(error, this.locator);\n }\n};\nfunction $d383b6561dce1487$var$_locator(l) {\n if (l) return \"\\n@\" + (l.systemId || \"\") + \"#[line:\" + l.lineNumber + \",col:\" + l.columnNumber + \"]\";\n}\nfunction $d383b6561dce1487$var$_toString(chars, start, length) {\n if (typeof chars == \"string\") return chars.substr(start, length);\n else {\n if (chars.length >= start + length || start) return new java.lang.String(chars, start, length) + \"\";\n return chars;\n }\n}\n/*\n * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/LexicalHandler.html\n * used method of org.xml.sax.ext.LexicalHandler:\n * #comment(chars, start, length)\n * #startCDATA()\n * #endCDATA()\n * #startDTD(name, publicId, systemId)\n *\n *\n * IGNORED method of org.xml.sax.ext.LexicalHandler:\n * #endDTD()\n * #startEntity(name)\n * #endEntity(name)\n *\n *\n * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/DeclHandler.html\n * IGNORED method of org.xml.sax.ext.DeclHandler\n * \t#attributeDecl(eName, aName, type, mode, value)\n * #elementDecl(name, model)\n * #externalEntityDecl(name, publicId, systemId)\n * #internalEntityDecl(name, value)\n * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/EntityResolver2.html\n * IGNORED method of org.xml.sax.EntityResolver2\n * #resolveEntity(String name,String publicId,String baseURI,String systemId)\n * #resolveEntity(publicId, systemId)\n * #getExternalSubset(name, baseURI)\n * @link http://www.saxproject.org/apidoc/org/xml/sax/DTDHandler.html\n * IGNORED method of org.xml.sax.DTDHandler\n * #notationDecl(name, publicId, systemId) {};\n * #unparsedEntityDecl(name, publicId, systemId, notationName) {};\n */ \"endDTD,startEntity,endEntity,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,resolveEntity,getExternalSubset,notationDecl,unparsedEntityDecl\".replace(/\\w+/g, function(key) {\n $d383b6561dce1487$var$DOMHandler.prototype[key] = function() {\n return null;\n };\n});\n/* Private static helpers treated below as private instance methods, so don't need to add these to the public API; we might use a Relator to also get rid of non-standard public properties */ function $d383b6561dce1487$var$appendElement(hander, node) {\n if (!hander.currentElement) hander.doc.appendChild(node);\n else hander.currentElement.appendChild(node);\n} //appendChild and setAttributeNS are preformance key\n$d383b6561dce1487$export$181392475aa39887 = $d383b6561dce1487$var$DOMHandler;\n$d383b6561dce1487$export$ba13e0e2f19e61a1 = $d383b6561dce1487$var$normalizeLineEndings;\n$d383b6561dce1487$export$1059c6e7d2ce5669 = $d383b6561dce1487$var$DOMParser;\n\n});\nparcelRegister(\"12jBw\", function(module, exports) {\n\n$parcel$export(module.exports, \"find\", () => $0c152f5a1a56ce9f$export$71aa6c912b956294, (v) => $0c152f5a1a56ce9f$export$71aa6c912b956294 = v);\n$parcel$export(module.exports, \"freeze\", () => $0c152f5a1a56ce9f$export$792f3d81ea979f55, (v) => $0c152f5a1a56ce9f$export$792f3d81ea979f55 = v);\n$parcel$export(module.exports, \"NAMESPACE\", () => $0c152f5a1a56ce9f$export$6aad947bda0f3f46, (v) => $0c152f5a1a56ce9f$export$6aad947bda0f3f46 = v);\nvar $0c152f5a1a56ce9f$export$e6e34fd1f2686227;\nvar $0c152f5a1a56ce9f$export$71aa6c912b956294;\nvar $0c152f5a1a56ce9f$export$792f3d81ea979f55;\nvar $0c152f5a1a56ce9f$export$c6cb9dd1e3ada1aa;\nvar $0c152f5a1a56ce9f$export$6aad947bda0f3f46;\n\"use strict\";\n/**\n * Ponyfill for `Array.prototype.find` which is only available in ES6 runtimes.\n *\n * Works with anything that has a `length` property and index access properties, including NodeList.\n *\n * @template {unknown} T\n * @param {Array | ({length:number, [number]: T})} list\n * @param {function (item: T, index: number, list:Array | ({length:number, [number]: T})):boolean} predicate\n * @param {Partial>?} ac `Array.prototype` by default,\n * \t\t\t\tallows injecting a custom implementation in tests\n * @returns {T | undefined}\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find\n * @see https://tc39.es/ecma262/multipage/indexed-collections.html#sec-array.prototype.find\n */ function $0c152f5a1a56ce9f$var$find(list, predicate, ac) {\n if (ac === undefined) ac = Array.prototype;\n if (list && typeof ac.find === \"function\") return ac.find.call(list, predicate);\n for(var i = 0; i < list.length; i++)if (Object.prototype.hasOwnProperty.call(list, i)) {\n var item = list[i];\n if (predicate.call(undefined, item, i, list)) return item;\n }\n}\n/**\n * \"Shallow freezes\" an object to render it immutable.\n * Uses `Object.freeze` if available,\n * otherwise the immutability is only in the type.\n *\n * Is used to create \"enum like\" objects.\n *\n * @template T\n * @param {T} object the object to freeze\n * @param {Pick = Object} oc `Object` by default,\n * \t\t\t\tallows to inject custom object constructor for tests\n * @returns {Readonly}\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze\n */ function $0c152f5a1a56ce9f$var$freeze(object, oc) {\n if (oc === undefined) oc = Object;\n return oc && typeof oc.freeze === \"function\" ? oc.freeze(object) : object;\n}\n/**\n * Since we can not rely on `Object.assign` we provide a simplified version\n * that is sufficient for our needs.\n *\n * @param {Object} target\n * @param {Object | null | undefined} source\n *\n * @returns {Object} target\n * @throws TypeError if target is not an object\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign\n * @see https://tc39.es/ecma262/multipage/fundamental-objects.html#sec-object.assign\n */ function $0c152f5a1a56ce9f$var$assign(target, source) {\n if (target === null || typeof target !== \"object\") throw new TypeError(\"target is not an object\");\n for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];\n return target;\n}\n/**\n * All mime types that are allowed as input to `DOMParser.parseFromString`\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString#Argument02 MDN\n * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#domparsersupportedtype WHATWG HTML Spec\n * @see DOMParser.prototype.parseFromString\n */ var $0c152f5a1a56ce9f$var$MIME_TYPE = $0c152f5a1a56ce9f$var$freeze({\n /**\n\t * `text/html`, the only mime type that triggers treating an XML document as HTML.\n\t *\n\t * @see DOMParser.SupportedType.isHTML\n\t * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration\n\t * @see https://en.wikipedia.org/wiki/HTML Wikipedia\n\t * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN\n\t * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring WHATWG HTML Spec\n\t */ HTML: \"text/html\",\n /**\n\t * Helper method to check a mime type if it indicates an HTML document\n\t *\n\t * @param {string} [value]\n\t * @returns {boolean}\n\t *\n\t * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration\n\t * @see https://en.wikipedia.org/wiki/HTML Wikipedia\n\t * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN\n\t * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring \t */ isHTML: function(value) {\n return value === $0c152f5a1a56ce9f$var$MIME_TYPE.HTML;\n },\n /**\n\t * `application/xml`, the standard mime type for XML documents.\n\t *\n\t * @see https://www.iana.org/assignments/media-types/application/xml IANA MimeType registration\n\t * @see https://tools.ietf.org/html/rfc7303#section-9.1 RFC 7303\n\t * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia\n\t */ XML_APPLICATION: \"application/xml\",\n /**\n\t * `text/html`, an alias for `application/xml`.\n\t *\n\t * @see https://tools.ietf.org/html/rfc7303#section-9.2 RFC 7303\n\t * @see https://www.iana.org/assignments/media-types/text/xml IANA MimeType registration\n\t * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia\n\t */ XML_TEXT: \"text/xml\",\n /**\n\t * `application/xhtml+xml`, indicates an XML document that has the default HTML namespace,\n\t * but is parsed as an XML document.\n\t *\n\t * @see https://www.iana.org/assignments/media-types/application/xhtml+xml IANA MimeType registration\n\t * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument WHATWG DOM Spec\n\t * @see https://en.wikipedia.org/wiki/XHTML Wikipedia\n\t */ XML_XHTML_APPLICATION: \"application/xhtml+xml\",\n /**\n\t * `image/svg+xml`,\n\t *\n\t * @see https://www.iana.org/assignments/media-types/image/svg+xml IANA MimeType registration\n\t * @see https://www.w3.org/TR/SVG11/ W3C SVG 1.1\n\t * @see https://en.wikipedia.org/wiki/Scalable_Vector_Graphics Wikipedia\n\t */ XML_SVG_IMAGE: \"image/svg+xml\"\n});\n/**\n * Namespaces that are used in this code base.\n *\n * @see http://www.w3.org/TR/REC-xml-names\n */ var $0c152f5a1a56ce9f$var$NAMESPACE = $0c152f5a1a56ce9f$var$freeze({\n /**\n\t * The XHTML namespace.\n\t *\n\t * @see http://www.w3.org/1999/xhtml\n\t */ HTML: \"http://www.w3.org/1999/xhtml\",\n /**\n\t * Checks if `uri` equals `NAMESPACE.HTML`.\n\t *\n\t * @param {string} [uri]\n\t *\n\t * @see NAMESPACE.HTML\n\t */ isHTML: function(uri) {\n return uri === $0c152f5a1a56ce9f$var$NAMESPACE.HTML;\n },\n /**\n\t * The SVG namespace.\n\t *\n\t * @see http://www.w3.org/2000/svg\n\t */ SVG: \"http://www.w3.org/2000/svg\",\n /**\n\t * The `xml:` namespace.\n\t *\n\t * @see http://www.w3.org/XML/1998/namespace\n\t */ XML: \"http://www.w3.org/XML/1998/namespace\",\n /**\n\t * The `xmlns:` namespace\n\t *\n\t * @see https://www.w3.org/2000/xmlns/\n\t */ XMLNS: \"http://www.w3.org/2000/xmlns/\"\n});\n$0c152f5a1a56ce9f$export$e6e34fd1f2686227 = $0c152f5a1a56ce9f$var$assign;\n$0c152f5a1a56ce9f$export$71aa6c912b956294 = $0c152f5a1a56ce9f$var$find;\n$0c152f5a1a56ce9f$export$792f3d81ea979f55 = $0c152f5a1a56ce9f$var$freeze;\n$0c152f5a1a56ce9f$export$c6cb9dd1e3ada1aa = $0c152f5a1a56ce9f$var$MIME_TYPE;\n$0c152f5a1a56ce9f$export$6aad947bda0f3f46 = $0c152f5a1a56ce9f$var$NAMESPACE;\n\n});\n\nparcelRegister(\"fSAop\", function(module, exports) {\n\n$parcel$export(module.exports, \"DOMImplementation\", () => $b8f821026a6eb0fb$export$455426655eab1d48, (v) => $b8f821026a6eb0fb$export$455426655eab1d48 = v);\n$parcel$export(module.exports, \"XMLSerializer\", () => $b8f821026a6eb0fb$export$64f0bed4ae6f0f24, (v) => $b8f821026a6eb0fb$export$64f0bed4ae6f0f24 = v);\n//if(typeof require == 'function'){\nvar $b8f821026a6eb0fb$export$d1d99cf900472499;\nvar $b8f821026a6eb0fb$export$fe58bcf938607f6a;\nvar $b8f821026a6eb0fb$export$455426655eab1d48;\nvar $b8f821026a6eb0fb$export$db77ccec0bb4ccac;\nvar $b8f821026a6eb0fb$export$85c928794f8d04d4;\nvar $b8f821026a6eb0fb$export$79b41aa5d56abdff;\nvar $b8f821026a6eb0fb$export$64f0bed4ae6f0f24;\n\nvar $12jBw = parcelRequire(\"12jBw\");\nvar $b8f821026a6eb0fb$var$find = $12jBw.find;\nvar $b8f821026a6eb0fb$var$NAMESPACE = $12jBw.NAMESPACE;\n/**\n * A prerequisite for `[].filter`, to drop elements that are empty\n * @param {string} input\n * @returns {boolean}\n */ function $b8f821026a6eb0fb$var$notEmptyString(input) {\n return input !== \"\";\n}\n/**\n * @see https://infra.spec.whatwg.org/#split-on-ascii-whitespace\n * @see https://infra.spec.whatwg.org/#ascii-whitespace\n *\n * @param {string} input\n * @returns {string[]} (can be empty)\n */ function $b8f821026a6eb0fb$var$splitOnASCIIWhitespace(input) {\n // U+0009 TAB, U+000A LF, U+000C FF, U+000D CR, U+0020 SPACE\n return input ? input.split(/[\\t\\n\\f\\r ]+/).filter($b8f821026a6eb0fb$var$notEmptyString) : [];\n}\n/**\n * Adds element as a key to current if it is not already present.\n *\n * @param {Record} current\n * @param {string} element\n * @returns {Record}\n */ function $b8f821026a6eb0fb$var$orderedSetReducer(current, element) {\n if (!current.hasOwnProperty(element)) current[element] = true;\n return current;\n}\n/**\n * @see https://infra.spec.whatwg.org/#ordered-set\n * @param {string} input\n * @returns {string[]}\n */ function $b8f821026a6eb0fb$var$toOrderedSet(input) {\n if (!input) return [];\n var list = $b8f821026a6eb0fb$var$splitOnASCIIWhitespace(input);\n return Object.keys(list.reduce($b8f821026a6eb0fb$var$orderedSetReducer, {}));\n}\n/**\n * Uses `list.indexOf` to implement something like `Array.prototype.includes`,\n * which we can not rely on being available.\n *\n * @param {any[]} list\n * @returns {function(any): boolean}\n */ function $b8f821026a6eb0fb$var$arrayIncludes(list) {\n return function(element) {\n return list && list.indexOf(element) !== -1;\n };\n}\nfunction $b8f821026a6eb0fb$var$copy(src, dest) {\n for(var p in src)if (Object.prototype.hasOwnProperty.call(src, p)) dest[p] = src[p];\n}\n/**\n^\\w+\\.prototype\\.([_\\w]+)\\s*=\\s*((?:.*\\{\\s*?[\\r\\n][\\s\\S]*?^})|\\S.*?(?=[;\\r\\n]));?\n^\\w+\\.prototype\\.([_\\w]+)\\s*=\\s*(\\S.*?(?=[;\\r\\n]));?\n */ function $b8f821026a6eb0fb$var$_extends(Class, Super) {\n var pt = Class.prototype;\n if (!(pt instanceof Super)) {\n function t() {}\n t.prototype = Super.prototype;\n t = new t();\n $b8f821026a6eb0fb$var$copy(pt, t);\n Class.prototype = pt = t;\n }\n if (pt.constructor != Class) {\n if (typeof Class != \"function\") console.error(\"unknown Class:\" + Class);\n pt.constructor = Class;\n }\n}\n// Node Types\nvar $b8f821026a6eb0fb$var$NodeType = {};\nvar $b8f821026a6eb0fb$var$ELEMENT_NODE = $b8f821026a6eb0fb$var$NodeType.ELEMENT_NODE = 1;\nvar $b8f821026a6eb0fb$var$ATTRIBUTE_NODE = $b8f821026a6eb0fb$var$NodeType.ATTRIBUTE_NODE = 2;\nvar $b8f821026a6eb0fb$var$TEXT_NODE = $b8f821026a6eb0fb$var$NodeType.TEXT_NODE = 3;\nvar $b8f821026a6eb0fb$var$CDATA_SECTION_NODE = $b8f821026a6eb0fb$var$NodeType.CDATA_SECTION_NODE = 4;\nvar $b8f821026a6eb0fb$var$ENTITY_REFERENCE_NODE = $b8f821026a6eb0fb$var$NodeType.ENTITY_REFERENCE_NODE = 5;\nvar $b8f821026a6eb0fb$var$ENTITY_NODE = $b8f821026a6eb0fb$var$NodeType.ENTITY_NODE = 6;\nvar $b8f821026a6eb0fb$var$PROCESSING_INSTRUCTION_NODE = $b8f821026a6eb0fb$var$NodeType.PROCESSING_INSTRUCTION_NODE = 7;\nvar $b8f821026a6eb0fb$var$COMMENT_NODE = $b8f821026a6eb0fb$var$NodeType.COMMENT_NODE = 8;\nvar $b8f821026a6eb0fb$var$DOCUMENT_NODE = $b8f821026a6eb0fb$var$NodeType.DOCUMENT_NODE = 9;\nvar $b8f821026a6eb0fb$var$DOCUMENT_TYPE_NODE = $b8f821026a6eb0fb$var$NodeType.DOCUMENT_TYPE_NODE = 10;\nvar $b8f821026a6eb0fb$var$DOCUMENT_FRAGMENT_NODE = $b8f821026a6eb0fb$var$NodeType.DOCUMENT_FRAGMENT_NODE = 11;\nvar $b8f821026a6eb0fb$var$NOTATION_NODE = $b8f821026a6eb0fb$var$NodeType.NOTATION_NODE = 12;\n// ExceptionCode\nvar $b8f821026a6eb0fb$var$ExceptionCode = {};\nvar $b8f821026a6eb0fb$var$ExceptionMessage = {};\nvar $b8f821026a6eb0fb$var$INDEX_SIZE_ERR = $b8f821026a6eb0fb$var$ExceptionCode.INDEX_SIZE_ERR = ($b8f821026a6eb0fb$var$ExceptionMessage[1] = \"Index size error\", 1);\nvar $b8f821026a6eb0fb$var$DOMSTRING_SIZE_ERR = $b8f821026a6eb0fb$var$ExceptionCode.DOMSTRING_SIZE_ERR = ($b8f821026a6eb0fb$var$ExceptionMessage[2] = \"DOMString size error\", 2);\nvar $b8f821026a6eb0fb$var$HIERARCHY_REQUEST_ERR = $b8f821026a6eb0fb$var$ExceptionCode.HIERARCHY_REQUEST_ERR = ($b8f821026a6eb0fb$var$ExceptionMessage[3] = \"Hierarchy request error\", 3);\nvar $b8f821026a6eb0fb$var$WRONG_DOCUMENT_ERR = $b8f821026a6eb0fb$var$ExceptionCode.WRONG_DOCUMENT_ERR = ($b8f821026a6eb0fb$var$ExceptionMessage[4] = \"Wrong document\", 4);\nvar $b8f821026a6eb0fb$var$INVALID_CHARACTER_ERR = $b8f821026a6eb0fb$var$ExceptionCode.INVALID_CHARACTER_ERR = ($b8f821026a6eb0fb$var$ExceptionMessage[5] = \"Invalid character\", 5);\nvar $b8f821026a6eb0fb$var$NO_DATA_ALLOWED_ERR = $b8f821026a6eb0fb$var$ExceptionCode.NO_DATA_ALLOWED_ERR = ($b8f821026a6eb0fb$var$ExceptionMessage[6] = \"No data allowed\", 6);\nvar $b8f821026a6eb0fb$var$NO_MODIFICATION_ALLOWED_ERR = $b8f821026a6eb0fb$var$ExceptionCode.NO_MODIFICATION_ALLOWED_ERR = ($b8f821026a6eb0fb$var$ExceptionMessage[7] = \"No modification allowed\", 7);\nvar $b8f821026a6eb0fb$var$NOT_FOUND_ERR = $b8f821026a6eb0fb$var$ExceptionCode.NOT_FOUND_ERR = ($b8f821026a6eb0fb$var$ExceptionMessage[8] = \"Not found\", 8);\nvar $b8f821026a6eb0fb$var$NOT_SUPPORTED_ERR = $b8f821026a6eb0fb$var$ExceptionCode.NOT_SUPPORTED_ERR = ($b8f821026a6eb0fb$var$ExceptionMessage[9] = \"Not supported\", 9);\nvar $b8f821026a6eb0fb$var$INUSE_ATTRIBUTE_ERR = $b8f821026a6eb0fb$var$ExceptionCode.INUSE_ATTRIBUTE_ERR = ($b8f821026a6eb0fb$var$ExceptionMessage[10] = \"Attribute in use\", 10);\n//level2\nvar $b8f821026a6eb0fb$var$INVALID_STATE_ERR = $b8f821026a6eb0fb$var$ExceptionCode.INVALID_STATE_ERR = ($b8f821026a6eb0fb$var$ExceptionMessage[11] = \"Invalid state\", 11);\nvar $b8f821026a6eb0fb$var$SYNTAX_ERR = $b8f821026a6eb0fb$var$ExceptionCode.SYNTAX_ERR = ($b8f821026a6eb0fb$var$ExceptionMessage[12] = \"Syntax error\", 12);\nvar $b8f821026a6eb0fb$var$INVALID_MODIFICATION_ERR = $b8f821026a6eb0fb$var$ExceptionCode.INVALID_MODIFICATION_ERR = ($b8f821026a6eb0fb$var$ExceptionMessage[13] = \"Invalid modification\", 13);\nvar $b8f821026a6eb0fb$var$NAMESPACE_ERR = $b8f821026a6eb0fb$var$ExceptionCode.NAMESPACE_ERR = ($b8f821026a6eb0fb$var$ExceptionMessage[14] = \"Invalid namespace\", 14);\nvar $b8f821026a6eb0fb$var$INVALID_ACCESS_ERR = $b8f821026a6eb0fb$var$ExceptionCode.INVALID_ACCESS_ERR = ($b8f821026a6eb0fb$var$ExceptionMessage[15] = \"Invalid access\", 15);\n/**\n * DOM Level 2\n * Object DOMException\n * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/ecma-script-binding.html\n * @see http://www.w3.org/TR/REC-DOM-Level-1/ecma-script-language-binding.html\n */ function $b8f821026a6eb0fb$var$DOMException(code, message) {\n if (message instanceof Error) var error = message;\n else {\n error = this;\n Error.call(this, $b8f821026a6eb0fb$var$ExceptionMessage[code]);\n this.message = $b8f821026a6eb0fb$var$ExceptionMessage[code];\n if (Error.captureStackTrace) Error.captureStackTrace(this, $b8f821026a6eb0fb$var$DOMException);\n }\n error.code = code;\n if (message) this.message = this.message + \": \" + message;\n return error;\n}\n$b8f821026a6eb0fb$var$DOMException.prototype = Error.prototype;\n$b8f821026a6eb0fb$var$copy($b8f821026a6eb0fb$var$ExceptionCode, $b8f821026a6eb0fb$var$DOMException);\n/**\n * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-536297177\n * The NodeList interface provides the abstraction of an ordered collection of nodes, without defining or constraining how this collection is implemented. NodeList objects in the DOM are live.\n * The items in the NodeList are accessible via an integral index, starting from 0.\n */ function $b8f821026a6eb0fb$var$NodeList() {}\n$b8f821026a6eb0fb$var$NodeList.prototype = {\n /**\n\t * The number of nodes in the list. The range of valid child node indices is 0 to length-1 inclusive.\n\t * @standard level1\n\t */ length: 0,\n /**\n\t * Returns the indexth item in the collection. If index is greater than or equal to the number of nodes in the list, this returns null.\n\t * @standard level1\n\t * @param index unsigned long\n\t * Index into the collection.\n\t * @return Node\n\t * \tThe node at the indexth position in the NodeList, or null if that is not a valid index.\n\t */ item: function(index) {\n return index >= 0 && index < this.length ? this[index] : null;\n },\n toString: function(isHTML, nodeFilter) {\n for(var buf = [], i = 0; i < this.length; i++)$b8f821026a6eb0fb$var$serializeToString(this[i], buf, isHTML, nodeFilter);\n return buf.join(\"\");\n },\n /**\n\t * @private\n\t * @param {function (Node):boolean} predicate\n\t * @returns {Node[]}\n\t */ filter: function(predicate) {\n return Array.prototype.filter.call(this, predicate);\n },\n /**\n\t * @private\n\t * @param {Node} item\n\t * @returns {number}\n\t */ indexOf: function(item) {\n return Array.prototype.indexOf.call(this, item);\n }\n};\nfunction $b8f821026a6eb0fb$var$LiveNodeList(node, refresh) {\n this._node = node;\n this._refresh = refresh;\n $b8f821026a6eb0fb$var$_updateLiveList(this);\n}\nfunction $b8f821026a6eb0fb$var$_updateLiveList(list) {\n var inc = list._node._inc || list._node.ownerDocument._inc;\n if (list._inc !== inc) {\n var ls = list._refresh(list._node);\n $b8f821026a6eb0fb$var$__set__(list, \"length\", ls.length);\n if (!list.$$length || ls.length < list.$$length) {\n for(var i = ls.length; (i in list); i++)if (Object.prototype.hasOwnProperty.call(list, i)) delete list[i];\n }\n $b8f821026a6eb0fb$var$copy(ls, list);\n list._inc = inc;\n }\n}\n$b8f821026a6eb0fb$var$LiveNodeList.prototype.item = function(i) {\n $b8f821026a6eb0fb$var$_updateLiveList(this);\n return this[i] || null;\n};\n$b8f821026a6eb0fb$var$_extends($b8f821026a6eb0fb$var$LiveNodeList, $b8f821026a6eb0fb$var$NodeList);\n/**\n * Objects implementing the NamedNodeMap interface are used\n * to represent collections of nodes that can be accessed by name.\n * Note that NamedNodeMap does not inherit from NodeList;\n * NamedNodeMaps are not maintained in any particular order.\n * Objects contained in an object implementing NamedNodeMap may also be accessed by an ordinal index,\n * but this is simply to allow convenient enumeration of the contents of a NamedNodeMap,\n * and does not imply that the DOM specifies an order to these Nodes.\n * NamedNodeMap objects in the DOM are live.\n * used for attributes or DocumentType entities\n */ function $b8f821026a6eb0fb$var$NamedNodeMap() {}\nfunction $b8f821026a6eb0fb$var$_findNodeIndex(list, node) {\n var i = list.length;\n while(i--){\n if (list[i] === node) return i;\n }\n}\nfunction $b8f821026a6eb0fb$var$_addNamedNode(el, list, newAttr, oldAttr) {\n if (oldAttr) list[$b8f821026a6eb0fb$var$_findNodeIndex(list, oldAttr)] = newAttr;\n else list[list.length++] = newAttr;\n if (el) {\n newAttr.ownerElement = el;\n var doc = el.ownerDocument;\n if (doc) {\n oldAttr && $b8f821026a6eb0fb$var$_onRemoveAttribute(doc, el, oldAttr);\n $b8f821026a6eb0fb$var$_onAddAttribute(doc, el, newAttr);\n }\n }\n}\nfunction $b8f821026a6eb0fb$var$_removeNamedNode(el, list, attr) {\n //console.log('remove attr:'+attr)\n var i = $b8f821026a6eb0fb$var$_findNodeIndex(list, attr);\n if (i >= 0) {\n var lastIndex = list.length - 1;\n while(i < lastIndex)list[i] = list[++i];\n list.length = lastIndex;\n if (el) {\n var doc = el.ownerDocument;\n if (doc) {\n $b8f821026a6eb0fb$var$_onRemoveAttribute(doc, el, attr);\n attr.ownerElement = null;\n }\n }\n } else throw new $b8f821026a6eb0fb$var$DOMException($b8f821026a6eb0fb$var$NOT_FOUND_ERR, new Error(el.tagName + \"@\" + attr));\n}\n$b8f821026a6eb0fb$var$NamedNodeMap.prototype = {\n length: 0,\n item: $b8f821026a6eb0fb$var$NodeList.prototype.item,\n getNamedItem: function(key) {\n //\t\tif(key.indexOf(':')>0 || key == 'xmlns'){\n //\t\t\treturn null;\n //\t\t}\n //console.log()\n var i = this.length;\n while(i--){\n var attr = this[i];\n //console.log(attr.nodeName,key)\n if (attr.nodeName == key) return attr;\n }\n },\n setNamedItem: function(attr) {\n var el = attr.ownerElement;\n if (el && el != this._ownerElement) throw new $b8f821026a6eb0fb$var$DOMException($b8f821026a6eb0fb$var$INUSE_ATTRIBUTE_ERR);\n var oldAttr = this.getNamedItem(attr.nodeName);\n $b8f821026a6eb0fb$var$_addNamedNode(this._ownerElement, this, attr, oldAttr);\n return oldAttr;\n },\n /* returns Node */ setNamedItemNS: function(attr) {\n var el = attr.ownerElement, oldAttr;\n if (el && el != this._ownerElement) throw new $b8f821026a6eb0fb$var$DOMException($b8f821026a6eb0fb$var$INUSE_ATTRIBUTE_ERR);\n oldAttr = this.getNamedItemNS(attr.namespaceURI, attr.localName);\n $b8f821026a6eb0fb$var$_addNamedNode(this._ownerElement, this, attr, oldAttr);\n return oldAttr;\n },\n /* returns Node */ removeNamedItem: function(key) {\n var attr = this.getNamedItem(key);\n $b8f821026a6eb0fb$var$_removeNamedNode(this._ownerElement, this, attr);\n return attr;\n },\n //for level2\n removeNamedItemNS: function(namespaceURI, localName) {\n var attr = this.getNamedItemNS(namespaceURI, localName);\n $b8f821026a6eb0fb$var$_removeNamedNode(this._ownerElement, this, attr);\n return attr;\n },\n getNamedItemNS: function(namespaceURI, localName) {\n var i = this.length;\n while(i--){\n var node = this[i];\n if (node.localName == localName && node.namespaceURI == namespaceURI) return node;\n }\n return null;\n }\n};\n/**\n * The DOMImplementation interface represents an object providing methods\n * which are not dependent on any particular document.\n * Such an object is returned by the `Document.implementation` property.\n *\n * __The individual methods describe the differences compared to the specs.__\n *\n * @constructor\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation MDN\n * @see https://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-102161490 DOM Level 1 Core (Initial)\n * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-102161490 DOM Level 2 Core\n * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-102161490 DOM Level 3 Core\n * @see https://dom.spec.whatwg.org/#domimplementation DOM Living Standard\n */ function $b8f821026a6eb0fb$var$DOMImplementation() {}\n$b8f821026a6eb0fb$var$DOMImplementation.prototype = {\n /**\n\t * The DOMImplementation.hasFeature() method returns a Boolean flag indicating if a given feature is supported.\n\t * The different implementations fairly diverged in what kind of features were reported.\n\t * The latest version of the spec settled to force this method to always return true, where the functionality was accurate and in use.\n\t *\n\t * @deprecated It is deprecated and modern browsers return true in all cases.\n\t *\n\t * @param {string} feature\n\t * @param {string} [version]\n\t * @returns {boolean} always true\n\t *\n\t * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/hasFeature MDN\n\t * @see https://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-5CED94D7 DOM Level 1 Core\n\t * @see https://dom.spec.whatwg.org/#dom-domimplementation-hasfeature DOM Living Standard\n\t */ hasFeature: function(feature, version) {\n return true;\n },\n /**\n\t * Creates an XML Document object of the specified type with its document element.\n\t *\n\t * __It behaves slightly different from the description in the living standard__:\n\t * - There is no interface/class `XMLDocument`, it returns a `Document` instance.\n\t * - `contentType`, `encoding`, `mode`, `origin`, `url` fields are currently not declared.\n\t * - this implementation is not validating names or qualified names\n\t * (when parsing XML strings, the SAX parser takes care of that)\n\t *\n\t * @param {string|null} namespaceURI\n\t * @param {string} qualifiedName\n\t * @param {DocumentType=null} doctype\n\t * @returns {Document}\n\t *\n\t * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocument MDN\n\t * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocument DOM Level 2 Core (initial)\n\t * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument DOM Level 2 Core\n\t *\n\t * @see https://dom.spec.whatwg.org/#validate-and-extract DOM: Validate and extract\n\t * @see https://www.w3.org/TR/xml/#NT-NameStartChar XML Spec: Names\n\t * @see https://www.w3.org/TR/xml-names/#ns-qualnames XML Namespaces: Qualified names\n\t */ createDocument: function(namespaceURI, qualifiedName, doctype) {\n var doc = new $b8f821026a6eb0fb$var$Document();\n doc.implementation = this;\n doc.childNodes = new $b8f821026a6eb0fb$var$NodeList();\n doc.doctype = doctype || null;\n if (doctype) doc.appendChild(doctype);\n if (qualifiedName) {\n var root = doc.createElementNS(namespaceURI, qualifiedName);\n doc.appendChild(root);\n }\n return doc;\n },\n /**\n\t * Returns a doctype, with the given `qualifiedName`, `publicId`, and `systemId`.\n\t *\n\t * __This behavior is slightly different from the in the specs__:\n\t * - this implementation is not validating names or qualified names\n\t * (when parsing XML strings, the SAX parser takes care of that)\n\t *\n\t * @param {string} qualifiedName\n\t * @param {string} [publicId]\n\t * @param {string} [systemId]\n\t * @returns {DocumentType} which can either be used with `DOMImplementation.createDocument` upon document creation\n\t * \t\t\t\t or can be put into the document via methods like `Node.insertBefore()` or `Node.replaceChild()`\n\t *\n\t * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocumentType MDN\n\t * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocType DOM Level 2 Core\n\t * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocumenttype DOM Living Standard\n\t *\n\t * @see https://dom.spec.whatwg.org/#validate-and-extract DOM: Validate and extract\n\t * @see https://www.w3.org/TR/xml/#NT-NameStartChar XML Spec: Names\n\t * @see https://www.w3.org/TR/xml-names/#ns-qualnames XML Namespaces: Qualified names\n\t */ createDocumentType: function(qualifiedName, publicId, systemId) {\n var node = new $b8f821026a6eb0fb$var$DocumentType();\n node.name = qualifiedName;\n node.nodeName = qualifiedName;\n node.publicId = publicId || \"\";\n node.systemId = systemId || \"\";\n return node;\n }\n};\n/**\n * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-1950641247\n */ function $b8f821026a6eb0fb$var$Node() {}\n$b8f821026a6eb0fb$var$Node.prototype = {\n firstChild: null,\n lastChild: null,\n previousSibling: null,\n nextSibling: null,\n attributes: null,\n parentNode: null,\n childNodes: null,\n ownerDocument: null,\n nodeValue: null,\n namespaceURI: null,\n prefix: null,\n localName: null,\n // Modified in DOM Level 2:\n insertBefore: function(newChild, refChild) {\n return $b8f821026a6eb0fb$var$_insertBefore(this, newChild, refChild);\n },\n replaceChild: function(newChild, oldChild) {\n $b8f821026a6eb0fb$var$_insertBefore(this, newChild, oldChild, $b8f821026a6eb0fb$var$assertPreReplacementValidityInDocument);\n if (oldChild) this.removeChild(oldChild);\n },\n removeChild: function(oldChild) {\n return $b8f821026a6eb0fb$var$_removeChild(this, oldChild);\n },\n appendChild: function(newChild) {\n return this.insertBefore(newChild, null);\n },\n hasChildNodes: function() {\n return this.firstChild != null;\n },\n cloneNode: function(deep) {\n return $b8f821026a6eb0fb$var$cloneNode(this.ownerDocument || this, this, deep);\n },\n // Modified in DOM Level 2:\n normalize: function() {\n var child = this.firstChild;\n while(child){\n var next = child.nextSibling;\n if (next && next.nodeType == $b8f821026a6eb0fb$var$TEXT_NODE && child.nodeType == $b8f821026a6eb0fb$var$TEXT_NODE) {\n this.removeChild(next);\n child.appendData(next.data);\n } else {\n child.normalize();\n child = next;\n }\n }\n },\n // Introduced in DOM Level 2:\n isSupported: function(feature, version) {\n return this.ownerDocument.implementation.hasFeature(feature, version);\n },\n // Introduced in DOM Level 2:\n hasAttributes: function() {\n return this.attributes.length > 0;\n },\n /**\n\t * Look up the prefix associated to the given namespace URI, starting from this node.\n\t * **The default namespace declarations are ignored by this method.**\n\t * See Namespace Prefix Lookup for details on the algorithm used by this method.\n\t *\n\t * _Note: The implementation seems to be incomplete when compared to the algorithm described in the specs._\n\t *\n\t * @param {string | null} namespaceURI\n\t * @returns {string | null}\n\t * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-lookupNamespacePrefix\n\t * @see https://www.w3.org/TR/DOM-Level-3-Core/namespaces-algorithms.html#lookupNamespacePrefixAlgo\n\t * @see https://dom.spec.whatwg.org/#dom-node-lookupprefix\n\t * @see https://github.com/xmldom/xmldom/issues/322\n\t */ lookupPrefix: function(namespaceURI) {\n var el = this;\n while(el){\n var map = el._nsMap;\n //console.dir(map)\n if (map) for(var n in map){\n if (Object.prototype.hasOwnProperty.call(map, n) && map[n] === namespaceURI) return n;\n }\n el = el.nodeType == $b8f821026a6eb0fb$var$ATTRIBUTE_NODE ? el.ownerDocument : el.parentNode;\n }\n return null;\n },\n // Introduced in DOM Level 3:\n lookupNamespaceURI: function(prefix) {\n var el = this;\n while(el){\n var map = el._nsMap;\n //console.dir(map)\n if (map) {\n if (Object.prototype.hasOwnProperty.call(map, prefix)) return map[prefix];\n }\n el = el.nodeType == $b8f821026a6eb0fb$var$ATTRIBUTE_NODE ? el.ownerDocument : el.parentNode;\n }\n return null;\n },\n // Introduced in DOM Level 3:\n isDefaultNamespace: function(namespaceURI) {\n var prefix = this.lookupPrefix(namespaceURI);\n return prefix == null;\n }\n};\nfunction $b8f821026a6eb0fb$var$_xmlEncoder(c) {\n return c == \"<\" && \"<\" || c == \">\" && \">\" || c == \"&\" && \"&\" || c == '\"' && \""\" || \"&#\" + c.charCodeAt() + \";\";\n}\n$b8f821026a6eb0fb$var$copy($b8f821026a6eb0fb$var$NodeType, $b8f821026a6eb0fb$var$Node);\n$b8f821026a6eb0fb$var$copy($b8f821026a6eb0fb$var$NodeType, $b8f821026a6eb0fb$var$Node.prototype);\n/**\n * @param callback return true for continue,false for break\n * @return boolean true: break visit;\n */ function $b8f821026a6eb0fb$var$_visitNode(node, callback) {\n if (callback(node)) return true;\n if (node = node.firstChild) do {\n if ($b8f821026a6eb0fb$var$_visitNode(node, callback)) return true;\n }while (node = node.nextSibling);\n}\nfunction $b8f821026a6eb0fb$var$Document() {\n this.ownerDocument = this;\n}\nfunction $b8f821026a6eb0fb$var$_onAddAttribute(doc, el, newAttr) {\n doc && doc._inc++;\n var ns = newAttr.namespaceURI;\n if (ns === $b8f821026a6eb0fb$var$NAMESPACE.XMLNS) //update namespace\n el._nsMap[newAttr.prefix ? newAttr.localName : \"\"] = newAttr.value;\n}\nfunction $b8f821026a6eb0fb$var$_onRemoveAttribute(doc, el, newAttr, remove) {\n doc && doc._inc++;\n var ns = newAttr.namespaceURI;\n if (ns === $b8f821026a6eb0fb$var$NAMESPACE.XMLNS) //update namespace\n delete el._nsMap[newAttr.prefix ? newAttr.localName : \"\"];\n}\n/**\n * Updates `el.childNodes`, updating the indexed items and it's `length`.\n * Passing `newChild` means it will be appended.\n * Otherwise it's assumed that an item has been removed,\n * and `el.firstNode` and it's `.nextSibling` are used\n * to walk the current list of child nodes.\n *\n * @param {Document} doc\n * @param {Node} el\n * @param {Node} [newChild]\n * @private\n */ function $b8f821026a6eb0fb$var$_onUpdateChild(doc, el, newChild) {\n if (doc && doc._inc) {\n doc._inc++;\n //update childNodes\n var cs = el.childNodes;\n if (newChild) cs[cs.length++] = newChild;\n else {\n var child = el.firstChild;\n var i = 0;\n while(child){\n cs[i++] = child;\n child = child.nextSibling;\n }\n cs.length = i;\n delete cs[cs.length];\n }\n }\n}\n/**\n * Removes the connections between `parentNode` and `child`\n * and any existing `child.previousSibling` or `child.nextSibling`.\n *\n * @see https://github.com/xmldom/xmldom/issues/135\n * @see https://github.com/xmldom/xmldom/issues/145\n *\n * @param {Node} parentNode\n * @param {Node} child\n * @returns {Node} the child that was removed.\n * @private\n */ function $b8f821026a6eb0fb$var$_removeChild(parentNode, child) {\n var previous = child.previousSibling;\n var next = child.nextSibling;\n if (previous) previous.nextSibling = next;\n else parentNode.firstChild = next;\n if (next) next.previousSibling = previous;\n else parentNode.lastChild = previous;\n child.parentNode = null;\n child.previousSibling = null;\n child.nextSibling = null;\n $b8f821026a6eb0fb$var$_onUpdateChild(parentNode.ownerDocument, parentNode);\n return child;\n}\n/**\n * Returns `true` if `node` can be a parent for insertion.\n * @param {Node} node\n * @returns {boolean}\n */ function $b8f821026a6eb0fb$var$hasValidParentNodeType(node) {\n return node && (node.nodeType === $b8f821026a6eb0fb$var$Node.DOCUMENT_NODE || node.nodeType === $b8f821026a6eb0fb$var$Node.DOCUMENT_FRAGMENT_NODE || node.nodeType === $b8f821026a6eb0fb$var$Node.ELEMENT_NODE);\n}\n/**\n * Returns `true` if `node` can be inserted according to it's `nodeType`.\n * @param {Node} node\n * @returns {boolean}\n */ function $b8f821026a6eb0fb$var$hasInsertableNodeType(node) {\n return node && ($b8f821026a6eb0fb$var$isElementNode(node) || $b8f821026a6eb0fb$var$isTextNode(node) || $b8f821026a6eb0fb$var$isDocTypeNode(node) || node.nodeType === $b8f821026a6eb0fb$var$Node.DOCUMENT_FRAGMENT_NODE || node.nodeType === $b8f821026a6eb0fb$var$Node.COMMENT_NODE || node.nodeType === $b8f821026a6eb0fb$var$Node.PROCESSING_INSTRUCTION_NODE);\n}\n/**\n * Returns true if `node` is a DOCTYPE node\n * @param {Node} node\n * @returns {boolean}\n */ function $b8f821026a6eb0fb$var$isDocTypeNode(node) {\n return node && node.nodeType === $b8f821026a6eb0fb$var$Node.DOCUMENT_TYPE_NODE;\n}\n/**\n * Returns true if the node is an element\n * @param {Node} node\n * @returns {boolean}\n */ function $b8f821026a6eb0fb$var$isElementNode(node) {\n return node && node.nodeType === $b8f821026a6eb0fb$var$Node.ELEMENT_NODE;\n}\n/**\n * Returns true if `node` is a text node\n * @param {Node} node\n * @returns {boolean}\n */ function $b8f821026a6eb0fb$var$isTextNode(node) {\n return node && node.nodeType === $b8f821026a6eb0fb$var$Node.TEXT_NODE;\n}\n/**\n * Check if en element node can be inserted before `child`, or at the end if child is falsy,\n * according to the presence and position of a doctype node on the same level.\n *\n * @param {Document} doc The document node\n * @param {Node} child the node that would become the nextSibling if the element would be inserted\n * @returns {boolean} `true` if an element can be inserted before child\n * @private\n * https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity\n */ function $b8f821026a6eb0fb$var$isElementInsertionPossible(doc, child) {\n var parentChildNodes = doc.childNodes || [];\n if ($b8f821026a6eb0fb$var$find(parentChildNodes, $b8f821026a6eb0fb$var$isElementNode) || $b8f821026a6eb0fb$var$isDocTypeNode(child)) return false;\n var docTypeNode = $b8f821026a6eb0fb$var$find(parentChildNodes, $b8f821026a6eb0fb$var$isDocTypeNode);\n return !(child && docTypeNode && parentChildNodes.indexOf(docTypeNode) > parentChildNodes.indexOf(child));\n}\n/**\n * Check if en element node can be inserted before `child`, or at the end if child is falsy,\n * according to the presence and position of a doctype node on the same level.\n *\n * @param {Node} doc The document node\n * @param {Node} child the node that would become the nextSibling if the element would be inserted\n * @returns {boolean} `true` if an element can be inserted before child\n * @private\n * https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity\n */ function $b8f821026a6eb0fb$var$isElementReplacementPossible(doc, child) {\n var parentChildNodes = doc.childNodes || [];\n function hasElementChildThatIsNotChild(node) {\n return $b8f821026a6eb0fb$var$isElementNode(node) && node !== child;\n }\n if ($b8f821026a6eb0fb$var$find(parentChildNodes, hasElementChildThatIsNotChild)) return false;\n var docTypeNode = $b8f821026a6eb0fb$var$find(parentChildNodes, $b8f821026a6eb0fb$var$isDocTypeNode);\n return !(child && docTypeNode && parentChildNodes.indexOf(docTypeNode) > parentChildNodes.indexOf(child));\n}\n/**\n * @private\n * Steps 1-5 of the checks before inserting and before replacing a child are the same.\n *\n * @param {Node} parent the parent node to insert `node` into\n * @param {Node} node the node to insert\n * @param {Node=} child the node that should become the `nextSibling` of `node`\n * @returns {Node}\n * @throws DOMException for several node combinations that would create a DOM that is not well-formed.\n * @throws DOMException if `child` is provided but is not a child of `parent`.\n * @see https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity\n * @see https://dom.spec.whatwg.org/#concept-node-replace\n */ function $b8f821026a6eb0fb$var$assertPreInsertionValidity1to5(parent, node, child) {\n // 1. If `parent` is not a Document, DocumentFragment, or Element node, then throw a \"HierarchyRequestError\" DOMException.\n if (!$b8f821026a6eb0fb$var$hasValidParentNodeType(parent)) throw new $b8f821026a6eb0fb$var$DOMException($b8f821026a6eb0fb$var$HIERARCHY_REQUEST_ERR, \"Unexpected parent node type \" + parent.nodeType);\n // 2. If `node` is a host-including inclusive ancestor of `parent`, then throw a \"HierarchyRequestError\" DOMException.\n // not implemented!\n // 3. If `child` is non-null and its parent is not `parent`, then throw a \"NotFoundError\" DOMException.\n if (child && child.parentNode !== parent) throw new $b8f821026a6eb0fb$var$DOMException($b8f821026a6eb0fb$var$NOT_FOUND_ERR, \"child not in parent\");\n if (// 4. If `node` is not a DocumentFragment, DocumentType, Element, or CharacterData node, then throw a \"HierarchyRequestError\" DOMException.\n !$b8f821026a6eb0fb$var$hasInsertableNodeType(node) || // 5. If either `node` is a Text node and `parent` is a document,\n // the sax parser currently adds top level text nodes, this will be fixed in 0.9.0\n // || (node.nodeType === Node.TEXT_NODE && parent.nodeType === Node.DOCUMENT_NODE)\n // or `node` is a doctype and `parent` is not a document, then throw a \"HierarchyRequestError\" DOMException.\n $b8f821026a6eb0fb$var$isDocTypeNode(node) && parent.nodeType !== $b8f821026a6eb0fb$var$Node.DOCUMENT_NODE) throw new $b8f821026a6eb0fb$var$DOMException($b8f821026a6eb0fb$var$HIERARCHY_REQUEST_ERR, \"Unexpected node type \" + node.nodeType + \" for parent node type \" + parent.nodeType);\n}\n/**\n * @private\n * Step 6 of the checks before inserting and before replacing a child are different.\n *\n * @param {Document} parent the parent node to insert `node` into\n * @param {Node} node the node to insert\n * @param {Node | undefined} child the node that should become the `nextSibling` of `node`\n * @returns {Node}\n * @throws DOMException for several node combinations that would create a DOM that is not well-formed.\n * @throws DOMException if `child` is provided but is not a child of `parent`.\n * @see https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity\n * @see https://dom.spec.whatwg.org/#concept-node-replace\n */ function $b8f821026a6eb0fb$var$assertPreInsertionValidityInDocument(parent, node, child) {\n var parentChildNodes = parent.childNodes || [];\n var nodeChildNodes = node.childNodes || [];\n // DocumentFragment\n if (node.nodeType === $b8f821026a6eb0fb$var$Node.DOCUMENT_FRAGMENT_NODE) {\n var nodeChildElements = nodeChildNodes.filter($b8f821026a6eb0fb$var$isElementNode);\n // If node has more than one element child or has a Text node child.\n if (nodeChildElements.length > 1 || $b8f821026a6eb0fb$var$find(nodeChildNodes, $b8f821026a6eb0fb$var$isTextNode)) throw new $b8f821026a6eb0fb$var$DOMException($b8f821026a6eb0fb$var$HIERARCHY_REQUEST_ERR, \"More than one element or text in fragment\");\n // Otherwise, if `node` has one element child and either `parent` has an element child,\n // `child` is a doctype, or `child` is non-null and a doctype is following `child`.\n if (nodeChildElements.length === 1 && !$b8f821026a6eb0fb$var$isElementInsertionPossible(parent, child)) throw new $b8f821026a6eb0fb$var$DOMException($b8f821026a6eb0fb$var$HIERARCHY_REQUEST_ERR, \"Element in fragment can not be inserted before doctype\");\n }\n // Element\n if ($b8f821026a6eb0fb$var$isElementNode(node)) {\n // `parent` has an element child, `child` is a doctype,\n // or `child` is non-null and a doctype is following `child`.\n if (!$b8f821026a6eb0fb$var$isElementInsertionPossible(parent, child)) throw new $b8f821026a6eb0fb$var$DOMException($b8f821026a6eb0fb$var$HIERARCHY_REQUEST_ERR, \"Only one element can be added and only after doctype\");\n }\n // DocumentType\n if ($b8f821026a6eb0fb$var$isDocTypeNode(node)) {\n // `parent` has a doctype child,\n if ($b8f821026a6eb0fb$var$find(parentChildNodes, $b8f821026a6eb0fb$var$isDocTypeNode)) throw new $b8f821026a6eb0fb$var$DOMException($b8f821026a6eb0fb$var$HIERARCHY_REQUEST_ERR, \"Only one doctype is allowed\");\n var parentElementChild = $b8f821026a6eb0fb$var$find(parentChildNodes, $b8f821026a6eb0fb$var$isElementNode);\n // `child` is non-null and an element is preceding `child`,\n if (child && parentChildNodes.indexOf(parentElementChild) < parentChildNodes.indexOf(child)) throw new $b8f821026a6eb0fb$var$DOMException($b8f821026a6eb0fb$var$HIERARCHY_REQUEST_ERR, \"Doctype can only be inserted before an element\");\n // or `child` is null and `parent` has an element child.\n if (!child && parentElementChild) throw new $b8f821026a6eb0fb$var$DOMException($b8f821026a6eb0fb$var$HIERARCHY_REQUEST_ERR, \"Doctype can not be appended since element is present\");\n }\n}\n/**\n * @private\n * Step 6 of the checks before inserting and before replacing a child are different.\n *\n * @param {Document} parent the parent node to insert `node` into\n * @param {Node} node the node to insert\n * @param {Node | undefined} child the node that should become the `nextSibling` of `node`\n * @returns {Node}\n * @throws DOMException for several node combinations that would create a DOM that is not well-formed.\n * @throws DOMException if `child` is provided but is not a child of `parent`.\n * @see https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity\n * @see https://dom.spec.whatwg.org/#concept-node-replace\n */ function $b8f821026a6eb0fb$var$assertPreReplacementValidityInDocument(parent, node, child) {\n var parentChildNodes = parent.childNodes || [];\n var nodeChildNodes = node.childNodes || [];\n // DocumentFragment\n if (node.nodeType === $b8f821026a6eb0fb$var$Node.DOCUMENT_FRAGMENT_NODE) {\n var nodeChildElements = nodeChildNodes.filter($b8f821026a6eb0fb$var$isElementNode);\n // If `node` has more than one element child or has a Text node child.\n if (nodeChildElements.length > 1 || $b8f821026a6eb0fb$var$find(nodeChildNodes, $b8f821026a6eb0fb$var$isTextNode)) throw new $b8f821026a6eb0fb$var$DOMException($b8f821026a6eb0fb$var$HIERARCHY_REQUEST_ERR, \"More than one element or text in fragment\");\n // Otherwise, if `node` has one element child and either `parent` has an element child that is not `child` or a doctype is following `child`.\n if (nodeChildElements.length === 1 && !$b8f821026a6eb0fb$var$isElementReplacementPossible(parent, child)) throw new $b8f821026a6eb0fb$var$DOMException($b8f821026a6eb0fb$var$HIERARCHY_REQUEST_ERR, \"Element in fragment can not be inserted before doctype\");\n }\n // Element\n if ($b8f821026a6eb0fb$var$isElementNode(node)) {\n // `parent` has an element child that is not `child` or a doctype is following `child`.\n if (!$b8f821026a6eb0fb$var$isElementReplacementPossible(parent, child)) throw new $b8f821026a6eb0fb$var$DOMException($b8f821026a6eb0fb$var$HIERARCHY_REQUEST_ERR, \"Only one element can be added and only after doctype\");\n }\n // DocumentType\n if ($b8f821026a6eb0fb$var$isDocTypeNode(node)) {\n function hasDoctypeChildThatIsNotChild(node) {\n return $b8f821026a6eb0fb$var$isDocTypeNode(node) && node !== child;\n }\n // `parent` has a doctype child that is not `child`,\n if ($b8f821026a6eb0fb$var$find(parentChildNodes, hasDoctypeChildThatIsNotChild)) throw new $b8f821026a6eb0fb$var$DOMException($b8f821026a6eb0fb$var$HIERARCHY_REQUEST_ERR, \"Only one doctype is allowed\");\n var parentElementChild = $b8f821026a6eb0fb$var$find(parentChildNodes, $b8f821026a6eb0fb$var$isElementNode);\n // or an element is preceding `child`.\n if (child && parentChildNodes.indexOf(parentElementChild) < parentChildNodes.indexOf(child)) throw new $b8f821026a6eb0fb$var$DOMException($b8f821026a6eb0fb$var$HIERARCHY_REQUEST_ERR, \"Doctype can only be inserted before an element\");\n }\n}\n/**\n * @private\n * @param {Node} parent the parent node to insert `node` into\n * @param {Node} node the node to insert\n * @param {Node=} child the node that should become the `nextSibling` of `node`\n * @returns {Node}\n * @throws DOMException for several node combinations that would create a DOM that is not well-formed.\n * @throws DOMException if `child` is provided but is not a child of `parent`.\n * @see https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity\n */ function $b8f821026a6eb0fb$var$_insertBefore(parent, node, child, _inDocumentAssertion) {\n // To ensure pre-insertion validity of a node into a parent before a child, run these steps:\n $b8f821026a6eb0fb$var$assertPreInsertionValidity1to5(parent, node, child);\n // If parent is a document, and any of the statements below, switched on the interface node implements,\n // are true, then throw a \"HierarchyRequestError\" DOMException.\n if (parent.nodeType === $b8f821026a6eb0fb$var$Node.DOCUMENT_NODE) (_inDocumentAssertion || $b8f821026a6eb0fb$var$assertPreInsertionValidityInDocument)(parent, node, child);\n var cp = node.parentNode;\n if (cp) cp.removeChild(node); //remove and update\n if (node.nodeType === $b8f821026a6eb0fb$var$DOCUMENT_FRAGMENT_NODE) {\n var newFirst = node.firstChild;\n if (newFirst == null) return node;\n var newLast = node.lastChild;\n } else newFirst = newLast = node;\n var pre = child ? child.previousSibling : parent.lastChild;\n newFirst.previousSibling = pre;\n newLast.nextSibling = child;\n if (pre) pre.nextSibling = newFirst;\n else parent.firstChild = newFirst;\n if (child == null) parent.lastChild = newLast;\n else child.previousSibling = newLast;\n do newFirst.parentNode = parent;\n while (newFirst !== newLast && (newFirst = newFirst.nextSibling));\n $b8f821026a6eb0fb$var$_onUpdateChild(parent.ownerDocument || parent, parent);\n //console.log(parent.lastChild.nextSibling == null)\n if (node.nodeType == $b8f821026a6eb0fb$var$DOCUMENT_FRAGMENT_NODE) node.firstChild = node.lastChild = null;\n return node;\n}\n/**\n * Appends `newChild` to `parentNode`.\n * If `newChild` is already connected to a `parentNode` it is first removed from it.\n *\n * @see https://github.com/xmldom/xmldom/issues/135\n * @see https://github.com/xmldom/xmldom/issues/145\n * @param {Node} parentNode\n * @param {Node} newChild\n * @returns {Node}\n * @private\n */ function $b8f821026a6eb0fb$var$_appendSingleChild(parentNode, newChild) {\n if (newChild.parentNode) newChild.parentNode.removeChild(newChild);\n newChild.parentNode = parentNode;\n newChild.previousSibling = parentNode.lastChild;\n newChild.nextSibling = null;\n if (newChild.previousSibling) newChild.previousSibling.nextSibling = newChild;\n else parentNode.firstChild = newChild;\n parentNode.lastChild = newChild;\n $b8f821026a6eb0fb$var$_onUpdateChild(parentNode.ownerDocument, parentNode, newChild);\n return newChild;\n}\n$b8f821026a6eb0fb$var$Document.prototype = {\n //implementation : null,\n nodeName: \"#document\",\n nodeType: $b8f821026a6eb0fb$var$DOCUMENT_NODE,\n /**\n\t * The DocumentType node of the document.\n\t *\n\t * @readonly\n\t * @type DocumentType\n\t */ doctype: null,\n documentElement: null,\n _inc: 1,\n insertBefore: function(newChild, refChild) {\n if (newChild.nodeType == $b8f821026a6eb0fb$var$DOCUMENT_FRAGMENT_NODE) {\n var child = newChild.firstChild;\n while(child){\n var next = child.nextSibling;\n this.insertBefore(child, refChild);\n child = next;\n }\n return newChild;\n }\n $b8f821026a6eb0fb$var$_insertBefore(this, newChild, refChild);\n newChild.ownerDocument = this;\n if (this.documentElement === null && newChild.nodeType === $b8f821026a6eb0fb$var$ELEMENT_NODE) this.documentElement = newChild;\n return newChild;\n },\n removeChild: function(oldChild) {\n if (this.documentElement == oldChild) this.documentElement = null;\n return $b8f821026a6eb0fb$var$_removeChild(this, oldChild);\n },\n replaceChild: function(newChild, oldChild) {\n //raises\n $b8f821026a6eb0fb$var$_insertBefore(this, newChild, oldChild, $b8f821026a6eb0fb$var$assertPreReplacementValidityInDocument);\n newChild.ownerDocument = this;\n if (oldChild) this.removeChild(oldChild);\n if ($b8f821026a6eb0fb$var$isElementNode(newChild)) this.documentElement = newChild;\n },\n // Introduced in DOM Level 2:\n importNode: function(importedNode, deep) {\n return $b8f821026a6eb0fb$var$importNode(this, importedNode, deep);\n },\n // Introduced in DOM Level 2:\n getElementById: function(id) {\n var rtv = null;\n $b8f821026a6eb0fb$var$_visitNode(this.documentElement, function(node) {\n if (node.nodeType == $b8f821026a6eb0fb$var$ELEMENT_NODE) {\n if (node.getAttribute(\"id\") == id) {\n rtv = node;\n return true;\n }\n }\n });\n return rtv;\n },\n /**\n\t * The `getElementsByClassName` method of `Document` interface returns an array-like object\n\t * of all child elements which have **all** of the given class name(s).\n\t *\n\t * Returns an empty list if `classeNames` is an empty string or only contains HTML white space characters.\n\t *\n\t *\n\t * Warning: This is a live LiveNodeList.\n\t * Changes in the DOM will reflect in the array as the changes occur.\n\t * If an element selected by this array no longer qualifies for the selector,\n\t * it will automatically be removed. Be aware of this for iteration purposes.\n\t *\n\t * @param {string} classNames is a string representing the class name(s) to match; multiple class names are separated by (ASCII-)whitespace\n\t *\n\t * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/getElementsByClassName\n\t * @see https://dom.spec.whatwg.org/#concept-getelementsbyclassname\n\t */ getElementsByClassName: function(classNames) {\n var classNamesSet = $b8f821026a6eb0fb$var$toOrderedSet(classNames);\n return new $b8f821026a6eb0fb$var$LiveNodeList(this, function(base) {\n var ls = [];\n if (classNamesSet.length > 0) $b8f821026a6eb0fb$var$_visitNode(base.documentElement, function(node) {\n if (node !== base && node.nodeType === $b8f821026a6eb0fb$var$ELEMENT_NODE) {\n var nodeClassNames = node.getAttribute(\"class\");\n // can be null if the attribute does not exist\n if (nodeClassNames) {\n // before splitting and iterating just compare them for the most common case\n var matches = classNames === nodeClassNames;\n if (!matches) {\n var nodeClassNamesSet = $b8f821026a6eb0fb$var$toOrderedSet(nodeClassNames);\n matches = classNamesSet.every($b8f821026a6eb0fb$var$arrayIncludes(nodeClassNamesSet));\n }\n if (matches) ls.push(node);\n }\n }\n });\n return ls;\n });\n },\n //document factory method:\n createElement: function(tagName) {\n var node = new $b8f821026a6eb0fb$var$Element();\n node.ownerDocument = this;\n node.nodeName = tagName;\n node.tagName = tagName;\n node.localName = tagName;\n node.childNodes = new $b8f821026a6eb0fb$var$NodeList();\n var attrs = node.attributes = new $b8f821026a6eb0fb$var$NamedNodeMap();\n attrs._ownerElement = node;\n return node;\n },\n createDocumentFragment: function() {\n var node = new $b8f821026a6eb0fb$var$DocumentFragment();\n node.ownerDocument = this;\n node.childNodes = new $b8f821026a6eb0fb$var$NodeList();\n return node;\n },\n createTextNode: function(data) {\n var node = new $b8f821026a6eb0fb$var$Text();\n node.ownerDocument = this;\n node.appendData(data);\n return node;\n },\n createComment: function(data) {\n var node = new $b8f821026a6eb0fb$var$Comment();\n node.ownerDocument = this;\n node.appendData(data);\n return node;\n },\n createCDATASection: function(data) {\n var node = new $b8f821026a6eb0fb$var$CDATASection();\n node.ownerDocument = this;\n node.appendData(data);\n return node;\n },\n createProcessingInstruction: function(target, data) {\n var node = new $b8f821026a6eb0fb$var$ProcessingInstruction();\n node.ownerDocument = this;\n node.tagName = node.nodeName = node.target = target;\n node.nodeValue = node.data = data;\n return node;\n },\n createAttribute: function(name) {\n var node = new $b8f821026a6eb0fb$var$Attr();\n node.ownerDocument = this;\n node.name = name;\n node.nodeName = name;\n node.localName = name;\n node.specified = true;\n return node;\n },\n createEntityReference: function(name) {\n var node = new $b8f821026a6eb0fb$var$EntityReference();\n node.ownerDocument = this;\n node.nodeName = name;\n return node;\n },\n // Introduced in DOM Level 2:\n createElementNS: function(namespaceURI, qualifiedName) {\n var node = new $b8f821026a6eb0fb$var$Element();\n var pl = qualifiedName.split(\":\");\n var attrs = node.attributes = new $b8f821026a6eb0fb$var$NamedNodeMap();\n node.childNodes = new $b8f821026a6eb0fb$var$NodeList();\n node.ownerDocument = this;\n node.nodeName = qualifiedName;\n node.tagName = qualifiedName;\n node.namespaceURI = namespaceURI;\n if (pl.length == 2) {\n node.prefix = pl[0];\n node.localName = pl[1];\n } else //el.prefix = null;\n node.localName = qualifiedName;\n attrs._ownerElement = node;\n return node;\n },\n // Introduced in DOM Level 2:\n createAttributeNS: function(namespaceURI, qualifiedName) {\n var node = new $b8f821026a6eb0fb$var$Attr();\n var pl = qualifiedName.split(\":\");\n node.ownerDocument = this;\n node.nodeName = qualifiedName;\n node.name = qualifiedName;\n node.namespaceURI = namespaceURI;\n node.specified = true;\n if (pl.length == 2) {\n node.prefix = pl[0];\n node.localName = pl[1];\n } else //el.prefix = null;\n node.localName = qualifiedName;\n return node;\n }\n};\n$b8f821026a6eb0fb$var$_extends($b8f821026a6eb0fb$var$Document, $b8f821026a6eb0fb$var$Node);\nfunction $b8f821026a6eb0fb$var$Element() {\n this._nsMap = {};\n}\n$b8f821026a6eb0fb$var$Element.prototype = {\n nodeType: $b8f821026a6eb0fb$var$ELEMENT_NODE,\n hasAttribute: function(name) {\n return this.getAttributeNode(name) != null;\n },\n getAttribute: function(name) {\n var attr = this.getAttributeNode(name);\n return attr && attr.value || \"\";\n },\n getAttributeNode: function(name) {\n return this.attributes.getNamedItem(name);\n },\n setAttribute: function(name, value) {\n var attr = this.ownerDocument.createAttribute(name);\n attr.value = attr.nodeValue = \"\" + value;\n this.setAttributeNode(attr);\n },\n removeAttribute: function(name) {\n var attr = this.getAttributeNode(name);\n attr && this.removeAttributeNode(attr);\n },\n //four real opeartion method\n appendChild: function(newChild) {\n if (newChild.nodeType === $b8f821026a6eb0fb$var$DOCUMENT_FRAGMENT_NODE) return this.insertBefore(newChild, null);\n else return $b8f821026a6eb0fb$var$_appendSingleChild(this, newChild);\n },\n setAttributeNode: function(newAttr) {\n return this.attributes.setNamedItem(newAttr);\n },\n setAttributeNodeNS: function(newAttr) {\n return this.attributes.setNamedItemNS(newAttr);\n },\n removeAttributeNode: function(oldAttr) {\n //console.log(this == oldAttr.ownerElement)\n return this.attributes.removeNamedItem(oldAttr.nodeName);\n },\n //get real attribute name,and remove it by removeAttributeNode\n removeAttributeNS: function(namespaceURI, localName) {\n var old = this.getAttributeNodeNS(namespaceURI, localName);\n old && this.removeAttributeNode(old);\n },\n hasAttributeNS: function(namespaceURI, localName) {\n return this.getAttributeNodeNS(namespaceURI, localName) != null;\n },\n getAttributeNS: function(namespaceURI, localName) {\n var attr = this.getAttributeNodeNS(namespaceURI, localName);\n return attr && attr.value || \"\";\n },\n setAttributeNS: function(namespaceURI, qualifiedName, value) {\n var attr = this.ownerDocument.createAttributeNS(namespaceURI, qualifiedName);\n attr.value = attr.nodeValue = \"\" + value;\n this.setAttributeNode(attr);\n },\n getAttributeNodeNS: function(namespaceURI, localName) {\n return this.attributes.getNamedItemNS(namespaceURI, localName);\n },\n getElementsByTagName: function(tagName) {\n return new $b8f821026a6eb0fb$var$LiveNodeList(this, function(base) {\n var ls = [];\n $b8f821026a6eb0fb$var$_visitNode(base, function(node) {\n if (node !== base && node.nodeType == $b8f821026a6eb0fb$var$ELEMENT_NODE && (tagName === \"*\" || node.tagName == tagName)) ls.push(node);\n });\n return ls;\n });\n },\n getElementsByTagNameNS: function(namespaceURI, localName) {\n return new $b8f821026a6eb0fb$var$LiveNodeList(this, function(base) {\n var ls = [];\n $b8f821026a6eb0fb$var$_visitNode(base, function(node) {\n if (node !== base && node.nodeType === $b8f821026a6eb0fb$var$ELEMENT_NODE && (namespaceURI === \"*\" || node.namespaceURI === namespaceURI) && (localName === \"*\" || node.localName == localName)) ls.push(node);\n });\n return ls;\n });\n }\n};\n$b8f821026a6eb0fb$var$Document.prototype.getElementsByTagName = $b8f821026a6eb0fb$var$Element.prototype.getElementsByTagName;\n$b8f821026a6eb0fb$var$Document.prototype.getElementsByTagNameNS = $b8f821026a6eb0fb$var$Element.prototype.getElementsByTagNameNS;\n$b8f821026a6eb0fb$var$_extends($b8f821026a6eb0fb$var$Element, $b8f821026a6eb0fb$var$Node);\nfunction $b8f821026a6eb0fb$var$Attr() {}\n$b8f821026a6eb0fb$var$Attr.prototype.nodeType = $b8f821026a6eb0fb$var$ATTRIBUTE_NODE;\n$b8f821026a6eb0fb$var$_extends($b8f821026a6eb0fb$var$Attr, $b8f821026a6eb0fb$var$Node);\nfunction $b8f821026a6eb0fb$var$CharacterData() {}\n$b8f821026a6eb0fb$var$CharacterData.prototype = {\n data: \"\",\n substringData: function(offset, count) {\n return this.data.substring(offset, offset + count);\n },\n appendData: function(text) {\n text = this.data + text;\n this.nodeValue = this.data = text;\n this.length = text.length;\n },\n insertData: function(offset, text) {\n this.replaceData(offset, 0, text);\n },\n appendChild: function(newChild) {\n throw new Error($b8f821026a6eb0fb$var$ExceptionMessage[$b8f821026a6eb0fb$var$HIERARCHY_REQUEST_ERR]);\n },\n deleteData: function(offset, count) {\n this.replaceData(offset, count, \"\");\n },\n replaceData: function(offset, count, text) {\n var start = this.data.substring(0, offset);\n var end = this.data.substring(offset + count);\n text = start + text + end;\n this.nodeValue = this.data = text;\n this.length = text.length;\n }\n};\n$b8f821026a6eb0fb$var$_extends($b8f821026a6eb0fb$var$CharacterData, $b8f821026a6eb0fb$var$Node);\nfunction $b8f821026a6eb0fb$var$Text() {}\n$b8f821026a6eb0fb$var$Text.prototype = {\n nodeName: \"#text\",\n nodeType: $b8f821026a6eb0fb$var$TEXT_NODE,\n splitText: function(offset) {\n var text = this.data;\n var newText = text.substring(offset);\n text = text.substring(0, offset);\n this.data = this.nodeValue = text;\n this.length = text.length;\n var newNode = this.ownerDocument.createTextNode(newText);\n if (this.parentNode) this.parentNode.insertBefore(newNode, this.nextSibling);\n return newNode;\n }\n};\n$b8f821026a6eb0fb$var$_extends($b8f821026a6eb0fb$var$Text, $b8f821026a6eb0fb$var$CharacterData);\nfunction $b8f821026a6eb0fb$var$Comment() {}\n$b8f821026a6eb0fb$var$Comment.prototype = {\n nodeName: \"#comment\",\n nodeType: $b8f821026a6eb0fb$var$COMMENT_NODE\n};\n$b8f821026a6eb0fb$var$_extends($b8f821026a6eb0fb$var$Comment, $b8f821026a6eb0fb$var$CharacterData);\nfunction $b8f821026a6eb0fb$var$CDATASection() {}\n$b8f821026a6eb0fb$var$CDATASection.prototype = {\n nodeName: \"#cdata-section\",\n nodeType: $b8f821026a6eb0fb$var$CDATA_SECTION_NODE\n};\n$b8f821026a6eb0fb$var$_extends($b8f821026a6eb0fb$var$CDATASection, $b8f821026a6eb0fb$var$CharacterData);\nfunction $b8f821026a6eb0fb$var$DocumentType() {}\n$b8f821026a6eb0fb$var$DocumentType.prototype.nodeType = $b8f821026a6eb0fb$var$DOCUMENT_TYPE_NODE;\n$b8f821026a6eb0fb$var$_extends($b8f821026a6eb0fb$var$DocumentType, $b8f821026a6eb0fb$var$Node);\nfunction $b8f821026a6eb0fb$var$Notation() {}\n$b8f821026a6eb0fb$var$Notation.prototype.nodeType = $b8f821026a6eb0fb$var$NOTATION_NODE;\n$b8f821026a6eb0fb$var$_extends($b8f821026a6eb0fb$var$Notation, $b8f821026a6eb0fb$var$Node);\nfunction $b8f821026a6eb0fb$var$Entity() {}\n$b8f821026a6eb0fb$var$Entity.prototype.nodeType = $b8f821026a6eb0fb$var$ENTITY_NODE;\n$b8f821026a6eb0fb$var$_extends($b8f821026a6eb0fb$var$Entity, $b8f821026a6eb0fb$var$Node);\nfunction $b8f821026a6eb0fb$var$EntityReference() {}\n$b8f821026a6eb0fb$var$EntityReference.prototype.nodeType = $b8f821026a6eb0fb$var$ENTITY_REFERENCE_NODE;\n$b8f821026a6eb0fb$var$_extends($b8f821026a6eb0fb$var$EntityReference, $b8f821026a6eb0fb$var$Node);\nfunction $b8f821026a6eb0fb$var$DocumentFragment() {}\n$b8f821026a6eb0fb$var$DocumentFragment.prototype.nodeName = \"#document-fragment\";\n$b8f821026a6eb0fb$var$DocumentFragment.prototype.nodeType = $b8f821026a6eb0fb$var$DOCUMENT_FRAGMENT_NODE;\n$b8f821026a6eb0fb$var$_extends($b8f821026a6eb0fb$var$DocumentFragment, $b8f821026a6eb0fb$var$Node);\nfunction $b8f821026a6eb0fb$var$ProcessingInstruction() {}\n$b8f821026a6eb0fb$var$ProcessingInstruction.prototype.nodeType = $b8f821026a6eb0fb$var$PROCESSING_INSTRUCTION_NODE;\n$b8f821026a6eb0fb$var$_extends($b8f821026a6eb0fb$var$ProcessingInstruction, $b8f821026a6eb0fb$var$Node);\nfunction $b8f821026a6eb0fb$var$XMLSerializer() {}\n$b8f821026a6eb0fb$var$XMLSerializer.prototype.serializeToString = function(node, isHtml, nodeFilter) {\n return $b8f821026a6eb0fb$var$nodeSerializeToString.call(node, isHtml, nodeFilter);\n};\n$b8f821026a6eb0fb$var$Node.prototype.toString = $b8f821026a6eb0fb$var$nodeSerializeToString;\nfunction $b8f821026a6eb0fb$var$nodeSerializeToString(isHtml, nodeFilter) {\n var buf = [];\n var refNode = this.nodeType == 9 && this.documentElement || this;\n var prefix = refNode.prefix;\n var uri = refNode.namespaceURI;\n if (uri && prefix == null) {\n //console.log(prefix)\n var prefix = refNode.lookupPrefix(uri);\n if (prefix == null) //isHTML = true;\n var visibleNamespaces = [\n {\n namespace: uri,\n prefix: null\n }\n ];\n }\n $b8f821026a6eb0fb$var$serializeToString(this, buf, isHtml, nodeFilter, visibleNamespaces);\n //console.log('###',this.nodeType,uri,prefix,buf.join(''))\n return buf.join(\"\");\n}\nfunction $b8f821026a6eb0fb$var$needNamespaceDefine(node, isHTML, visibleNamespaces) {\n var prefix = node.prefix || \"\";\n var uri = node.namespaceURI;\n // According to [Namespaces in XML 1.0](https://www.w3.org/TR/REC-xml-names/#ns-using) ,\n // and more specifically https://www.w3.org/TR/REC-xml-names/#nsc-NoPrefixUndecl :\n // > In a namespace declaration for a prefix [...], the attribute value MUST NOT be empty.\n // in a similar manner [Namespaces in XML 1.1](https://www.w3.org/TR/xml-names11/#ns-using)\n // and more specifically https://www.w3.org/TR/xml-names11/#nsc-NSDeclared :\n // > [...] Furthermore, the attribute value [...] must not be an empty string.\n // so serializing empty namespace value like xmlns:ds=\"\" would produce an invalid XML document.\n if (!uri) return false;\n if (prefix === \"xml\" && uri === $b8f821026a6eb0fb$var$NAMESPACE.XML || uri === $b8f821026a6eb0fb$var$NAMESPACE.XMLNS) return false;\n var i = visibleNamespaces.length;\n while(i--){\n var ns = visibleNamespaces[i];\n // get namespace prefix\n if (ns.prefix === prefix) return ns.namespace !== uri;\n }\n return true;\n}\n/**\n * Well-formed constraint: No < in Attribute Values\n * > The replacement text of any entity referred to directly or indirectly\n * > in an attribute value must not contain a <.\n * @see https://www.w3.org/TR/xml11/#CleanAttrVals\n * @see https://www.w3.org/TR/xml11/#NT-AttValue\n *\n * Literal whitespace other than space that appear in attribute values\n * are serialized as their entity references, so they will be preserved.\n * (In contrast to whitespace literals in the input which are normalized to spaces)\n * @see https://www.w3.org/TR/xml11/#AVNormalize\n * @see https://w3c.github.io/DOM-Parsing/#serializing-an-element-s-attributes\n */ function $b8f821026a6eb0fb$var$addSerializedAttribute(buf, qualifiedName, value) {\n buf.push(\" \", qualifiedName, '=\"', value.replace(/[<>&\"\\t\\n\\r]/g, $b8f821026a6eb0fb$var$_xmlEncoder), '\"');\n}\nfunction $b8f821026a6eb0fb$var$serializeToString(node, buf, isHTML, nodeFilter, visibleNamespaces) {\n if (!visibleNamespaces) visibleNamespaces = [];\n if (nodeFilter) {\n node = nodeFilter(node);\n if (node) {\n if (typeof node == \"string\") {\n buf.push(node);\n return;\n }\n } else return;\n //buf.sort.apply(attrs, attributeSorter);\n }\n switch(node.nodeType){\n case $b8f821026a6eb0fb$var$ELEMENT_NODE:\n var attrs = node.attributes;\n var len = attrs.length;\n var child = node.firstChild;\n var nodeName = node.tagName;\n isHTML = $b8f821026a6eb0fb$var$NAMESPACE.isHTML(node.namespaceURI) || isHTML;\n var prefixedNodeName = nodeName;\n if (!isHTML && !node.prefix && node.namespaceURI) {\n var defaultNS;\n // lookup current default ns from `xmlns` attribute\n for(var ai = 0; ai < attrs.length; ai++)if (attrs.item(ai).name === \"xmlns\") {\n defaultNS = attrs.item(ai).value;\n break;\n }\n if (!defaultNS) // lookup current default ns in visibleNamespaces\n for(var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--){\n var namespace = visibleNamespaces[nsi];\n if (namespace.prefix === \"\" && namespace.namespace === node.namespaceURI) {\n defaultNS = namespace.namespace;\n break;\n }\n }\n if (defaultNS !== node.namespaceURI) for(var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--){\n var namespace = visibleNamespaces[nsi];\n if (namespace.namespace === node.namespaceURI) {\n if (namespace.prefix) prefixedNodeName = namespace.prefix + \":\" + nodeName;\n break;\n }\n }\n }\n buf.push(\"<\", prefixedNodeName);\n for(var i = 0; i < len; i++){\n // add namespaces for attributes\n var attr = attrs.item(i);\n if (attr.prefix == \"xmlns\") visibleNamespaces.push({\n prefix: attr.localName,\n namespace: attr.value\n });\n else if (attr.nodeName == \"xmlns\") visibleNamespaces.push({\n prefix: \"\",\n namespace: attr.value\n });\n }\n for(var i = 0; i < len; i++){\n var attr = attrs.item(i);\n if ($b8f821026a6eb0fb$var$needNamespaceDefine(attr, isHTML, visibleNamespaces)) {\n var prefix = attr.prefix || \"\";\n var uri = attr.namespaceURI;\n $b8f821026a6eb0fb$var$addSerializedAttribute(buf, prefix ? \"xmlns:\" + prefix : \"xmlns\", uri);\n visibleNamespaces.push({\n prefix: prefix,\n namespace: uri\n });\n }\n $b8f821026a6eb0fb$var$serializeToString(attr, buf, isHTML, nodeFilter, visibleNamespaces);\n }\n // add namespace for current node\n if (nodeName === prefixedNodeName && $b8f821026a6eb0fb$var$needNamespaceDefine(node, isHTML, visibleNamespaces)) {\n var prefix = node.prefix || \"\";\n var uri = node.namespaceURI;\n $b8f821026a6eb0fb$var$addSerializedAttribute(buf, prefix ? \"xmlns:\" + prefix : \"xmlns\", uri);\n visibleNamespaces.push({\n prefix: prefix,\n namespace: uri\n });\n }\n if (child || isHTML && !/^(?:meta|link|img|br|hr|input)$/i.test(nodeName)) {\n buf.push(\">\");\n //if is cdata child node\n if (isHTML && /^script$/i.test(nodeName)) while(child){\n if (child.data) buf.push(child.data);\n else $b8f821026a6eb0fb$var$serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());\n child = child.nextSibling;\n }\n else while(child){\n $b8f821026a6eb0fb$var$serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());\n child = child.nextSibling;\n }\n buf.push(\"\");\n } else buf.push(\"/>\");\n // remove added visible namespaces\n //visibleNamespaces.length = startVisibleNamespaces;\n return;\n case $b8f821026a6eb0fb$var$DOCUMENT_NODE:\n case $b8f821026a6eb0fb$var$DOCUMENT_FRAGMENT_NODE:\n var child = node.firstChild;\n while(child){\n $b8f821026a6eb0fb$var$serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());\n child = child.nextSibling;\n }\n return;\n case $b8f821026a6eb0fb$var$ATTRIBUTE_NODE:\n return $b8f821026a6eb0fb$var$addSerializedAttribute(buf, node.name, node.value);\n case $b8f821026a6eb0fb$var$TEXT_NODE:\n /**\n\t\t * The ampersand character (&) and the left angle bracket (<) must not appear in their literal form,\n\t\t * except when used as markup delimiters, or within a comment, a processing instruction, or a CDATA section.\n\t\t * If they are needed elsewhere, they must be escaped using either numeric character references or the strings\n\t\t * `&` and `<` respectively.\n\t\t * The right angle bracket (>) may be represented using the string \" > \", and must, for compatibility,\n\t\t * be escaped using either `>` or a character reference when it appears in the string `]]>` in content,\n\t\t * when that string is not marking the end of a CDATA section.\n\t\t *\n\t\t * In the content of elements, character data is any string of characters\n\t\t * which does not contain the start-delimiter of any markup\n\t\t * and does not include the CDATA-section-close delimiter, `]]>`.\n\t\t *\n\t\t * @see https://www.w3.org/TR/xml/#NT-CharData\n\t\t * @see https://w3c.github.io/DOM-Parsing/#xml-serializing-a-text-node\n\t\t */ return buf.push(node.data.replace(/[<&>]/g, $b8f821026a6eb0fb$var$_xmlEncoder));\n case $b8f821026a6eb0fb$var$CDATA_SECTION_NODE:\n return buf.push(\"\");\n case $b8f821026a6eb0fb$var$COMMENT_NODE:\n return buf.push(\"\");\n case $b8f821026a6eb0fb$var$DOCUMENT_TYPE_NODE:\n var pubid = node.publicId;\n var sysid = node.systemId;\n buf.push(\"\");\n } else if (sysid && sysid != \".\") buf.push(\" SYSTEM \", sysid, \">\");\n else {\n var sub = node.internalSubset;\n if (sub) buf.push(\" [\", sub, \"]\");\n buf.push(\">\");\n }\n return;\n case $b8f821026a6eb0fb$var$PROCESSING_INSTRUCTION_NODE:\n return buf.push(\"\");\n case $b8f821026a6eb0fb$var$ENTITY_REFERENCE_NODE:\n return buf.push(\"&\", node.nodeName, \";\");\n //case ENTITY_NODE:\n //case NOTATION_NODE:\n default:\n buf.push(\"??\", node.nodeName);\n }\n}\nfunction $b8f821026a6eb0fb$var$importNode(doc, node, deep) {\n var node2;\n switch(node.nodeType){\n case $b8f821026a6eb0fb$var$ELEMENT_NODE:\n node2 = node.cloneNode(false);\n node2.ownerDocument = doc;\n //var attrs = node2.attributes;\n //var len = attrs.length;\n //for(var i=0;i $bb581e29d81da91f$export$91f0e5ff03dc84f, (v) => $bb581e29d81da91f$export$91f0e5ff03dc84f = v);\n$parcel$export(module.exports, \"HTML_ENTITIES\", () => $bb581e29d81da91f$export$b7e4d4631df36afa, (v) => $bb581e29d81da91f$export$b7e4d4631df36afa = v);\n/**\n * The entities that are predefined in every XML document.\n *\n * @see https://www.w3.org/TR/2006/REC-xml11-20060816/#sec-predefined-ent W3C XML 1.1\n * @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-predefined-ent W3C XML 1.0\n * @see https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references#Predefined_entities_in_XML Wikipedia\n */ var $bb581e29d81da91f$export$91f0e5ff03dc84f;\n/**\n * A map of all entities that are detected in an HTML document.\n * They contain all entries from `XML_ENTITIES`.\n *\n * @see XML_ENTITIES\n * @see DOMParser.parseFromString\n * @see DOMImplementation.prototype.createHTMLDocument\n * @see https://html.spec.whatwg.org/#named-character-references WHATWG HTML(5) Spec\n * @see https://html.spec.whatwg.org/entities.json JSON\n * @see https://www.w3.org/TR/xml-entity-names/ W3C XML Entity Names\n * @see https://www.w3.org/TR/html4/sgml/entities.html W3C HTML4/SGML\n * @see https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references#Character_entity_references_in_HTML Wikipedia (HTML)\n * @see https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references#Entities_representing_special_characters_in_XHTML Wikpedia (XHTML)\n */ var $bb581e29d81da91f$export$b7e4d4631df36afa;\n/**\n * @deprecated use `HTML_ENTITIES` instead\n * @see HTML_ENTITIES\n */ var $bb581e29d81da91f$export$79451380caed3f98;\n\"use strict\";\n\nvar $12jBw = parcelRequire(\"12jBw\");\nvar $bb581e29d81da91f$require$freeze = $12jBw.freeze;\n$bb581e29d81da91f$export$91f0e5ff03dc84f = $bb581e29d81da91f$require$freeze({\n amp: \"&\",\n apos: \"'\",\n gt: \">\",\n lt: \"<\",\n quot: '\"'\n});\n$bb581e29d81da91f$export$b7e4d4631df36afa = $bb581e29d81da91f$require$freeze({\n Aacute: \"\\xc1\",\n aacute: \"\\xe1\",\n Abreve: \"\\u0102\",\n abreve: \"\\u0103\",\n ac: \"\\u223E\",\n acd: \"\\u223F\",\n acE: \"\\u223E\\u0333\",\n Acirc: \"\\xc2\",\n acirc: \"\\xe2\",\n acute: \"\\xb4\",\n Acy: \"\\u0410\",\n acy: \"\\u0430\",\n AElig: \"\\xc6\",\n aelig: \"\\xe6\",\n af: \"\\u2061\",\n Afr: \"\\uD835\\uDD04\",\n afr: \"\\uD835\\uDD1E\",\n Agrave: \"\\xc0\",\n agrave: \"\\xe0\",\n alefsym: \"\\u2135\",\n aleph: \"\\u2135\",\n Alpha: \"\\u0391\",\n alpha: \"\\u03B1\",\n Amacr: \"\\u0100\",\n amacr: \"\\u0101\",\n amalg: \"\\u2A3F\",\n AMP: \"&\",\n amp: \"&\",\n And: \"\\u2A53\",\n and: \"\\u2227\",\n andand: \"\\u2A55\",\n andd: \"\\u2A5C\",\n andslope: \"\\u2A58\",\n andv: \"\\u2A5A\",\n ang: \"\\u2220\",\n ange: \"\\u29A4\",\n angle: \"\\u2220\",\n angmsd: \"\\u2221\",\n angmsdaa: \"\\u29A8\",\n angmsdab: \"\\u29A9\",\n angmsdac: \"\\u29AA\",\n angmsdad: \"\\u29AB\",\n angmsdae: \"\\u29AC\",\n angmsdaf: \"\\u29AD\",\n angmsdag: \"\\u29AE\",\n angmsdah: \"\\u29AF\",\n angrt: \"\\u221F\",\n angrtvb: \"\\u22BE\",\n angrtvbd: \"\\u299D\",\n angsph: \"\\u2222\",\n angst: \"\\xc5\",\n angzarr: \"\\u237C\",\n Aogon: \"\\u0104\",\n aogon: \"\\u0105\",\n Aopf: \"\\uD835\\uDD38\",\n aopf: \"\\uD835\\uDD52\",\n ap: \"\\u2248\",\n apacir: \"\\u2A6F\",\n apE: \"\\u2A70\",\n ape: \"\\u224A\",\n apid: \"\\u224B\",\n apos: \"'\",\n ApplyFunction: \"\\u2061\",\n approx: \"\\u2248\",\n approxeq: \"\\u224A\",\n Aring: \"\\xc5\",\n aring: \"\\xe5\",\n Ascr: \"\\uD835\\uDC9C\",\n ascr: \"\\uD835\\uDCB6\",\n Assign: \"\\u2254\",\n ast: \"*\",\n asymp: \"\\u2248\",\n asympeq: \"\\u224D\",\n Atilde: \"\\xc3\",\n atilde: \"\\xe3\",\n Auml: \"\\xc4\",\n auml: \"\\xe4\",\n awconint: \"\\u2233\",\n awint: \"\\u2A11\",\n backcong: \"\\u224C\",\n backepsilon: \"\\u03F6\",\n backprime: \"\\u2035\",\n backsim: \"\\u223D\",\n backsimeq: \"\\u22CD\",\n Backslash: \"\\u2216\",\n Barv: \"\\u2AE7\",\n barvee: \"\\u22BD\",\n Barwed: \"\\u2306\",\n barwed: \"\\u2305\",\n barwedge: \"\\u2305\",\n bbrk: \"\\u23B5\",\n bbrktbrk: \"\\u23B6\",\n bcong: \"\\u224C\",\n Bcy: \"\\u0411\",\n bcy: \"\\u0431\",\n bdquo: \"\\u201E\",\n becaus: \"\\u2235\",\n Because: \"\\u2235\",\n because: \"\\u2235\",\n bemptyv: \"\\u29B0\",\n bepsi: \"\\u03F6\",\n bernou: \"\\u212C\",\n Bernoullis: \"\\u212C\",\n Beta: \"\\u0392\",\n beta: \"\\u03B2\",\n beth: \"\\u2136\",\n between: \"\\u226C\",\n Bfr: \"\\uD835\\uDD05\",\n bfr: \"\\uD835\\uDD1F\",\n bigcap: \"\\u22C2\",\n bigcirc: \"\\u25EF\",\n bigcup: \"\\u22C3\",\n bigodot: \"\\u2A00\",\n bigoplus: \"\\u2A01\",\n bigotimes: \"\\u2A02\",\n bigsqcup: \"\\u2A06\",\n bigstar: \"\\u2605\",\n bigtriangledown: \"\\u25BD\",\n bigtriangleup: \"\\u25B3\",\n biguplus: \"\\u2A04\",\n bigvee: \"\\u22C1\",\n bigwedge: \"\\u22C0\",\n bkarow: \"\\u290D\",\n blacklozenge: \"\\u29EB\",\n blacksquare: \"\\u25AA\",\n blacktriangle: \"\\u25B4\",\n blacktriangledown: \"\\u25BE\",\n blacktriangleleft: \"\\u25C2\",\n blacktriangleright: \"\\u25B8\",\n blank: \"\\u2423\",\n blk12: \"\\u2592\",\n blk14: \"\\u2591\",\n blk34: \"\\u2593\",\n block: \"\\u2588\",\n bne: \"=\\u20E5\",\n bnequiv: \"\\u2261\\u20E5\",\n bNot: \"\\u2AED\",\n bnot: \"\\u2310\",\n Bopf: \"\\uD835\\uDD39\",\n bopf: \"\\uD835\\uDD53\",\n bot: \"\\u22A5\",\n bottom: \"\\u22A5\",\n bowtie: \"\\u22C8\",\n boxbox: \"\\u29C9\",\n boxDL: \"\\u2557\",\n boxDl: \"\\u2556\",\n boxdL: \"\\u2555\",\n boxdl: \"\\u2510\",\n boxDR: \"\\u2554\",\n boxDr: \"\\u2553\",\n boxdR: \"\\u2552\",\n boxdr: \"\\u250C\",\n boxH: \"\\u2550\",\n boxh: \"\\u2500\",\n boxHD: \"\\u2566\",\n boxHd: \"\\u2564\",\n boxhD: \"\\u2565\",\n boxhd: \"\\u252C\",\n boxHU: \"\\u2569\",\n boxHu: \"\\u2567\",\n boxhU: \"\\u2568\",\n boxhu: \"\\u2534\",\n boxminus: \"\\u229F\",\n boxplus: \"\\u229E\",\n boxtimes: \"\\u22A0\",\n boxUL: \"\\u255D\",\n boxUl: \"\\u255C\",\n boxuL: \"\\u255B\",\n boxul: \"\\u2518\",\n boxUR: \"\\u255A\",\n boxUr: \"\\u2559\",\n boxuR: \"\\u2558\",\n boxur: \"\\u2514\",\n boxV: \"\\u2551\",\n boxv: \"\\u2502\",\n boxVH: \"\\u256C\",\n boxVh: \"\\u256B\",\n boxvH: \"\\u256A\",\n boxvh: \"\\u253C\",\n boxVL: \"\\u2563\",\n boxVl: \"\\u2562\",\n boxvL: \"\\u2561\",\n boxvl: \"\\u2524\",\n boxVR: \"\\u2560\",\n boxVr: \"\\u255F\",\n boxvR: \"\\u255E\",\n boxvr: \"\\u251C\",\n bprime: \"\\u2035\",\n Breve: \"\\u02D8\",\n breve: \"\\u02D8\",\n brvbar: \"\\xa6\",\n Bscr: \"\\u212C\",\n bscr: \"\\uD835\\uDCB7\",\n bsemi: \"\\u204F\",\n bsim: \"\\u223D\",\n bsime: \"\\u22CD\",\n bsol: \"\\\\\",\n bsolb: \"\\u29C5\",\n bsolhsub: \"\\u27C8\",\n bull: \"\\u2022\",\n bullet: \"\\u2022\",\n bump: \"\\u224E\",\n bumpE: \"\\u2AAE\",\n bumpe: \"\\u224F\",\n Bumpeq: \"\\u224E\",\n bumpeq: \"\\u224F\",\n Cacute: \"\\u0106\",\n cacute: \"\\u0107\",\n Cap: \"\\u22D2\",\n cap: \"\\u2229\",\n capand: \"\\u2A44\",\n capbrcup: \"\\u2A49\",\n capcap: \"\\u2A4B\",\n capcup: \"\\u2A47\",\n capdot: \"\\u2A40\",\n CapitalDifferentialD: \"\\u2145\",\n caps: \"\\u2229\\uFE00\",\n caret: \"\\u2041\",\n caron: \"\\u02C7\",\n Cayleys: \"\\u212D\",\n ccaps: \"\\u2A4D\",\n Ccaron: \"\\u010C\",\n ccaron: \"\\u010D\",\n Ccedil: \"\\xc7\",\n ccedil: \"\\xe7\",\n Ccirc: \"\\u0108\",\n ccirc: \"\\u0109\",\n Cconint: \"\\u2230\",\n ccups: \"\\u2A4C\",\n ccupssm: \"\\u2A50\",\n Cdot: \"\\u010A\",\n cdot: \"\\u010B\",\n cedil: \"\\xb8\",\n Cedilla: \"\\xb8\",\n cemptyv: \"\\u29B2\",\n cent: \"\\xa2\",\n CenterDot: \"\\xb7\",\n centerdot: \"\\xb7\",\n Cfr: \"\\u212D\",\n cfr: \"\\uD835\\uDD20\",\n CHcy: \"\\u0427\",\n chcy: \"\\u0447\",\n check: \"\\u2713\",\n checkmark: \"\\u2713\",\n Chi: \"\\u03A7\",\n chi: \"\\u03C7\",\n cir: \"\\u25CB\",\n circ: \"\\u02C6\",\n circeq: \"\\u2257\",\n circlearrowleft: \"\\u21BA\",\n circlearrowright: \"\\u21BB\",\n circledast: \"\\u229B\",\n circledcirc: \"\\u229A\",\n circleddash: \"\\u229D\",\n CircleDot: \"\\u2299\",\n circledR: \"\\xae\",\n circledS: \"\\u24C8\",\n CircleMinus: \"\\u2296\",\n CirclePlus: \"\\u2295\",\n CircleTimes: \"\\u2297\",\n cirE: \"\\u29C3\",\n cire: \"\\u2257\",\n cirfnint: \"\\u2A10\",\n cirmid: \"\\u2AEF\",\n cirscir: \"\\u29C2\",\n ClockwiseContourIntegral: \"\\u2232\",\n CloseCurlyDoubleQuote: \"\\u201D\",\n CloseCurlyQuote: \"\\u2019\",\n clubs: \"\\u2663\",\n clubsuit: \"\\u2663\",\n Colon: \"\\u2237\",\n colon: \":\",\n Colone: \"\\u2A74\",\n colone: \"\\u2254\",\n coloneq: \"\\u2254\",\n comma: \",\",\n commat: \"@\",\n comp: \"\\u2201\",\n compfn: \"\\u2218\",\n complement: \"\\u2201\",\n complexes: \"\\u2102\",\n cong: \"\\u2245\",\n congdot: \"\\u2A6D\",\n Congruent: \"\\u2261\",\n Conint: \"\\u222F\",\n conint: \"\\u222E\",\n ContourIntegral: \"\\u222E\",\n Copf: \"\\u2102\",\n copf: \"\\uD835\\uDD54\",\n coprod: \"\\u2210\",\n Coproduct: \"\\u2210\",\n COPY: \"\\xa9\",\n copy: \"\\xa9\",\n copysr: \"\\u2117\",\n CounterClockwiseContourIntegral: \"\\u2233\",\n crarr: \"\\u21B5\",\n Cross: \"\\u2A2F\",\n cross: \"\\u2717\",\n Cscr: \"\\uD835\\uDC9E\",\n cscr: \"\\uD835\\uDCB8\",\n csub: \"\\u2ACF\",\n csube: \"\\u2AD1\",\n csup: \"\\u2AD0\",\n csupe: \"\\u2AD2\",\n ctdot: \"\\u22EF\",\n cudarrl: \"\\u2938\",\n cudarrr: \"\\u2935\",\n cuepr: \"\\u22DE\",\n cuesc: \"\\u22DF\",\n cularr: \"\\u21B6\",\n cularrp: \"\\u293D\",\n Cup: \"\\u22D3\",\n cup: \"\\u222A\",\n cupbrcap: \"\\u2A48\",\n CupCap: \"\\u224D\",\n cupcap: \"\\u2A46\",\n cupcup: \"\\u2A4A\",\n cupdot: \"\\u228D\",\n cupor: \"\\u2A45\",\n cups: \"\\u222A\\uFE00\",\n curarr: \"\\u21B7\",\n curarrm: \"\\u293C\",\n curlyeqprec: \"\\u22DE\",\n curlyeqsucc: \"\\u22DF\",\n curlyvee: \"\\u22CE\",\n curlywedge: \"\\u22CF\",\n curren: \"\\xa4\",\n curvearrowleft: \"\\u21B6\",\n curvearrowright: \"\\u21B7\",\n cuvee: \"\\u22CE\",\n cuwed: \"\\u22CF\",\n cwconint: \"\\u2232\",\n cwint: \"\\u2231\",\n cylcty: \"\\u232D\",\n Dagger: \"\\u2021\",\n dagger: \"\\u2020\",\n daleth: \"\\u2138\",\n Darr: \"\\u21A1\",\n dArr: \"\\u21D3\",\n darr: \"\\u2193\",\n dash: \"\\u2010\",\n Dashv: \"\\u2AE4\",\n dashv: \"\\u22A3\",\n dbkarow: \"\\u290F\",\n dblac: \"\\u02DD\",\n Dcaron: \"\\u010E\",\n dcaron: \"\\u010F\",\n Dcy: \"\\u0414\",\n dcy: \"\\u0434\",\n DD: \"\\u2145\",\n dd: \"\\u2146\",\n ddagger: \"\\u2021\",\n ddarr: \"\\u21CA\",\n DDotrahd: \"\\u2911\",\n ddotseq: \"\\u2A77\",\n deg: \"\\xb0\",\n Del: \"\\u2207\",\n Delta: \"\\u0394\",\n delta: \"\\u03B4\",\n demptyv: \"\\u29B1\",\n dfisht: \"\\u297F\",\n Dfr: \"\\uD835\\uDD07\",\n dfr: \"\\uD835\\uDD21\",\n dHar: \"\\u2965\",\n dharl: \"\\u21C3\",\n dharr: \"\\u21C2\",\n DiacriticalAcute: \"\\xb4\",\n DiacriticalDot: \"\\u02D9\",\n DiacriticalDoubleAcute: \"\\u02DD\",\n DiacriticalGrave: \"`\",\n DiacriticalTilde: \"\\u02DC\",\n diam: \"\\u22C4\",\n Diamond: \"\\u22C4\",\n diamond: \"\\u22C4\",\n diamondsuit: \"\\u2666\",\n diams: \"\\u2666\",\n die: \"\\xa8\",\n DifferentialD: \"\\u2146\",\n digamma: \"\\u03DD\",\n disin: \"\\u22F2\",\n div: \"\\xf7\",\n divide: \"\\xf7\",\n divideontimes: \"\\u22C7\",\n divonx: \"\\u22C7\",\n DJcy: \"\\u0402\",\n djcy: \"\\u0452\",\n dlcorn: \"\\u231E\",\n dlcrop: \"\\u230D\",\n dollar: \"$\",\n Dopf: \"\\uD835\\uDD3B\",\n dopf: \"\\uD835\\uDD55\",\n Dot: \"\\xa8\",\n dot: \"\\u02D9\",\n DotDot: \"\\u20DC\",\n doteq: \"\\u2250\",\n doteqdot: \"\\u2251\",\n DotEqual: \"\\u2250\",\n dotminus: \"\\u2238\",\n dotplus: \"\\u2214\",\n dotsquare: \"\\u22A1\",\n doublebarwedge: \"\\u2306\",\n DoubleContourIntegral: \"\\u222F\",\n DoubleDot: \"\\xa8\",\n DoubleDownArrow: \"\\u21D3\",\n DoubleLeftArrow: \"\\u21D0\",\n DoubleLeftRightArrow: \"\\u21D4\",\n DoubleLeftTee: \"\\u2AE4\",\n DoubleLongLeftArrow: \"\\u27F8\",\n DoubleLongLeftRightArrow: \"\\u27FA\",\n DoubleLongRightArrow: \"\\u27F9\",\n DoubleRightArrow: \"\\u21D2\",\n DoubleRightTee: \"\\u22A8\",\n DoubleUpArrow: \"\\u21D1\",\n DoubleUpDownArrow: \"\\u21D5\",\n DoubleVerticalBar: \"\\u2225\",\n DownArrow: \"\\u2193\",\n Downarrow: \"\\u21D3\",\n downarrow: \"\\u2193\",\n DownArrowBar: \"\\u2913\",\n DownArrowUpArrow: \"\\u21F5\",\n DownBreve: \"\\u0311\",\n downdownarrows: \"\\u21CA\",\n downharpoonleft: \"\\u21C3\",\n downharpoonright: \"\\u21C2\",\n DownLeftRightVector: \"\\u2950\",\n DownLeftTeeVector: \"\\u295E\",\n DownLeftVector: \"\\u21BD\",\n DownLeftVectorBar: \"\\u2956\",\n DownRightTeeVector: \"\\u295F\",\n DownRightVector: \"\\u21C1\",\n DownRightVectorBar: \"\\u2957\",\n DownTee: \"\\u22A4\",\n DownTeeArrow: \"\\u21A7\",\n drbkarow: \"\\u2910\",\n drcorn: \"\\u231F\",\n drcrop: \"\\u230C\",\n Dscr: \"\\uD835\\uDC9F\",\n dscr: \"\\uD835\\uDCB9\",\n DScy: \"\\u0405\",\n dscy: \"\\u0455\",\n dsol: \"\\u29F6\",\n Dstrok: \"\\u0110\",\n dstrok: \"\\u0111\",\n dtdot: \"\\u22F1\",\n dtri: \"\\u25BF\",\n dtrif: \"\\u25BE\",\n duarr: \"\\u21F5\",\n duhar: \"\\u296F\",\n dwangle: \"\\u29A6\",\n DZcy: \"\\u040F\",\n dzcy: \"\\u045F\",\n dzigrarr: \"\\u27FF\",\n Eacute: \"\\xc9\",\n eacute: \"\\xe9\",\n easter: \"\\u2A6E\",\n Ecaron: \"\\u011A\",\n ecaron: \"\\u011B\",\n ecir: \"\\u2256\",\n Ecirc: \"\\xca\",\n ecirc: \"\\xea\",\n ecolon: \"\\u2255\",\n Ecy: \"\\u042D\",\n ecy: \"\\u044D\",\n eDDot: \"\\u2A77\",\n Edot: \"\\u0116\",\n eDot: \"\\u2251\",\n edot: \"\\u0117\",\n ee: \"\\u2147\",\n efDot: \"\\u2252\",\n Efr: \"\\uD835\\uDD08\",\n efr: \"\\uD835\\uDD22\",\n eg: \"\\u2A9A\",\n Egrave: \"\\xc8\",\n egrave: \"\\xe8\",\n egs: \"\\u2A96\",\n egsdot: \"\\u2A98\",\n el: \"\\u2A99\",\n Element: \"\\u2208\",\n elinters: \"\\u23E7\",\n ell: \"\\u2113\",\n els: \"\\u2A95\",\n elsdot: \"\\u2A97\",\n Emacr: \"\\u0112\",\n emacr: \"\\u0113\",\n empty: \"\\u2205\",\n emptyset: \"\\u2205\",\n EmptySmallSquare: \"\\u25FB\",\n emptyv: \"\\u2205\",\n EmptyVerySmallSquare: \"\\u25AB\",\n emsp: \"\\u2003\",\n emsp13: \"\\u2004\",\n emsp14: \"\\u2005\",\n ENG: \"\\u014A\",\n eng: \"\\u014B\",\n ensp: \"\\u2002\",\n Eogon: \"\\u0118\",\n eogon: \"\\u0119\",\n Eopf: \"\\uD835\\uDD3C\",\n eopf: \"\\uD835\\uDD56\",\n epar: \"\\u22D5\",\n eparsl: \"\\u29E3\",\n eplus: \"\\u2A71\",\n epsi: \"\\u03B5\",\n Epsilon: \"\\u0395\",\n epsilon: \"\\u03B5\",\n epsiv: \"\\u03F5\",\n eqcirc: \"\\u2256\",\n eqcolon: \"\\u2255\",\n eqsim: \"\\u2242\",\n eqslantgtr: \"\\u2A96\",\n eqslantless: \"\\u2A95\",\n Equal: \"\\u2A75\",\n equals: \"=\",\n EqualTilde: \"\\u2242\",\n equest: \"\\u225F\",\n Equilibrium: \"\\u21CC\",\n equiv: \"\\u2261\",\n equivDD: \"\\u2A78\",\n eqvparsl: \"\\u29E5\",\n erarr: \"\\u2971\",\n erDot: \"\\u2253\",\n Escr: \"\\u2130\",\n escr: \"\\u212F\",\n esdot: \"\\u2250\",\n Esim: \"\\u2A73\",\n esim: \"\\u2242\",\n Eta: \"\\u0397\",\n eta: \"\\u03B7\",\n ETH: \"\\xd0\",\n eth: \"\\xf0\",\n Euml: \"\\xcb\",\n euml: \"\\xeb\",\n euro: \"\\u20AC\",\n excl: \"!\",\n exist: \"\\u2203\",\n Exists: \"\\u2203\",\n expectation: \"\\u2130\",\n ExponentialE: \"\\u2147\",\n exponentiale: \"\\u2147\",\n fallingdotseq: \"\\u2252\",\n Fcy: \"\\u0424\",\n fcy: \"\\u0444\",\n female: \"\\u2640\",\n ffilig: \"\\uFB03\",\n fflig: \"\\uFB00\",\n ffllig: \"\\uFB04\",\n Ffr: \"\\uD835\\uDD09\",\n ffr: \"\\uD835\\uDD23\",\n filig: \"\\uFB01\",\n FilledSmallSquare: \"\\u25FC\",\n FilledVerySmallSquare: \"\\u25AA\",\n fjlig: \"fj\",\n flat: \"\\u266D\",\n fllig: \"\\uFB02\",\n fltns: \"\\u25B1\",\n fnof: \"\\u0192\",\n Fopf: \"\\uD835\\uDD3D\",\n fopf: \"\\uD835\\uDD57\",\n ForAll: \"\\u2200\",\n forall: \"\\u2200\",\n fork: \"\\u22D4\",\n forkv: \"\\u2AD9\",\n Fouriertrf: \"\\u2131\",\n fpartint: \"\\u2A0D\",\n frac12: \"\\xbd\",\n frac13: \"\\u2153\",\n frac14: \"\\xbc\",\n frac15: \"\\u2155\",\n frac16: \"\\u2159\",\n frac18: \"\\u215B\",\n frac23: \"\\u2154\",\n frac25: \"\\u2156\",\n frac34: \"\\xbe\",\n frac35: \"\\u2157\",\n frac38: \"\\u215C\",\n frac45: \"\\u2158\",\n frac56: \"\\u215A\",\n frac58: \"\\u215D\",\n frac78: \"\\u215E\",\n frasl: \"\\u2044\",\n frown: \"\\u2322\",\n Fscr: \"\\u2131\",\n fscr: \"\\uD835\\uDCBB\",\n gacute: \"\\u01F5\",\n Gamma: \"\\u0393\",\n gamma: \"\\u03B3\",\n Gammad: \"\\u03DC\",\n gammad: \"\\u03DD\",\n gap: \"\\u2A86\",\n Gbreve: \"\\u011E\",\n gbreve: \"\\u011F\",\n Gcedil: \"\\u0122\",\n Gcirc: \"\\u011C\",\n gcirc: \"\\u011D\",\n Gcy: \"\\u0413\",\n gcy: \"\\u0433\",\n Gdot: \"\\u0120\",\n gdot: \"\\u0121\",\n gE: \"\\u2267\",\n ge: \"\\u2265\",\n gEl: \"\\u2A8C\",\n gel: \"\\u22DB\",\n geq: \"\\u2265\",\n geqq: \"\\u2267\",\n geqslant: \"\\u2A7E\",\n ges: \"\\u2A7E\",\n gescc: \"\\u2AA9\",\n gesdot: \"\\u2A80\",\n gesdoto: \"\\u2A82\",\n gesdotol: \"\\u2A84\",\n gesl: \"\\u22DB\\uFE00\",\n gesles: \"\\u2A94\",\n Gfr: \"\\uD835\\uDD0A\",\n gfr: \"\\uD835\\uDD24\",\n Gg: \"\\u22D9\",\n gg: \"\\u226B\",\n ggg: \"\\u22D9\",\n gimel: \"\\u2137\",\n GJcy: \"\\u0403\",\n gjcy: \"\\u0453\",\n gl: \"\\u2277\",\n gla: \"\\u2AA5\",\n glE: \"\\u2A92\",\n glj: \"\\u2AA4\",\n gnap: \"\\u2A8A\",\n gnapprox: \"\\u2A8A\",\n gnE: \"\\u2269\",\n gne: \"\\u2A88\",\n gneq: \"\\u2A88\",\n gneqq: \"\\u2269\",\n gnsim: \"\\u22E7\",\n Gopf: \"\\uD835\\uDD3E\",\n gopf: \"\\uD835\\uDD58\",\n grave: \"`\",\n GreaterEqual: \"\\u2265\",\n GreaterEqualLess: \"\\u22DB\",\n GreaterFullEqual: \"\\u2267\",\n GreaterGreater: \"\\u2AA2\",\n GreaterLess: \"\\u2277\",\n GreaterSlantEqual: \"\\u2A7E\",\n GreaterTilde: \"\\u2273\",\n Gscr: \"\\uD835\\uDCA2\",\n gscr: \"\\u210A\",\n gsim: \"\\u2273\",\n gsime: \"\\u2A8E\",\n gsiml: \"\\u2A90\",\n Gt: \"\\u226B\",\n GT: \">\",\n gt: \">\",\n gtcc: \"\\u2AA7\",\n gtcir: \"\\u2A7A\",\n gtdot: \"\\u22D7\",\n gtlPar: \"\\u2995\",\n gtquest: \"\\u2A7C\",\n gtrapprox: \"\\u2A86\",\n gtrarr: \"\\u2978\",\n gtrdot: \"\\u22D7\",\n gtreqless: \"\\u22DB\",\n gtreqqless: \"\\u2A8C\",\n gtrless: \"\\u2277\",\n gtrsim: \"\\u2273\",\n gvertneqq: \"\\u2269\\uFE00\",\n gvnE: \"\\u2269\\uFE00\",\n Hacek: \"\\u02C7\",\n hairsp: \"\\u200A\",\n half: \"\\xbd\",\n hamilt: \"\\u210B\",\n HARDcy: \"\\u042A\",\n hardcy: \"\\u044A\",\n hArr: \"\\u21D4\",\n harr: \"\\u2194\",\n harrcir: \"\\u2948\",\n harrw: \"\\u21AD\",\n Hat: \"^\",\n hbar: \"\\u210F\",\n Hcirc: \"\\u0124\",\n hcirc: \"\\u0125\",\n hearts: \"\\u2665\",\n heartsuit: \"\\u2665\",\n hellip: \"\\u2026\",\n hercon: \"\\u22B9\",\n Hfr: \"\\u210C\",\n hfr: \"\\uD835\\uDD25\",\n HilbertSpace: \"\\u210B\",\n hksearow: \"\\u2925\",\n hkswarow: \"\\u2926\",\n hoarr: \"\\u21FF\",\n homtht: \"\\u223B\",\n hookleftarrow: \"\\u21A9\",\n hookrightarrow: \"\\u21AA\",\n Hopf: \"\\u210D\",\n hopf: \"\\uD835\\uDD59\",\n horbar: \"\\u2015\",\n HorizontalLine: \"\\u2500\",\n Hscr: \"\\u210B\",\n hscr: \"\\uD835\\uDCBD\",\n hslash: \"\\u210F\",\n Hstrok: \"\\u0126\",\n hstrok: \"\\u0127\",\n HumpDownHump: \"\\u224E\",\n HumpEqual: \"\\u224F\",\n hybull: \"\\u2043\",\n hyphen: \"\\u2010\",\n Iacute: \"\\xcd\",\n iacute: \"\\xed\",\n ic: \"\\u2063\",\n Icirc: \"\\xce\",\n icirc: \"\\xee\",\n Icy: \"\\u0418\",\n icy: \"\\u0438\",\n Idot: \"\\u0130\",\n IEcy: \"\\u0415\",\n iecy: \"\\u0435\",\n iexcl: \"\\xa1\",\n iff: \"\\u21D4\",\n Ifr: \"\\u2111\",\n ifr: \"\\uD835\\uDD26\",\n Igrave: \"\\xcc\",\n igrave: \"\\xec\",\n ii: \"\\u2148\",\n iiiint: \"\\u2A0C\",\n iiint: \"\\u222D\",\n iinfin: \"\\u29DC\",\n iiota: \"\\u2129\",\n IJlig: \"\\u0132\",\n ijlig: \"\\u0133\",\n Im: \"\\u2111\",\n Imacr: \"\\u012A\",\n imacr: \"\\u012B\",\n image: \"\\u2111\",\n ImaginaryI: \"\\u2148\",\n imagline: \"\\u2110\",\n imagpart: \"\\u2111\",\n imath: \"\\u0131\",\n imof: \"\\u22B7\",\n imped: \"\\u01B5\",\n Implies: \"\\u21D2\",\n in: \"\\u2208\",\n incare: \"\\u2105\",\n infin: \"\\u221E\",\n infintie: \"\\u29DD\",\n inodot: \"\\u0131\",\n Int: \"\\u222C\",\n int: \"\\u222B\",\n intcal: \"\\u22BA\",\n integers: \"\\u2124\",\n Integral: \"\\u222B\",\n intercal: \"\\u22BA\",\n Intersection: \"\\u22C2\",\n intlarhk: \"\\u2A17\",\n intprod: \"\\u2A3C\",\n InvisibleComma: \"\\u2063\",\n InvisibleTimes: \"\\u2062\",\n IOcy: \"\\u0401\",\n iocy: \"\\u0451\",\n Iogon: \"\\u012E\",\n iogon: \"\\u012F\",\n Iopf: \"\\uD835\\uDD40\",\n iopf: \"\\uD835\\uDD5A\",\n Iota: \"\\u0399\",\n iota: \"\\u03B9\",\n iprod: \"\\u2A3C\",\n iquest: \"\\xbf\",\n Iscr: \"\\u2110\",\n iscr: \"\\uD835\\uDCBE\",\n isin: \"\\u2208\",\n isindot: \"\\u22F5\",\n isinE: \"\\u22F9\",\n isins: \"\\u22F4\",\n isinsv: \"\\u22F3\",\n isinv: \"\\u2208\",\n it: \"\\u2062\",\n Itilde: \"\\u0128\",\n itilde: \"\\u0129\",\n Iukcy: \"\\u0406\",\n iukcy: \"\\u0456\",\n Iuml: \"\\xcf\",\n iuml: \"\\xef\",\n Jcirc: \"\\u0134\",\n jcirc: \"\\u0135\",\n Jcy: \"\\u0419\",\n jcy: \"\\u0439\",\n Jfr: \"\\uD835\\uDD0D\",\n jfr: \"\\uD835\\uDD27\",\n jmath: \"\\u0237\",\n Jopf: \"\\uD835\\uDD41\",\n jopf: \"\\uD835\\uDD5B\",\n Jscr: \"\\uD835\\uDCA5\",\n jscr: \"\\uD835\\uDCBF\",\n Jsercy: \"\\u0408\",\n jsercy: \"\\u0458\",\n Jukcy: \"\\u0404\",\n jukcy: \"\\u0454\",\n Kappa: \"\\u039A\",\n kappa: \"\\u03BA\",\n kappav: \"\\u03F0\",\n Kcedil: \"\\u0136\",\n kcedil: \"\\u0137\",\n Kcy: \"\\u041A\",\n kcy: \"\\u043A\",\n Kfr: \"\\uD835\\uDD0E\",\n kfr: \"\\uD835\\uDD28\",\n kgreen: \"\\u0138\",\n KHcy: \"\\u0425\",\n khcy: \"\\u0445\",\n KJcy: \"\\u040C\",\n kjcy: \"\\u045C\",\n Kopf: \"\\uD835\\uDD42\",\n kopf: \"\\uD835\\uDD5C\",\n Kscr: \"\\uD835\\uDCA6\",\n kscr: \"\\uD835\\uDCC0\",\n lAarr: \"\\u21DA\",\n Lacute: \"\\u0139\",\n lacute: \"\\u013A\",\n laemptyv: \"\\u29B4\",\n lagran: \"\\u2112\",\n Lambda: \"\\u039B\",\n lambda: \"\\u03BB\",\n Lang: \"\\u27EA\",\n lang: \"\\u27E8\",\n langd: \"\\u2991\",\n langle: \"\\u27E8\",\n lap: \"\\u2A85\",\n Laplacetrf: \"\\u2112\",\n laquo: \"\\xab\",\n Larr: \"\\u219E\",\n lArr: \"\\u21D0\",\n larr: \"\\u2190\",\n larrb: \"\\u21E4\",\n larrbfs: \"\\u291F\",\n larrfs: \"\\u291D\",\n larrhk: \"\\u21A9\",\n larrlp: \"\\u21AB\",\n larrpl: \"\\u2939\",\n larrsim: \"\\u2973\",\n larrtl: \"\\u21A2\",\n lat: \"\\u2AAB\",\n lAtail: \"\\u291B\",\n latail: \"\\u2919\",\n late: \"\\u2AAD\",\n lates: \"\\u2AAD\\uFE00\",\n lBarr: \"\\u290E\",\n lbarr: \"\\u290C\",\n lbbrk: \"\\u2772\",\n lbrace: \"{\",\n lbrack: \"[\",\n lbrke: \"\\u298B\",\n lbrksld: \"\\u298F\",\n lbrkslu: \"\\u298D\",\n Lcaron: \"\\u013D\",\n lcaron: \"\\u013E\",\n Lcedil: \"\\u013B\",\n lcedil: \"\\u013C\",\n lceil: \"\\u2308\",\n lcub: \"{\",\n Lcy: \"\\u041B\",\n lcy: \"\\u043B\",\n ldca: \"\\u2936\",\n ldquo: \"\\u201C\",\n ldquor: \"\\u201E\",\n ldrdhar: \"\\u2967\",\n ldrushar: \"\\u294B\",\n ldsh: \"\\u21B2\",\n lE: \"\\u2266\",\n le: \"\\u2264\",\n LeftAngleBracket: \"\\u27E8\",\n LeftArrow: \"\\u2190\",\n Leftarrow: \"\\u21D0\",\n leftarrow: \"\\u2190\",\n LeftArrowBar: \"\\u21E4\",\n LeftArrowRightArrow: \"\\u21C6\",\n leftarrowtail: \"\\u21A2\",\n LeftCeiling: \"\\u2308\",\n LeftDoubleBracket: \"\\u27E6\",\n LeftDownTeeVector: \"\\u2961\",\n LeftDownVector: \"\\u21C3\",\n LeftDownVectorBar: \"\\u2959\",\n LeftFloor: \"\\u230A\",\n leftharpoondown: \"\\u21BD\",\n leftharpoonup: \"\\u21BC\",\n leftleftarrows: \"\\u21C7\",\n LeftRightArrow: \"\\u2194\",\n Leftrightarrow: \"\\u21D4\",\n leftrightarrow: \"\\u2194\",\n leftrightarrows: \"\\u21C6\",\n leftrightharpoons: \"\\u21CB\",\n leftrightsquigarrow: \"\\u21AD\",\n LeftRightVector: \"\\u294E\",\n LeftTee: \"\\u22A3\",\n LeftTeeArrow: \"\\u21A4\",\n LeftTeeVector: \"\\u295A\",\n leftthreetimes: \"\\u22CB\",\n LeftTriangle: \"\\u22B2\",\n LeftTriangleBar: \"\\u29CF\",\n LeftTriangleEqual: \"\\u22B4\",\n LeftUpDownVector: \"\\u2951\",\n LeftUpTeeVector: \"\\u2960\",\n LeftUpVector: \"\\u21BF\",\n LeftUpVectorBar: \"\\u2958\",\n LeftVector: \"\\u21BC\",\n LeftVectorBar: \"\\u2952\",\n lEg: \"\\u2A8B\",\n leg: \"\\u22DA\",\n leq: \"\\u2264\",\n leqq: \"\\u2266\",\n leqslant: \"\\u2A7D\",\n les: \"\\u2A7D\",\n lescc: \"\\u2AA8\",\n lesdot: \"\\u2A7F\",\n lesdoto: \"\\u2A81\",\n lesdotor: \"\\u2A83\",\n lesg: \"\\u22DA\\uFE00\",\n lesges: \"\\u2A93\",\n lessapprox: \"\\u2A85\",\n lessdot: \"\\u22D6\",\n lesseqgtr: \"\\u22DA\",\n lesseqqgtr: \"\\u2A8B\",\n LessEqualGreater: \"\\u22DA\",\n LessFullEqual: \"\\u2266\",\n LessGreater: \"\\u2276\",\n lessgtr: \"\\u2276\",\n LessLess: \"\\u2AA1\",\n lesssim: \"\\u2272\",\n LessSlantEqual: \"\\u2A7D\",\n LessTilde: \"\\u2272\",\n lfisht: \"\\u297C\",\n lfloor: \"\\u230A\",\n Lfr: \"\\uD835\\uDD0F\",\n lfr: \"\\uD835\\uDD29\",\n lg: \"\\u2276\",\n lgE: \"\\u2A91\",\n lHar: \"\\u2962\",\n lhard: \"\\u21BD\",\n lharu: \"\\u21BC\",\n lharul: \"\\u296A\",\n lhblk: \"\\u2584\",\n LJcy: \"\\u0409\",\n ljcy: \"\\u0459\",\n Ll: \"\\u22D8\",\n ll: \"\\u226A\",\n llarr: \"\\u21C7\",\n llcorner: \"\\u231E\",\n Lleftarrow: \"\\u21DA\",\n llhard: \"\\u296B\",\n lltri: \"\\u25FA\",\n Lmidot: \"\\u013F\",\n lmidot: \"\\u0140\",\n lmoust: \"\\u23B0\",\n lmoustache: \"\\u23B0\",\n lnap: \"\\u2A89\",\n lnapprox: \"\\u2A89\",\n lnE: \"\\u2268\",\n lne: \"\\u2A87\",\n lneq: \"\\u2A87\",\n lneqq: \"\\u2268\",\n lnsim: \"\\u22E6\",\n loang: \"\\u27EC\",\n loarr: \"\\u21FD\",\n lobrk: \"\\u27E6\",\n LongLeftArrow: \"\\u27F5\",\n Longleftarrow: \"\\u27F8\",\n longleftarrow: \"\\u27F5\",\n LongLeftRightArrow: \"\\u27F7\",\n Longleftrightarrow: \"\\u27FA\",\n longleftrightarrow: \"\\u27F7\",\n longmapsto: \"\\u27FC\",\n LongRightArrow: \"\\u27F6\",\n Longrightarrow: \"\\u27F9\",\n longrightarrow: \"\\u27F6\",\n looparrowleft: \"\\u21AB\",\n looparrowright: \"\\u21AC\",\n lopar: \"\\u2985\",\n Lopf: \"\\uD835\\uDD43\",\n lopf: \"\\uD835\\uDD5D\",\n loplus: \"\\u2A2D\",\n lotimes: \"\\u2A34\",\n lowast: \"\\u2217\",\n lowbar: \"_\",\n LowerLeftArrow: \"\\u2199\",\n LowerRightArrow: \"\\u2198\",\n loz: \"\\u25CA\",\n lozenge: \"\\u25CA\",\n lozf: \"\\u29EB\",\n lpar: \"(\",\n lparlt: \"\\u2993\",\n lrarr: \"\\u21C6\",\n lrcorner: \"\\u231F\",\n lrhar: \"\\u21CB\",\n lrhard: \"\\u296D\",\n lrm: \"\\u200E\",\n lrtri: \"\\u22BF\",\n lsaquo: \"\\u2039\",\n Lscr: \"\\u2112\",\n lscr: \"\\uD835\\uDCC1\",\n Lsh: \"\\u21B0\",\n lsh: \"\\u21B0\",\n lsim: \"\\u2272\",\n lsime: \"\\u2A8D\",\n lsimg: \"\\u2A8F\",\n lsqb: \"[\",\n lsquo: \"\\u2018\",\n lsquor: \"\\u201A\",\n Lstrok: \"\\u0141\",\n lstrok: \"\\u0142\",\n Lt: \"\\u226A\",\n LT: \"<\",\n lt: \"<\",\n ltcc: \"\\u2AA6\",\n ltcir: \"\\u2A79\",\n ltdot: \"\\u22D6\",\n lthree: \"\\u22CB\",\n ltimes: \"\\u22C9\",\n ltlarr: \"\\u2976\",\n ltquest: \"\\u2A7B\",\n ltri: \"\\u25C3\",\n ltrie: \"\\u22B4\",\n ltrif: \"\\u25C2\",\n ltrPar: \"\\u2996\",\n lurdshar: \"\\u294A\",\n luruhar: \"\\u2966\",\n lvertneqq: \"\\u2268\\uFE00\",\n lvnE: \"\\u2268\\uFE00\",\n macr: \"\\xaf\",\n male: \"\\u2642\",\n malt: \"\\u2720\",\n maltese: \"\\u2720\",\n Map: \"\\u2905\",\n map: \"\\u21A6\",\n mapsto: \"\\u21A6\",\n mapstodown: \"\\u21A7\",\n mapstoleft: \"\\u21A4\",\n mapstoup: \"\\u21A5\",\n marker: \"\\u25AE\",\n mcomma: \"\\u2A29\",\n Mcy: \"\\u041C\",\n mcy: \"\\u043C\",\n mdash: \"\\u2014\",\n mDDot: \"\\u223A\",\n measuredangle: \"\\u2221\",\n MediumSpace: \"\\u205F\",\n Mellintrf: \"\\u2133\",\n Mfr: \"\\uD835\\uDD10\",\n mfr: \"\\uD835\\uDD2A\",\n mho: \"\\u2127\",\n micro: \"\\xb5\",\n mid: \"\\u2223\",\n midast: \"*\",\n midcir: \"\\u2AF0\",\n middot: \"\\xb7\",\n minus: \"\\u2212\",\n minusb: \"\\u229F\",\n minusd: \"\\u2238\",\n minusdu: \"\\u2A2A\",\n MinusPlus: \"\\u2213\",\n mlcp: \"\\u2ADB\",\n mldr: \"\\u2026\",\n mnplus: \"\\u2213\",\n models: \"\\u22A7\",\n Mopf: \"\\uD835\\uDD44\",\n mopf: \"\\uD835\\uDD5E\",\n mp: \"\\u2213\",\n Mscr: \"\\u2133\",\n mscr: \"\\uD835\\uDCC2\",\n mstpos: \"\\u223E\",\n Mu: \"\\u039C\",\n mu: \"\\u03BC\",\n multimap: \"\\u22B8\",\n mumap: \"\\u22B8\",\n nabla: \"\\u2207\",\n Nacute: \"\\u0143\",\n nacute: \"\\u0144\",\n nang: \"\\u2220\\u20D2\",\n nap: \"\\u2249\",\n napE: \"\\u2A70\\u0338\",\n napid: \"\\u224B\\u0338\",\n napos: \"\\u0149\",\n napprox: \"\\u2249\",\n natur: \"\\u266E\",\n natural: \"\\u266E\",\n naturals: \"\\u2115\",\n nbsp: \"\\xa0\",\n nbump: \"\\u224E\\u0338\",\n nbumpe: \"\\u224F\\u0338\",\n ncap: \"\\u2A43\",\n Ncaron: \"\\u0147\",\n ncaron: \"\\u0148\",\n Ncedil: \"\\u0145\",\n ncedil: \"\\u0146\",\n ncong: \"\\u2247\",\n ncongdot: \"\\u2A6D\\u0338\",\n ncup: \"\\u2A42\",\n Ncy: \"\\u041D\",\n ncy: \"\\u043D\",\n ndash: \"\\u2013\",\n ne: \"\\u2260\",\n nearhk: \"\\u2924\",\n neArr: \"\\u21D7\",\n nearr: \"\\u2197\",\n nearrow: \"\\u2197\",\n nedot: \"\\u2250\\u0338\",\n NegativeMediumSpace: \"\\u200B\",\n NegativeThickSpace: \"\\u200B\",\n NegativeThinSpace: \"\\u200B\",\n NegativeVeryThinSpace: \"\\u200B\",\n nequiv: \"\\u2262\",\n nesear: \"\\u2928\",\n nesim: \"\\u2242\\u0338\",\n NestedGreaterGreater: \"\\u226B\",\n NestedLessLess: \"\\u226A\",\n NewLine: \"\\n\",\n nexist: \"\\u2204\",\n nexists: \"\\u2204\",\n Nfr: \"\\uD835\\uDD11\",\n nfr: \"\\uD835\\uDD2B\",\n ngE: \"\\u2267\\u0338\",\n nge: \"\\u2271\",\n ngeq: \"\\u2271\",\n ngeqq: \"\\u2267\\u0338\",\n ngeqslant: \"\\u2A7E\\u0338\",\n nges: \"\\u2A7E\\u0338\",\n nGg: \"\\u22D9\\u0338\",\n ngsim: \"\\u2275\",\n nGt: \"\\u226B\\u20D2\",\n ngt: \"\\u226F\",\n ngtr: \"\\u226F\",\n nGtv: \"\\u226B\\u0338\",\n nhArr: \"\\u21CE\",\n nharr: \"\\u21AE\",\n nhpar: \"\\u2AF2\",\n ni: \"\\u220B\",\n nis: \"\\u22FC\",\n nisd: \"\\u22FA\",\n niv: \"\\u220B\",\n NJcy: \"\\u040A\",\n njcy: \"\\u045A\",\n nlArr: \"\\u21CD\",\n nlarr: \"\\u219A\",\n nldr: \"\\u2025\",\n nlE: \"\\u2266\\u0338\",\n nle: \"\\u2270\",\n nLeftarrow: \"\\u21CD\",\n nleftarrow: \"\\u219A\",\n nLeftrightarrow: \"\\u21CE\",\n nleftrightarrow: \"\\u21AE\",\n nleq: \"\\u2270\",\n nleqq: \"\\u2266\\u0338\",\n nleqslant: \"\\u2A7D\\u0338\",\n nles: \"\\u2A7D\\u0338\",\n nless: \"\\u226E\",\n nLl: \"\\u22D8\\u0338\",\n nlsim: \"\\u2274\",\n nLt: \"\\u226A\\u20D2\",\n nlt: \"\\u226E\",\n nltri: \"\\u22EA\",\n nltrie: \"\\u22EC\",\n nLtv: \"\\u226A\\u0338\",\n nmid: \"\\u2224\",\n NoBreak: \"\\u2060\",\n NonBreakingSpace: \"\\xa0\",\n Nopf: \"\\u2115\",\n nopf: \"\\uD835\\uDD5F\",\n Not: \"\\u2AEC\",\n not: \"\\xac\",\n NotCongruent: \"\\u2262\",\n NotCupCap: \"\\u226D\",\n NotDoubleVerticalBar: \"\\u2226\",\n NotElement: \"\\u2209\",\n NotEqual: \"\\u2260\",\n NotEqualTilde: \"\\u2242\\u0338\",\n NotExists: \"\\u2204\",\n NotGreater: \"\\u226F\",\n NotGreaterEqual: \"\\u2271\",\n NotGreaterFullEqual: \"\\u2267\\u0338\",\n NotGreaterGreater: \"\\u226B\\u0338\",\n NotGreaterLess: \"\\u2279\",\n NotGreaterSlantEqual: \"\\u2A7E\\u0338\",\n NotGreaterTilde: \"\\u2275\",\n NotHumpDownHump: \"\\u224E\\u0338\",\n NotHumpEqual: \"\\u224F\\u0338\",\n notin: \"\\u2209\",\n notindot: \"\\u22F5\\u0338\",\n notinE: \"\\u22F9\\u0338\",\n notinva: \"\\u2209\",\n notinvb: \"\\u22F7\",\n notinvc: \"\\u22F6\",\n NotLeftTriangle: \"\\u22EA\",\n NotLeftTriangleBar: \"\\u29CF\\u0338\",\n NotLeftTriangleEqual: \"\\u22EC\",\n NotLess: \"\\u226E\",\n NotLessEqual: \"\\u2270\",\n NotLessGreater: \"\\u2278\",\n NotLessLess: \"\\u226A\\u0338\",\n NotLessSlantEqual: \"\\u2A7D\\u0338\",\n NotLessTilde: \"\\u2274\",\n NotNestedGreaterGreater: \"\\u2AA2\\u0338\",\n NotNestedLessLess: \"\\u2AA1\\u0338\",\n notni: \"\\u220C\",\n notniva: \"\\u220C\",\n notnivb: \"\\u22FE\",\n notnivc: \"\\u22FD\",\n NotPrecedes: \"\\u2280\",\n NotPrecedesEqual: \"\\u2AAF\\u0338\",\n NotPrecedesSlantEqual: \"\\u22E0\",\n NotReverseElement: \"\\u220C\",\n NotRightTriangle: \"\\u22EB\",\n NotRightTriangleBar: \"\\u29D0\\u0338\",\n NotRightTriangleEqual: \"\\u22ED\",\n NotSquareSubset: \"\\u228F\\u0338\",\n NotSquareSubsetEqual: \"\\u22E2\",\n NotSquareSuperset: \"\\u2290\\u0338\",\n NotSquareSupersetEqual: \"\\u22E3\",\n NotSubset: \"\\u2282\\u20D2\",\n NotSubsetEqual: \"\\u2288\",\n NotSucceeds: \"\\u2281\",\n NotSucceedsEqual: \"\\u2AB0\\u0338\",\n NotSucceedsSlantEqual: \"\\u22E1\",\n NotSucceedsTilde: \"\\u227F\\u0338\",\n NotSuperset: \"\\u2283\\u20D2\",\n NotSupersetEqual: \"\\u2289\",\n NotTilde: \"\\u2241\",\n NotTildeEqual: \"\\u2244\",\n NotTildeFullEqual: \"\\u2247\",\n NotTildeTilde: \"\\u2249\",\n NotVerticalBar: \"\\u2224\",\n npar: \"\\u2226\",\n nparallel: \"\\u2226\",\n nparsl: \"\\u2AFD\\u20E5\",\n npart: \"\\u2202\\u0338\",\n npolint: \"\\u2A14\",\n npr: \"\\u2280\",\n nprcue: \"\\u22E0\",\n npre: \"\\u2AAF\\u0338\",\n nprec: \"\\u2280\",\n npreceq: \"\\u2AAF\\u0338\",\n nrArr: \"\\u21CF\",\n nrarr: \"\\u219B\",\n nrarrc: \"\\u2933\\u0338\",\n nrarrw: \"\\u219D\\u0338\",\n nRightarrow: \"\\u21CF\",\n nrightarrow: \"\\u219B\",\n nrtri: \"\\u22EB\",\n nrtrie: \"\\u22ED\",\n nsc: \"\\u2281\",\n nsccue: \"\\u22E1\",\n nsce: \"\\u2AB0\\u0338\",\n Nscr: \"\\uD835\\uDCA9\",\n nscr: \"\\uD835\\uDCC3\",\n nshortmid: \"\\u2224\",\n nshortparallel: \"\\u2226\",\n nsim: \"\\u2241\",\n nsime: \"\\u2244\",\n nsimeq: \"\\u2244\",\n nsmid: \"\\u2224\",\n nspar: \"\\u2226\",\n nsqsube: \"\\u22E2\",\n nsqsupe: \"\\u22E3\",\n nsub: \"\\u2284\",\n nsubE: \"\\u2AC5\\u0338\",\n nsube: \"\\u2288\",\n nsubset: \"\\u2282\\u20D2\",\n nsubseteq: \"\\u2288\",\n nsubseteqq: \"\\u2AC5\\u0338\",\n nsucc: \"\\u2281\",\n nsucceq: \"\\u2AB0\\u0338\",\n nsup: \"\\u2285\",\n nsupE: \"\\u2AC6\\u0338\",\n nsupe: \"\\u2289\",\n nsupset: \"\\u2283\\u20D2\",\n nsupseteq: \"\\u2289\",\n nsupseteqq: \"\\u2AC6\\u0338\",\n ntgl: \"\\u2279\",\n Ntilde: \"\\xd1\",\n ntilde: \"\\xf1\",\n ntlg: \"\\u2278\",\n ntriangleleft: \"\\u22EA\",\n ntrianglelefteq: \"\\u22EC\",\n ntriangleright: \"\\u22EB\",\n ntrianglerighteq: \"\\u22ED\",\n Nu: \"\\u039D\",\n nu: \"\\u03BD\",\n num: \"#\",\n numero: \"\\u2116\",\n numsp: \"\\u2007\",\n nvap: \"\\u224D\\u20D2\",\n nVDash: \"\\u22AF\",\n nVdash: \"\\u22AE\",\n nvDash: \"\\u22AD\",\n nvdash: \"\\u22AC\",\n nvge: \"\\u2265\\u20D2\",\n nvgt: \">\\u20D2\",\n nvHarr: \"\\u2904\",\n nvinfin: \"\\u29DE\",\n nvlArr: \"\\u2902\",\n nvle: \"\\u2264\\u20D2\",\n nvlt: \"<\\u20D2\",\n nvltrie: \"\\u22B4\\u20D2\",\n nvrArr: \"\\u2903\",\n nvrtrie: \"\\u22B5\\u20D2\",\n nvsim: \"\\u223C\\u20D2\",\n nwarhk: \"\\u2923\",\n nwArr: \"\\u21D6\",\n nwarr: \"\\u2196\",\n nwarrow: \"\\u2196\",\n nwnear: \"\\u2927\",\n Oacute: \"\\xd3\",\n oacute: \"\\xf3\",\n oast: \"\\u229B\",\n ocir: \"\\u229A\",\n Ocirc: \"\\xd4\",\n ocirc: \"\\xf4\",\n Ocy: \"\\u041E\",\n ocy: \"\\u043E\",\n odash: \"\\u229D\",\n Odblac: \"\\u0150\",\n odblac: \"\\u0151\",\n odiv: \"\\u2A38\",\n odot: \"\\u2299\",\n odsold: \"\\u29BC\",\n OElig: \"\\u0152\",\n oelig: \"\\u0153\",\n ofcir: \"\\u29BF\",\n Ofr: \"\\uD835\\uDD12\",\n ofr: \"\\uD835\\uDD2C\",\n ogon: \"\\u02DB\",\n Ograve: \"\\xd2\",\n ograve: \"\\xf2\",\n ogt: \"\\u29C1\",\n ohbar: \"\\u29B5\",\n ohm: \"\\u03A9\",\n oint: \"\\u222E\",\n olarr: \"\\u21BA\",\n olcir: \"\\u29BE\",\n olcross: \"\\u29BB\",\n oline: \"\\u203E\",\n olt: \"\\u29C0\",\n Omacr: \"\\u014C\",\n omacr: \"\\u014D\",\n Omega: \"\\u03A9\",\n omega: \"\\u03C9\",\n Omicron: \"\\u039F\",\n omicron: \"\\u03BF\",\n omid: \"\\u29B6\",\n ominus: \"\\u2296\",\n Oopf: \"\\uD835\\uDD46\",\n oopf: \"\\uD835\\uDD60\",\n opar: \"\\u29B7\",\n OpenCurlyDoubleQuote: \"\\u201C\",\n OpenCurlyQuote: \"\\u2018\",\n operp: \"\\u29B9\",\n oplus: \"\\u2295\",\n Or: \"\\u2A54\",\n or: \"\\u2228\",\n orarr: \"\\u21BB\",\n ord: \"\\u2A5D\",\n order: \"\\u2134\",\n orderof: \"\\u2134\",\n ordf: \"\\xaa\",\n ordm: \"\\xba\",\n origof: \"\\u22B6\",\n oror: \"\\u2A56\",\n orslope: \"\\u2A57\",\n orv: \"\\u2A5B\",\n oS: \"\\u24C8\",\n Oscr: \"\\uD835\\uDCAA\",\n oscr: \"\\u2134\",\n Oslash: \"\\xd8\",\n oslash: \"\\xf8\",\n osol: \"\\u2298\",\n Otilde: \"\\xd5\",\n otilde: \"\\xf5\",\n Otimes: \"\\u2A37\",\n otimes: \"\\u2297\",\n otimesas: \"\\u2A36\",\n Ouml: \"\\xd6\",\n ouml: \"\\xf6\",\n ovbar: \"\\u233D\",\n OverBar: \"\\u203E\",\n OverBrace: \"\\u23DE\",\n OverBracket: \"\\u23B4\",\n OverParenthesis: \"\\u23DC\",\n par: \"\\u2225\",\n para: \"\\xb6\",\n parallel: \"\\u2225\",\n parsim: \"\\u2AF3\",\n parsl: \"\\u2AFD\",\n part: \"\\u2202\",\n PartialD: \"\\u2202\",\n Pcy: \"\\u041F\",\n pcy: \"\\u043F\",\n percnt: \"%\",\n period: \".\",\n permil: \"\\u2030\",\n perp: \"\\u22A5\",\n pertenk: \"\\u2031\",\n Pfr: \"\\uD835\\uDD13\",\n pfr: \"\\uD835\\uDD2D\",\n Phi: \"\\u03A6\",\n phi: \"\\u03C6\",\n phiv: \"\\u03D5\",\n phmmat: \"\\u2133\",\n phone: \"\\u260E\",\n Pi: \"\\u03A0\",\n pi: \"\\u03C0\",\n pitchfork: \"\\u22D4\",\n piv: \"\\u03D6\",\n planck: \"\\u210F\",\n planckh: \"\\u210E\",\n plankv: \"\\u210F\",\n plus: \"+\",\n plusacir: \"\\u2A23\",\n plusb: \"\\u229E\",\n pluscir: \"\\u2A22\",\n plusdo: \"\\u2214\",\n plusdu: \"\\u2A25\",\n pluse: \"\\u2A72\",\n PlusMinus: \"\\xb1\",\n plusmn: \"\\xb1\",\n plussim: \"\\u2A26\",\n plustwo: \"\\u2A27\",\n pm: \"\\xb1\",\n Poincareplane: \"\\u210C\",\n pointint: \"\\u2A15\",\n Popf: \"\\u2119\",\n popf: \"\\uD835\\uDD61\",\n pound: \"\\xa3\",\n Pr: \"\\u2ABB\",\n pr: \"\\u227A\",\n prap: \"\\u2AB7\",\n prcue: \"\\u227C\",\n prE: \"\\u2AB3\",\n pre: \"\\u2AAF\",\n prec: \"\\u227A\",\n precapprox: \"\\u2AB7\",\n preccurlyeq: \"\\u227C\",\n Precedes: \"\\u227A\",\n PrecedesEqual: \"\\u2AAF\",\n PrecedesSlantEqual: \"\\u227C\",\n PrecedesTilde: \"\\u227E\",\n preceq: \"\\u2AAF\",\n precnapprox: \"\\u2AB9\",\n precneqq: \"\\u2AB5\",\n precnsim: \"\\u22E8\",\n precsim: \"\\u227E\",\n Prime: \"\\u2033\",\n prime: \"\\u2032\",\n primes: \"\\u2119\",\n prnap: \"\\u2AB9\",\n prnE: \"\\u2AB5\",\n prnsim: \"\\u22E8\",\n prod: \"\\u220F\",\n Product: \"\\u220F\",\n profalar: \"\\u232E\",\n profline: \"\\u2312\",\n profsurf: \"\\u2313\",\n prop: \"\\u221D\",\n Proportion: \"\\u2237\",\n Proportional: \"\\u221D\",\n propto: \"\\u221D\",\n prsim: \"\\u227E\",\n prurel: \"\\u22B0\",\n Pscr: \"\\uD835\\uDCAB\",\n pscr: \"\\uD835\\uDCC5\",\n Psi: \"\\u03A8\",\n psi: \"\\u03C8\",\n puncsp: \"\\u2008\",\n Qfr: \"\\uD835\\uDD14\",\n qfr: \"\\uD835\\uDD2E\",\n qint: \"\\u2A0C\",\n Qopf: \"\\u211A\",\n qopf: \"\\uD835\\uDD62\",\n qprime: \"\\u2057\",\n Qscr: \"\\uD835\\uDCAC\",\n qscr: \"\\uD835\\uDCC6\",\n quaternions: \"\\u210D\",\n quatint: \"\\u2A16\",\n quest: \"?\",\n questeq: \"\\u225F\",\n QUOT: '\"',\n quot: '\"',\n rAarr: \"\\u21DB\",\n race: \"\\u223D\\u0331\",\n Racute: \"\\u0154\",\n racute: \"\\u0155\",\n radic: \"\\u221A\",\n raemptyv: \"\\u29B3\",\n Rang: \"\\u27EB\",\n rang: \"\\u27E9\",\n rangd: \"\\u2992\",\n range: \"\\u29A5\",\n rangle: \"\\u27E9\",\n raquo: \"\\xbb\",\n Rarr: \"\\u21A0\",\n rArr: \"\\u21D2\",\n rarr: \"\\u2192\",\n rarrap: \"\\u2975\",\n rarrb: \"\\u21E5\",\n rarrbfs: \"\\u2920\",\n rarrc: \"\\u2933\",\n rarrfs: \"\\u291E\",\n rarrhk: \"\\u21AA\",\n rarrlp: \"\\u21AC\",\n rarrpl: \"\\u2945\",\n rarrsim: \"\\u2974\",\n Rarrtl: \"\\u2916\",\n rarrtl: \"\\u21A3\",\n rarrw: \"\\u219D\",\n rAtail: \"\\u291C\",\n ratail: \"\\u291A\",\n ratio: \"\\u2236\",\n rationals: \"\\u211A\",\n RBarr: \"\\u2910\",\n rBarr: \"\\u290F\",\n rbarr: \"\\u290D\",\n rbbrk: \"\\u2773\",\n rbrace: \"}\",\n rbrack: \"]\",\n rbrke: \"\\u298C\",\n rbrksld: \"\\u298E\",\n rbrkslu: \"\\u2990\",\n Rcaron: \"\\u0158\",\n rcaron: \"\\u0159\",\n Rcedil: \"\\u0156\",\n rcedil: \"\\u0157\",\n rceil: \"\\u2309\",\n rcub: \"}\",\n Rcy: \"\\u0420\",\n rcy: \"\\u0440\",\n rdca: \"\\u2937\",\n rdldhar: \"\\u2969\",\n rdquo: \"\\u201D\",\n rdquor: \"\\u201D\",\n rdsh: \"\\u21B3\",\n Re: \"\\u211C\",\n real: \"\\u211C\",\n realine: \"\\u211B\",\n realpart: \"\\u211C\",\n reals: \"\\u211D\",\n rect: \"\\u25AD\",\n REG: \"\\xae\",\n reg: \"\\xae\",\n ReverseElement: \"\\u220B\",\n ReverseEquilibrium: \"\\u21CB\",\n ReverseUpEquilibrium: \"\\u296F\",\n rfisht: \"\\u297D\",\n rfloor: \"\\u230B\",\n Rfr: \"\\u211C\",\n rfr: \"\\uD835\\uDD2F\",\n rHar: \"\\u2964\",\n rhard: \"\\u21C1\",\n rharu: \"\\u21C0\",\n rharul: \"\\u296C\",\n Rho: \"\\u03A1\",\n rho: \"\\u03C1\",\n rhov: \"\\u03F1\",\n RightAngleBracket: \"\\u27E9\",\n RightArrow: \"\\u2192\",\n Rightarrow: \"\\u21D2\",\n rightarrow: \"\\u2192\",\n RightArrowBar: \"\\u21E5\",\n RightArrowLeftArrow: \"\\u21C4\",\n rightarrowtail: \"\\u21A3\",\n RightCeiling: \"\\u2309\",\n RightDoubleBracket: \"\\u27E7\",\n RightDownTeeVector: \"\\u295D\",\n RightDownVector: \"\\u21C2\",\n RightDownVectorBar: \"\\u2955\",\n RightFloor: \"\\u230B\",\n rightharpoondown: \"\\u21C1\",\n rightharpoonup: \"\\u21C0\",\n rightleftarrows: \"\\u21C4\",\n rightleftharpoons: \"\\u21CC\",\n rightrightarrows: \"\\u21C9\",\n rightsquigarrow: \"\\u219D\",\n RightTee: \"\\u22A2\",\n RightTeeArrow: \"\\u21A6\",\n RightTeeVector: \"\\u295B\",\n rightthreetimes: \"\\u22CC\",\n RightTriangle: \"\\u22B3\",\n RightTriangleBar: \"\\u29D0\",\n RightTriangleEqual: \"\\u22B5\",\n RightUpDownVector: \"\\u294F\",\n RightUpTeeVector: \"\\u295C\",\n RightUpVector: \"\\u21BE\",\n RightUpVectorBar: \"\\u2954\",\n RightVector: \"\\u21C0\",\n RightVectorBar: \"\\u2953\",\n ring: \"\\u02DA\",\n risingdotseq: \"\\u2253\",\n rlarr: \"\\u21C4\",\n rlhar: \"\\u21CC\",\n rlm: \"\\u200F\",\n rmoust: \"\\u23B1\",\n rmoustache: \"\\u23B1\",\n rnmid: \"\\u2AEE\",\n roang: \"\\u27ED\",\n roarr: \"\\u21FE\",\n robrk: \"\\u27E7\",\n ropar: \"\\u2986\",\n Ropf: \"\\u211D\",\n ropf: \"\\uD835\\uDD63\",\n roplus: \"\\u2A2E\",\n rotimes: \"\\u2A35\",\n RoundImplies: \"\\u2970\",\n rpar: \")\",\n rpargt: \"\\u2994\",\n rppolint: \"\\u2A12\",\n rrarr: \"\\u21C9\",\n Rrightarrow: \"\\u21DB\",\n rsaquo: \"\\u203A\",\n Rscr: \"\\u211B\",\n rscr: \"\\uD835\\uDCC7\",\n Rsh: \"\\u21B1\",\n rsh: \"\\u21B1\",\n rsqb: \"]\",\n rsquo: \"\\u2019\",\n rsquor: \"\\u2019\",\n rthree: \"\\u22CC\",\n rtimes: \"\\u22CA\",\n rtri: \"\\u25B9\",\n rtrie: \"\\u22B5\",\n rtrif: \"\\u25B8\",\n rtriltri: \"\\u29CE\",\n RuleDelayed: \"\\u29F4\",\n ruluhar: \"\\u2968\",\n rx: \"\\u211E\",\n Sacute: \"\\u015A\",\n sacute: \"\\u015B\",\n sbquo: \"\\u201A\",\n Sc: \"\\u2ABC\",\n sc: \"\\u227B\",\n scap: \"\\u2AB8\",\n Scaron: \"\\u0160\",\n scaron: \"\\u0161\",\n sccue: \"\\u227D\",\n scE: \"\\u2AB4\",\n sce: \"\\u2AB0\",\n Scedil: \"\\u015E\",\n scedil: \"\\u015F\",\n Scirc: \"\\u015C\",\n scirc: \"\\u015D\",\n scnap: \"\\u2ABA\",\n scnE: \"\\u2AB6\",\n scnsim: \"\\u22E9\",\n scpolint: \"\\u2A13\",\n scsim: \"\\u227F\",\n Scy: \"\\u0421\",\n scy: \"\\u0441\",\n sdot: \"\\u22C5\",\n sdotb: \"\\u22A1\",\n sdote: \"\\u2A66\",\n searhk: \"\\u2925\",\n seArr: \"\\u21D8\",\n searr: \"\\u2198\",\n searrow: \"\\u2198\",\n sect: \"\\xa7\",\n semi: \";\",\n seswar: \"\\u2929\",\n setminus: \"\\u2216\",\n setmn: \"\\u2216\",\n sext: \"\\u2736\",\n Sfr: \"\\uD835\\uDD16\",\n sfr: \"\\uD835\\uDD30\",\n sfrown: \"\\u2322\",\n sharp: \"\\u266F\",\n SHCHcy: \"\\u0429\",\n shchcy: \"\\u0449\",\n SHcy: \"\\u0428\",\n shcy: \"\\u0448\",\n ShortDownArrow: \"\\u2193\",\n ShortLeftArrow: \"\\u2190\",\n shortmid: \"\\u2223\",\n shortparallel: \"\\u2225\",\n ShortRightArrow: \"\\u2192\",\n ShortUpArrow: \"\\u2191\",\n shy: \"\\xad\",\n Sigma: \"\\u03A3\",\n sigma: \"\\u03C3\",\n sigmaf: \"\\u03C2\",\n sigmav: \"\\u03C2\",\n sim: \"\\u223C\",\n simdot: \"\\u2A6A\",\n sime: \"\\u2243\",\n simeq: \"\\u2243\",\n simg: \"\\u2A9E\",\n simgE: \"\\u2AA0\",\n siml: \"\\u2A9D\",\n simlE: \"\\u2A9F\",\n simne: \"\\u2246\",\n simplus: \"\\u2A24\",\n simrarr: \"\\u2972\",\n slarr: \"\\u2190\",\n SmallCircle: \"\\u2218\",\n smallsetminus: \"\\u2216\",\n smashp: \"\\u2A33\",\n smeparsl: \"\\u29E4\",\n smid: \"\\u2223\",\n smile: \"\\u2323\",\n smt: \"\\u2AAA\",\n smte: \"\\u2AAC\",\n smtes: \"\\u2AAC\\uFE00\",\n SOFTcy: \"\\u042C\",\n softcy: \"\\u044C\",\n sol: \"/\",\n solb: \"\\u29C4\",\n solbar: \"\\u233F\",\n Sopf: \"\\uD835\\uDD4A\",\n sopf: \"\\uD835\\uDD64\",\n spades: \"\\u2660\",\n spadesuit: \"\\u2660\",\n spar: \"\\u2225\",\n sqcap: \"\\u2293\",\n sqcaps: \"\\u2293\\uFE00\",\n sqcup: \"\\u2294\",\n sqcups: \"\\u2294\\uFE00\",\n Sqrt: \"\\u221A\",\n sqsub: \"\\u228F\",\n sqsube: \"\\u2291\",\n sqsubset: \"\\u228F\",\n sqsubseteq: \"\\u2291\",\n sqsup: \"\\u2290\",\n sqsupe: \"\\u2292\",\n sqsupset: \"\\u2290\",\n sqsupseteq: \"\\u2292\",\n squ: \"\\u25A1\",\n Square: \"\\u25A1\",\n square: \"\\u25A1\",\n SquareIntersection: \"\\u2293\",\n SquareSubset: \"\\u228F\",\n SquareSubsetEqual: \"\\u2291\",\n SquareSuperset: \"\\u2290\",\n SquareSupersetEqual: \"\\u2292\",\n SquareUnion: \"\\u2294\",\n squarf: \"\\u25AA\",\n squf: \"\\u25AA\",\n srarr: \"\\u2192\",\n Sscr: \"\\uD835\\uDCAE\",\n sscr: \"\\uD835\\uDCC8\",\n ssetmn: \"\\u2216\",\n ssmile: \"\\u2323\",\n sstarf: \"\\u22C6\",\n Star: \"\\u22C6\",\n star: \"\\u2606\",\n starf: \"\\u2605\",\n straightepsilon: \"\\u03F5\",\n straightphi: \"\\u03D5\",\n strns: \"\\xaf\",\n Sub: \"\\u22D0\",\n sub: \"\\u2282\",\n subdot: \"\\u2ABD\",\n subE: \"\\u2AC5\",\n sube: \"\\u2286\",\n subedot: \"\\u2AC3\",\n submult: \"\\u2AC1\",\n subnE: \"\\u2ACB\",\n subne: \"\\u228A\",\n subplus: \"\\u2ABF\",\n subrarr: \"\\u2979\",\n Subset: \"\\u22D0\",\n subset: \"\\u2282\",\n subseteq: \"\\u2286\",\n subseteqq: \"\\u2AC5\",\n SubsetEqual: \"\\u2286\",\n subsetneq: \"\\u228A\",\n subsetneqq: \"\\u2ACB\",\n subsim: \"\\u2AC7\",\n subsub: \"\\u2AD5\",\n subsup: \"\\u2AD3\",\n succ: \"\\u227B\",\n succapprox: \"\\u2AB8\",\n succcurlyeq: \"\\u227D\",\n Succeeds: \"\\u227B\",\n SucceedsEqual: \"\\u2AB0\",\n SucceedsSlantEqual: \"\\u227D\",\n SucceedsTilde: \"\\u227F\",\n succeq: \"\\u2AB0\",\n succnapprox: \"\\u2ABA\",\n succneqq: \"\\u2AB6\",\n succnsim: \"\\u22E9\",\n succsim: \"\\u227F\",\n SuchThat: \"\\u220B\",\n Sum: \"\\u2211\",\n sum: \"\\u2211\",\n sung: \"\\u266A\",\n Sup: \"\\u22D1\",\n sup: \"\\u2283\",\n sup1: \"\\xb9\",\n sup2: \"\\xb2\",\n sup3: \"\\xb3\",\n supdot: \"\\u2ABE\",\n supdsub: \"\\u2AD8\",\n supE: \"\\u2AC6\",\n supe: \"\\u2287\",\n supedot: \"\\u2AC4\",\n Superset: \"\\u2283\",\n SupersetEqual: \"\\u2287\",\n suphsol: \"\\u27C9\",\n suphsub: \"\\u2AD7\",\n suplarr: \"\\u297B\",\n supmult: \"\\u2AC2\",\n supnE: \"\\u2ACC\",\n supne: \"\\u228B\",\n supplus: \"\\u2AC0\",\n Supset: \"\\u22D1\",\n supset: \"\\u2283\",\n supseteq: \"\\u2287\",\n supseteqq: \"\\u2AC6\",\n supsetneq: \"\\u228B\",\n supsetneqq: \"\\u2ACC\",\n supsim: \"\\u2AC8\",\n supsub: \"\\u2AD4\",\n supsup: \"\\u2AD6\",\n swarhk: \"\\u2926\",\n swArr: \"\\u21D9\",\n swarr: \"\\u2199\",\n swarrow: \"\\u2199\",\n swnwar: \"\\u292A\",\n szlig: \"\\xdf\",\n Tab: \"\t\",\n target: \"\\u2316\",\n Tau: \"\\u03A4\",\n tau: \"\\u03C4\",\n tbrk: \"\\u23B4\",\n Tcaron: \"\\u0164\",\n tcaron: \"\\u0165\",\n Tcedil: \"\\u0162\",\n tcedil: \"\\u0163\",\n Tcy: \"\\u0422\",\n tcy: \"\\u0442\",\n tdot: \"\\u20DB\",\n telrec: \"\\u2315\",\n Tfr: \"\\uD835\\uDD17\",\n tfr: \"\\uD835\\uDD31\",\n there4: \"\\u2234\",\n Therefore: \"\\u2234\",\n therefore: \"\\u2234\",\n Theta: \"\\u0398\",\n theta: \"\\u03B8\",\n thetasym: \"\\u03D1\",\n thetav: \"\\u03D1\",\n thickapprox: \"\\u2248\",\n thicksim: \"\\u223C\",\n ThickSpace: \"\\u205F\\u200A\",\n thinsp: \"\\u2009\",\n ThinSpace: \"\\u2009\",\n thkap: \"\\u2248\",\n thksim: \"\\u223C\",\n THORN: \"\\xde\",\n thorn: \"\\xfe\",\n Tilde: \"\\u223C\",\n tilde: \"\\u02DC\",\n TildeEqual: \"\\u2243\",\n TildeFullEqual: \"\\u2245\",\n TildeTilde: \"\\u2248\",\n times: \"\\xd7\",\n timesb: \"\\u22A0\",\n timesbar: \"\\u2A31\",\n timesd: \"\\u2A30\",\n tint: \"\\u222D\",\n toea: \"\\u2928\",\n top: \"\\u22A4\",\n topbot: \"\\u2336\",\n topcir: \"\\u2AF1\",\n Topf: \"\\uD835\\uDD4B\",\n topf: \"\\uD835\\uDD65\",\n topfork: \"\\u2ADA\",\n tosa: \"\\u2929\",\n tprime: \"\\u2034\",\n TRADE: \"\\u2122\",\n trade: \"\\u2122\",\n triangle: \"\\u25B5\",\n triangledown: \"\\u25BF\",\n triangleleft: \"\\u25C3\",\n trianglelefteq: \"\\u22B4\",\n triangleq: \"\\u225C\",\n triangleright: \"\\u25B9\",\n trianglerighteq: \"\\u22B5\",\n tridot: \"\\u25EC\",\n trie: \"\\u225C\",\n triminus: \"\\u2A3A\",\n TripleDot: \"\\u20DB\",\n triplus: \"\\u2A39\",\n trisb: \"\\u29CD\",\n tritime: \"\\u2A3B\",\n trpezium: \"\\u23E2\",\n Tscr: \"\\uD835\\uDCAF\",\n tscr: \"\\uD835\\uDCC9\",\n TScy: \"\\u0426\",\n tscy: \"\\u0446\",\n TSHcy: \"\\u040B\",\n tshcy: \"\\u045B\",\n Tstrok: \"\\u0166\",\n tstrok: \"\\u0167\",\n twixt: \"\\u226C\",\n twoheadleftarrow: \"\\u219E\",\n twoheadrightarrow: \"\\u21A0\",\n Uacute: \"\\xda\",\n uacute: \"\\xfa\",\n Uarr: \"\\u219F\",\n uArr: \"\\u21D1\",\n uarr: \"\\u2191\",\n Uarrocir: \"\\u2949\",\n Ubrcy: \"\\u040E\",\n ubrcy: \"\\u045E\",\n Ubreve: \"\\u016C\",\n ubreve: \"\\u016D\",\n Ucirc: \"\\xdb\",\n ucirc: \"\\xfb\",\n Ucy: \"\\u0423\",\n ucy: \"\\u0443\",\n udarr: \"\\u21C5\",\n Udblac: \"\\u0170\",\n udblac: \"\\u0171\",\n udhar: \"\\u296E\",\n ufisht: \"\\u297E\",\n Ufr: \"\\uD835\\uDD18\",\n ufr: \"\\uD835\\uDD32\",\n Ugrave: \"\\xd9\",\n ugrave: \"\\xf9\",\n uHar: \"\\u2963\",\n uharl: \"\\u21BF\",\n uharr: \"\\u21BE\",\n uhblk: \"\\u2580\",\n ulcorn: \"\\u231C\",\n ulcorner: \"\\u231C\",\n ulcrop: \"\\u230F\",\n ultri: \"\\u25F8\",\n Umacr: \"\\u016A\",\n umacr: \"\\u016B\",\n uml: \"\\xa8\",\n UnderBar: \"_\",\n UnderBrace: \"\\u23DF\",\n UnderBracket: \"\\u23B5\",\n UnderParenthesis: \"\\u23DD\",\n Union: \"\\u22C3\",\n UnionPlus: \"\\u228E\",\n Uogon: \"\\u0172\",\n uogon: \"\\u0173\",\n Uopf: \"\\uD835\\uDD4C\",\n uopf: \"\\uD835\\uDD66\",\n UpArrow: \"\\u2191\",\n Uparrow: \"\\u21D1\",\n uparrow: \"\\u2191\",\n UpArrowBar: \"\\u2912\",\n UpArrowDownArrow: \"\\u21C5\",\n UpDownArrow: \"\\u2195\",\n Updownarrow: \"\\u21D5\",\n updownarrow: \"\\u2195\",\n UpEquilibrium: \"\\u296E\",\n upharpoonleft: \"\\u21BF\",\n upharpoonright: \"\\u21BE\",\n uplus: \"\\u228E\",\n UpperLeftArrow: \"\\u2196\",\n UpperRightArrow: \"\\u2197\",\n Upsi: \"\\u03D2\",\n upsi: \"\\u03C5\",\n upsih: \"\\u03D2\",\n Upsilon: \"\\u03A5\",\n upsilon: \"\\u03C5\",\n UpTee: \"\\u22A5\",\n UpTeeArrow: \"\\u21A5\",\n upuparrows: \"\\u21C8\",\n urcorn: \"\\u231D\",\n urcorner: \"\\u231D\",\n urcrop: \"\\u230E\",\n Uring: \"\\u016E\",\n uring: \"\\u016F\",\n urtri: \"\\u25F9\",\n Uscr: \"\\uD835\\uDCB0\",\n uscr: \"\\uD835\\uDCCA\",\n utdot: \"\\u22F0\",\n Utilde: \"\\u0168\",\n utilde: \"\\u0169\",\n utri: \"\\u25B5\",\n utrif: \"\\u25B4\",\n uuarr: \"\\u21C8\",\n Uuml: \"\\xdc\",\n uuml: \"\\xfc\",\n uwangle: \"\\u29A7\",\n vangrt: \"\\u299C\",\n varepsilon: \"\\u03F5\",\n varkappa: \"\\u03F0\",\n varnothing: \"\\u2205\",\n varphi: \"\\u03D5\",\n varpi: \"\\u03D6\",\n varpropto: \"\\u221D\",\n vArr: \"\\u21D5\",\n varr: \"\\u2195\",\n varrho: \"\\u03F1\",\n varsigma: \"\\u03C2\",\n varsubsetneq: \"\\u228A\\uFE00\",\n varsubsetneqq: \"\\u2ACB\\uFE00\",\n varsupsetneq: \"\\u228B\\uFE00\",\n varsupsetneqq: \"\\u2ACC\\uFE00\",\n vartheta: \"\\u03D1\",\n vartriangleleft: \"\\u22B2\",\n vartriangleright: \"\\u22B3\",\n Vbar: \"\\u2AEB\",\n vBar: \"\\u2AE8\",\n vBarv: \"\\u2AE9\",\n Vcy: \"\\u0412\",\n vcy: \"\\u0432\",\n VDash: \"\\u22AB\",\n Vdash: \"\\u22A9\",\n vDash: \"\\u22A8\",\n vdash: \"\\u22A2\",\n Vdashl: \"\\u2AE6\",\n Vee: \"\\u22C1\",\n vee: \"\\u2228\",\n veebar: \"\\u22BB\",\n veeeq: \"\\u225A\",\n vellip: \"\\u22EE\",\n Verbar: \"\\u2016\",\n verbar: \"|\",\n Vert: \"\\u2016\",\n vert: \"|\",\n VerticalBar: \"\\u2223\",\n VerticalLine: \"|\",\n VerticalSeparator: \"\\u2758\",\n VerticalTilde: \"\\u2240\",\n VeryThinSpace: \"\\u200A\",\n Vfr: \"\\uD835\\uDD19\",\n vfr: \"\\uD835\\uDD33\",\n vltri: \"\\u22B2\",\n vnsub: \"\\u2282\\u20D2\",\n vnsup: \"\\u2283\\u20D2\",\n Vopf: \"\\uD835\\uDD4D\",\n vopf: \"\\uD835\\uDD67\",\n vprop: \"\\u221D\",\n vrtri: \"\\u22B3\",\n Vscr: \"\\uD835\\uDCB1\",\n vscr: \"\\uD835\\uDCCB\",\n vsubnE: \"\\u2ACB\\uFE00\",\n vsubne: \"\\u228A\\uFE00\",\n vsupnE: \"\\u2ACC\\uFE00\",\n vsupne: \"\\u228B\\uFE00\",\n Vvdash: \"\\u22AA\",\n vzigzag: \"\\u299A\",\n Wcirc: \"\\u0174\",\n wcirc: \"\\u0175\",\n wedbar: \"\\u2A5F\",\n Wedge: \"\\u22C0\",\n wedge: \"\\u2227\",\n wedgeq: \"\\u2259\",\n weierp: \"\\u2118\",\n Wfr: \"\\uD835\\uDD1A\",\n wfr: \"\\uD835\\uDD34\",\n Wopf: \"\\uD835\\uDD4E\",\n wopf: \"\\uD835\\uDD68\",\n wp: \"\\u2118\",\n wr: \"\\u2240\",\n wreath: \"\\u2240\",\n Wscr: \"\\uD835\\uDCB2\",\n wscr: \"\\uD835\\uDCCC\",\n xcap: \"\\u22C2\",\n xcirc: \"\\u25EF\",\n xcup: \"\\u22C3\",\n xdtri: \"\\u25BD\",\n Xfr: \"\\uD835\\uDD1B\",\n xfr: \"\\uD835\\uDD35\",\n xhArr: \"\\u27FA\",\n xharr: \"\\u27F7\",\n Xi: \"\\u039E\",\n xi: \"\\u03BE\",\n xlArr: \"\\u27F8\",\n xlarr: \"\\u27F5\",\n xmap: \"\\u27FC\",\n xnis: \"\\u22FB\",\n xodot: \"\\u2A00\",\n Xopf: \"\\uD835\\uDD4F\",\n xopf: \"\\uD835\\uDD69\",\n xoplus: \"\\u2A01\",\n xotime: \"\\u2A02\",\n xrArr: \"\\u27F9\",\n xrarr: \"\\u27F6\",\n Xscr: \"\\uD835\\uDCB3\",\n xscr: \"\\uD835\\uDCCD\",\n xsqcup: \"\\u2A06\",\n xuplus: \"\\u2A04\",\n xutri: \"\\u25B3\",\n xvee: \"\\u22C1\",\n xwedge: \"\\u22C0\",\n Yacute: \"\\xdd\",\n yacute: \"\\xfd\",\n YAcy: \"\\u042F\",\n yacy: \"\\u044F\",\n Ycirc: \"\\u0176\",\n ycirc: \"\\u0177\",\n Ycy: \"\\u042B\",\n ycy: \"\\u044B\",\n yen: \"\\xa5\",\n Yfr: \"\\uD835\\uDD1C\",\n yfr: \"\\uD835\\uDD36\",\n YIcy: \"\\u0407\",\n yicy: \"\\u0457\",\n Yopf: \"\\uD835\\uDD50\",\n yopf: \"\\uD835\\uDD6A\",\n Yscr: \"\\uD835\\uDCB4\",\n yscr: \"\\uD835\\uDCCE\",\n YUcy: \"\\u042E\",\n yucy: \"\\u044E\",\n Yuml: \"\\u0178\",\n yuml: \"\\xff\",\n Zacute: \"\\u0179\",\n zacute: \"\\u017A\",\n Zcaron: \"\\u017D\",\n zcaron: \"\\u017E\",\n Zcy: \"\\u0417\",\n zcy: \"\\u0437\",\n Zdot: \"\\u017B\",\n zdot: \"\\u017C\",\n zeetrf: \"\\u2128\",\n ZeroWidthSpace: \"\\u200B\",\n Zeta: \"\\u0396\",\n zeta: \"\\u03B6\",\n Zfr: \"\\u2128\",\n zfr: \"\\uD835\\uDD37\",\n ZHcy: \"\\u0416\",\n zhcy: \"\\u0436\",\n zigrarr: \"\\u21DD\",\n Zopf: \"\\u2124\",\n zopf: \"\\uD835\\uDD6B\",\n Zscr: \"\\uD835\\uDCB5\",\n zscr: \"\\uD835\\uDCCF\",\n zwj: \"\\u200D\",\n zwnj: \"\\u200C\"\n});\n$bb581e29d81da91f$export$79451380caed3f98 = $bb581e29d81da91f$export$b7e4d4631df36afa;\n\n});\n\nparcelRegister(\"gqQA6\", function(module, exports) {\n\n$parcel$export(module.exports, \"XMLReader\", () => $bf67dc97ecf5e14f$export$ccbc9f9f018333e9, (v) => $bf67dc97ecf5e14f$export$ccbc9f9f018333e9 = v);\n$parcel$export(module.exports, \"ParseError\", () => $bf67dc97ecf5e14f$export$f9c837a54db411d, (v) => $bf67dc97ecf5e14f$export$f9c837a54db411d = v);\nvar $bf67dc97ecf5e14f$export$ccbc9f9f018333e9;\nvar $bf67dc97ecf5e14f$export$f9c837a54db411d;\n\nvar $12jBw = parcelRequire(\"12jBw\");\nvar $bf67dc97ecf5e14f$require$NAMESPACE = $12jBw.NAMESPACE;\n//[4] \tNameStartChar\t ::= \t\":\" | [A-Z] | \"_\" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]\n//[4a] \tNameChar\t ::= \tNameStartChar | \"-\" | \".\" | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]\n//[5] \tName\t ::= \tNameStartChar (NameChar)*\nvar $bf67dc97ecf5e14f$var$nameStartChar = /[A-Z_a-z\\xC0-\\xD6\\xD8-\\xF6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD]/ //\\u10000-\\uEFFFF\n;\nvar $bf67dc97ecf5e14f$var$nameChar = new RegExp(\"[\\\\-\\\\.0-9\" + $bf67dc97ecf5e14f$var$nameStartChar.source.slice(1, -1) + \"\\\\u00B7\\\\u0300-\\\\u036F\\\\u203F-\\\\u2040]\");\nvar $bf67dc97ecf5e14f$var$tagNamePattern = new RegExp(\"^\" + $bf67dc97ecf5e14f$var$nameStartChar.source + $bf67dc97ecf5e14f$var$nameChar.source + \"*(?::\" + $bf67dc97ecf5e14f$var$nameStartChar.source + $bf67dc97ecf5e14f$var$nameChar.source + \"*)?$\");\n//var tagNamePattern = /^[a-zA-Z_][\\w\\-\\.]*(?:\\:[a-zA-Z_][\\w\\-\\.]*)?$/\n//var handlers = 'resolveEntity,getExternalSubset,characters,endDocument,endElement,endPrefixMapping,ignorableWhitespace,processingInstruction,setDocumentLocator,skippedEntity,startDocument,startElement,startPrefixMapping,notationDecl,unparsedEntityDecl,error,fatalError,warning,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,comment,endCDATA,endDTD,endEntity,startCDATA,startDTD,startEntity'.split(',')\n//S_TAG,\tS_ATTR,\tS_EQ,\tS_ATTR_NOQUOT_VALUE\n//S_ATTR_SPACE,\tS_ATTR_END,\tS_TAG_SPACE, S_TAG_CLOSE\nvar $bf67dc97ecf5e14f$var$S_TAG = 0; //tag name offerring\nvar $bf67dc97ecf5e14f$var$S_ATTR = 1; //attr name offerring\nvar $bf67dc97ecf5e14f$var$S_ATTR_SPACE = 2; //attr name end and space offer\nvar $bf67dc97ecf5e14f$var$S_EQ = 3; //=space?\nvar $bf67dc97ecf5e14f$var$S_ATTR_NOQUOT_VALUE = 4; //attr value(no quot value only)\nvar $bf67dc97ecf5e14f$var$S_ATTR_END = 5; //attr value end and no space(quot end)\nvar $bf67dc97ecf5e14f$var$S_TAG_SPACE = 6; //(attr value end || tag end ) && (space offer)\nvar $bf67dc97ecf5e14f$var$S_TAG_CLOSE = 7; //closed el\n/**\n * Creates an error that will not be caught by XMLReader aka the SAX parser.\n *\n * @param {string} message\n * @param {any?} locator Optional, can provide details about the location in the source\n * @constructor\n */ function $bf67dc97ecf5e14f$var$ParseError(message, locator) {\n this.message = message;\n this.locator = locator;\n if (Error.captureStackTrace) Error.captureStackTrace(this, $bf67dc97ecf5e14f$var$ParseError);\n}\n$bf67dc97ecf5e14f$var$ParseError.prototype = new Error();\n$bf67dc97ecf5e14f$var$ParseError.prototype.name = $bf67dc97ecf5e14f$var$ParseError.name;\nfunction $bf67dc97ecf5e14f$var$XMLReader() {}\n$bf67dc97ecf5e14f$var$XMLReader.prototype = {\n parse: function(source, defaultNSMap, entityMap) {\n var domBuilder = this.domBuilder;\n domBuilder.startDocument();\n $bf67dc97ecf5e14f$var$_copy(defaultNSMap, defaultNSMap = {});\n $bf67dc97ecf5e14f$var$parse(source, defaultNSMap, entityMap, domBuilder, this.errorHandler);\n domBuilder.endDocument();\n }\n};\nfunction $bf67dc97ecf5e14f$var$parse(source, defaultNSMapCopy, entityMap, domBuilder, errorHandler) {\n function fixedFromCharCode(code) {\n // String.prototype.fromCharCode does not supports\n // > 2 bytes unicode chars directly\n if (code > 0xffff) {\n code -= 0x10000;\n var surrogate1 = 0xd800 + (code >> 10), surrogate2 = 0xdc00 + (code & 0x3ff);\n return String.fromCharCode(surrogate1, surrogate2);\n } else return String.fromCharCode(code);\n }\n function entityReplacer(a) {\n var k = a.slice(1, -1);\n if (Object.hasOwnProperty.call(entityMap, k)) return entityMap[k];\n else if (k.charAt(0) === \"#\") return fixedFromCharCode(parseInt(k.substr(1).replace(\"x\", \"0x\")));\n else {\n errorHandler.error(\"entity not found:\" + a);\n return a;\n }\n }\n function appendText(end) {\n if (end > start) {\n var xt = source.substring(start, end).replace(/&#?\\w+;/g, entityReplacer);\n locator && position(start);\n domBuilder.characters(xt, 0, end - start);\n start = end;\n }\n }\n function position(p, m) {\n while(p >= lineEnd && (m = linePattern.exec(source))){\n lineStart = m.index;\n lineEnd = lineStart + m[0].length;\n locator.lineNumber++;\n //console.log('line++:',locator,startPos,endPos)\n }\n locator.columnNumber = p - lineStart + 1;\n }\n var lineStart = 0;\n var lineEnd = 0;\n var linePattern = /.*(?:\\r\\n?|\\n)|.*$/g;\n var locator = domBuilder.locator;\n var parseStack = [\n {\n currentNSMap: defaultNSMapCopy\n }\n ];\n var closeMap = {};\n var start = 0;\n while(true){\n try {\n var tagStart = source.indexOf(\"<\", start);\n if (tagStart < 0) {\n if (!source.substr(start).match(/^\\s*$/)) {\n var doc = domBuilder.doc;\n var text = doc.createTextNode(source.substr(start));\n doc.appendChild(text);\n domBuilder.currentElement = text;\n }\n return;\n }\n if (tagStart > start) appendText(tagStart);\n switch(source.charAt(tagStart + 1)){\n case \"/\":\n var end = source.indexOf(\">\", tagStart + 3);\n var tagName = source.substring(tagStart + 2, end).replace(/[ \\t\\n\\r]+$/g, \"\");\n var config = parseStack.pop();\n if (end < 0) {\n tagName = source.substring(tagStart + 2).replace(/[\\s<].*/, \"\");\n errorHandler.error(\"end tag name: \" + tagName + \" is not complete:\" + config.tagName);\n end = tagStart + 1 + tagName.length;\n } else if (tagName.match(/\\s start) start = end;\n else //TODO: 这里有可能sax回退,有位置错误风险\n appendText(Math.max(tagStart, start) + 1);\n }\n}\nfunction $bf67dc97ecf5e14f$var$copyLocator(f, t) {\n t.lineNumber = f.lineNumber;\n t.columnNumber = f.columnNumber;\n return t;\n}\n/**\n * @see #appendElement(source,elStartEnd,el,selfClosed,entityReplacer,domBuilder,parseStack);\n * @return end of the elementStartPart(end of elementEndPart for selfClosed el)\n */ function $bf67dc97ecf5e14f$var$parseElementStartPart(source, start, el, currentNSMap, entityReplacer, errorHandler) {\n /**\n\t * @param {string} qname\n\t * @param {string} value\n\t * @param {number} startIndex\n\t */ function addAttribute(qname, value, startIndex) {\n if (el.attributeNames.hasOwnProperty(qname)) errorHandler.fatalError(\"Attribute \" + qname + \" redefined\");\n el.addValue(qname, // @see https://www.w3.org/TR/xml/#AVNormalize\n // since the xmldom sax parser does not \"interpret\" DTD the following is not implemented:\n // - recursive replacement of (DTD) entity references\n // - trimming and collapsing multiple spaces into a single one for attributes that are not of type CDATA\n value.replace(/[\\t\\n\\r]/g, \" \").replace(/&#?\\w+;/g, entityReplacer), startIndex);\n }\n var attrName;\n var value;\n var p = ++start;\n var s = $bf67dc97ecf5e14f$var$S_TAG; //status\n while(true){\n var c = source.charAt(p);\n switch(c){\n case \"=\":\n if (s === $bf67dc97ecf5e14f$var$S_ATTR) {\n attrName = source.slice(start, p);\n s = $bf67dc97ecf5e14f$var$S_EQ;\n } else if (s === $bf67dc97ecf5e14f$var$S_ATTR_SPACE) s = $bf67dc97ecf5e14f$var$S_EQ;\n else //fatalError: equal must after attrName or space after attrName\n throw new Error(\"attribute equal must after attrName\"); // No known test case\n break;\n case \"'\":\n case '\"':\n if (s === $bf67dc97ecf5e14f$var$S_EQ || s === $bf67dc97ecf5e14f$var$S_ATTR //|| s == S_ATTR_SPACE\n ) {\n if (s === $bf67dc97ecf5e14f$var$S_ATTR) {\n errorHandler.warning('attribute value must after \"=\"');\n attrName = source.slice(start, p);\n }\n start = p + 1;\n p = source.indexOf(c, start);\n if (p > 0) {\n value = source.slice(start, p);\n addAttribute(attrName, value, start - 1);\n s = $bf67dc97ecf5e14f$var$S_ATTR_END;\n } else //fatalError: no end quot match\n throw new Error(\"attribute value no end '\" + c + \"' match\");\n } else if (s == $bf67dc97ecf5e14f$var$S_ATTR_NOQUOT_VALUE) {\n value = source.slice(start, p);\n addAttribute(attrName, value, start);\n errorHandler.warning('attribute \"' + attrName + '\" missed start quot(' + c + \")!!\");\n start = p + 1;\n s = $bf67dc97ecf5e14f$var$S_ATTR_END;\n } else //fatalError: no equal before\n throw new Error('attribute value must after \"=\"'); // No known test case\n break;\n case \"/\":\n switch(s){\n case $bf67dc97ecf5e14f$var$S_TAG:\n el.setTagName(source.slice(start, p));\n case $bf67dc97ecf5e14f$var$S_ATTR_END:\n case $bf67dc97ecf5e14f$var$S_TAG_SPACE:\n case $bf67dc97ecf5e14f$var$S_TAG_CLOSE:\n s = $bf67dc97ecf5e14f$var$S_TAG_CLOSE;\n el.closed = true;\n case $bf67dc97ecf5e14f$var$S_ATTR_NOQUOT_VALUE:\n case $bf67dc97ecf5e14f$var$S_ATTR:\n break;\n case $bf67dc97ecf5e14f$var$S_ATTR_SPACE:\n el.closed = true;\n break;\n //case S_EQ:\n default:\n throw new Error(\"attribute invalid close char('/')\") // No known test case\n ;\n }\n break;\n case \"\":\n errorHandler.error(\"unexpected end of input\");\n if (s == $bf67dc97ecf5e14f$var$S_TAG) el.setTagName(source.slice(start, p));\n return p;\n case \">\":\n switch(s){\n case $bf67dc97ecf5e14f$var$S_TAG:\n el.setTagName(source.slice(start, p));\n case $bf67dc97ecf5e14f$var$S_ATTR_END:\n case $bf67dc97ecf5e14f$var$S_TAG_SPACE:\n case $bf67dc97ecf5e14f$var$S_TAG_CLOSE:\n break; //normal\n case $bf67dc97ecf5e14f$var$S_ATTR_NOQUOT_VALUE:\n case $bf67dc97ecf5e14f$var$S_ATTR:\n value = source.slice(start, p);\n if (value.slice(-1) === \"/\") {\n el.closed = true;\n value = value.slice(0, -1);\n }\n case $bf67dc97ecf5e14f$var$S_ATTR_SPACE:\n if (s === $bf67dc97ecf5e14f$var$S_ATTR_SPACE) value = attrName;\n if (s == $bf67dc97ecf5e14f$var$S_ATTR_NOQUOT_VALUE) {\n errorHandler.warning('attribute \"' + value + '\" missed quot(\")!');\n addAttribute(attrName, value, start);\n } else {\n if (!$bf67dc97ecf5e14f$require$NAMESPACE.isHTML(currentNSMap[\"\"]) || !value.match(/^(?:disabled|checked|selected)$/i)) errorHandler.warning('attribute \"' + value + '\" missed value!! \"' + value + '\" instead!!');\n addAttribute(value, value, start);\n }\n break;\n case $bf67dc97ecf5e14f$var$S_EQ:\n throw new Error(\"attribute value missed!!\");\n }\n //\t\t\tconsole.log(tagName,tagNamePattern,tagNamePattern.test(tagName))\n return p;\n /*xml space '\\x20' | #x9 | #xD | #xA; */ case \"\\x80\":\n c = \" \";\n default:\n if (c <= \" \") switch(s){\n case $bf67dc97ecf5e14f$var$S_TAG:\n el.setTagName(source.slice(start, p)); //tagName\n s = $bf67dc97ecf5e14f$var$S_TAG_SPACE;\n break;\n case $bf67dc97ecf5e14f$var$S_ATTR:\n attrName = source.slice(start, p);\n s = $bf67dc97ecf5e14f$var$S_ATTR_SPACE;\n break;\n case $bf67dc97ecf5e14f$var$S_ATTR_NOQUOT_VALUE:\n var value = source.slice(start, p);\n errorHandler.warning('attribute \"' + value + '\" missed quot(\")!!');\n addAttribute(attrName, value, start);\n case $bf67dc97ecf5e14f$var$S_ATTR_END:\n s = $bf67dc97ecf5e14f$var$S_TAG_SPACE;\n break;\n }\n else //S_TAG,\tS_ATTR,\tS_EQ,\tS_ATTR_NOQUOT_VALUE\n //S_ATTR_SPACE,\tS_ATTR_END,\tS_TAG_SPACE, S_TAG_CLOSE\n switch(s){\n //case S_TAG:void();break;\n //case S_ATTR:void();break;\n //case S_ATTR_NOQUOT_VALUE:void();break;\n case $bf67dc97ecf5e14f$var$S_ATTR_SPACE:\n var tagName = el.tagName;\n if (!$bf67dc97ecf5e14f$require$NAMESPACE.isHTML(currentNSMap[\"\"]) || !attrName.match(/^(?:disabled|checked|selected)$/i)) errorHandler.warning('attribute \"' + attrName + '\" missed value!! \"' + attrName + '\" instead2!!');\n addAttribute(attrName, attrName, start);\n start = p;\n s = $bf67dc97ecf5e14f$var$S_ATTR;\n break;\n case $bf67dc97ecf5e14f$var$S_ATTR_END:\n errorHandler.warning('attribute space is required\"' + attrName + '\"!!');\n case $bf67dc97ecf5e14f$var$S_TAG_SPACE:\n s = $bf67dc97ecf5e14f$var$S_ATTR;\n start = p;\n break;\n case $bf67dc97ecf5e14f$var$S_EQ:\n s = $bf67dc97ecf5e14f$var$S_ATTR_NOQUOT_VALUE;\n start = p;\n break;\n case $bf67dc97ecf5e14f$var$S_TAG_CLOSE:\n throw new Error(\"elements closed character '/' and '>' must be connected to\");\n }\n } //end outer switch\n //console.log('p++',p)\n p++;\n }\n}\n/**\n * @return true if has new namespace define\n */ function $bf67dc97ecf5e14f$var$appendElement(el, domBuilder, currentNSMap) {\n var tagName = el.tagName;\n var localNSMap = null;\n //var currentNSMap = parseStack[parseStack.length-1].currentNSMap;\n var i = el.length;\n while(i--){\n var a = el[i];\n var qName = a.qName;\n var value = a.value;\n var nsp = qName.indexOf(\":\");\n if (nsp > 0) {\n var prefix = a.prefix = qName.slice(0, nsp);\n var localName = qName.slice(nsp + 1);\n var nsPrefix = prefix === \"xmlns\" && localName;\n } else {\n localName = qName;\n prefix = null;\n nsPrefix = qName === \"xmlns\" && \"\";\n }\n //can not set prefix,because prefix !== ''\n a.localName = localName;\n //prefix == null for no ns prefix attribute\n if (nsPrefix !== false) {\n if (localNSMap == null) {\n localNSMap = {};\n //console.log(currentNSMap,0)\n $bf67dc97ecf5e14f$var$_copy(currentNSMap, currentNSMap = {});\n //console.log(currentNSMap,1)\n }\n currentNSMap[nsPrefix] = localNSMap[nsPrefix] = value;\n a.uri = $bf67dc97ecf5e14f$require$NAMESPACE.XMLNS;\n domBuilder.startPrefixMapping(nsPrefix, value);\n }\n }\n var i = el.length;\n while(i--){\n a = el[i];\n var prefix = a.prefix;\n if (prefix) {\n if (prefix === \"xml\") a.uri = $bf67dc97ecf5e14f$require$NAMESPACE.XML;\n if (prefix !== \"xmlns\") a.uri = currentNSMap[prefix || \"\"];\n }\n }\n var nsp = tagName.indexOf(\":\");\n if (nsp > 0) {\n prefix = el.prefix = tagName.slice(0, nsp);\n localName = el.localName = tagName.slice(nsp + 1);\n } else {\n prefix = null; //important!!\n localName = el.localName = tagName;\n }\n //no prefix element has default namespace\n var ns = el.uri = currentNSMap[prefix || \"\"];\n domBuilder.startElement(ns, localName, tagName, el);\n //endPrefixMapping and startPrefixMapping have not any help for dom builder\n //localNSMap = null\n if (el.closed) {\n domBuilder.endElement(ns, localName, tagName);\n if (localNSMap) {\n for(prefix in localNSMap)if (Object.prototype.hasOwnProperty.call(localNSMap, prefix)) domBuilder.endPrefixMapping(prefix);\n }\n } else {\n el.currentNSMap = currentNSMap;\n el.localNSMap = localNSMap;\n //parseStack.push(el);\n return true;\n }\n}\nfunction $bf67dc97ecf5e14f$var$parseHtmlSpecialContent(source, elStartEnd, tagName, entityReplacer, domBuilder) {\n if (/^(?:script|textarea)$/i.test(tagName)) {\n var elEndStart = source.indexOf(\"\", elStartEnd);\n var text = source.substring(elStartEnd + 1, elEndStart);\n if (/[&<]/.test(text)) {\n if (/^script$/i.test(tagName)) {\n //if(!/\\]\\]>/.test(text)){\n //lexHandler.startCDATA();\n domBuilder.characters(text, 0, text.length);\n //lexHandler.endCDATA();\n return elEndStart;\n //}\n } //}else{//text area\n text = text.replace(/&#?\\w+;/g, entityReplacer);\n domBuilder.characters(text, 0, text.length);\n return elEndStart;\n //}\n }\n }\n return elStartEnd + 1;\n}\nfunction $bf67dc97ecf5e14f$var$fixSelfClosed(source, elStartEnd, tagName, closeMap) {\n //if(tagName in closeMap){\n var pos = closeMap[tagName];\n if (pos == null) {\n //console.log(tagName)\n pos = source.lastIndexOf(\"\");\n if (pos < elStartEnd) pos = source.lastIndexOf(\"\", start + 4);\n //append comment source.substring(4,end)// * (any, kinda silly)\n// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0\n// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0\n// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0\n// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0\n// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0\n// ~0.0.1 --> >=0.0.1 <0.1.0-0\nconst replaceTildes = (comp, options) => {\n return comp\n .trim()\n .split(/\\s+/)\n .map((c) => replaceTilde(c, options))\n .join(' ')\n}\n\nconst replaceTilde = (comp, options) => {\n const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]\n return comp.replace(r, (_, M, m, p, pr) => {\n debug('tilde', comp, _, M, m, p, pr)\n let ret\n\n if (isX(M)) {\n ret = ''\n } else if (isX(m)) {\n ret = `>=${M}.0.0 <${+M + 1}.0.0-0`\n } else if (isX(p)) {\n // ~1.2 == >=1.2.0 <1.3.0-0\n ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`\n } else if (pr) {\n debug('replaceTilde pr', pr)\n ret = `>=${M}.${m}.${p}-${pr\n } <${M}.${+m + 1}.0-0`\n } else {\n // ~1.2.3 == >=1.2.3 <1.3.0-0\n ret = `>=${M}.${m}.${p\n } <${M}.${+m + 1}.0-0`\n }\n\n debug('tilde return', ret)\n return ret\n })\n}\n\n// ^ --> * (any, kinda silly)\n// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0\n// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0\n// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0\n// ^1.2.3 --> >=1.2.3 <2.0.0-0\n// ^1.2.0 --> >=1.2.0 <2.0.0-0\n// ^0.0.1 --> >=0.0.1 <0.0.2-0\n// ^0.1.0 --> >=0.1.0 <0.2.0-0\nconst replaceCarets = (comp, options) => {\n return comp\n .trim()\n .split(/\\s+/)\n .map((c) => replaceCaret(c, options))\n .join(' ')\n}\n\nconst replaceCaret = (comp, options) => {\n debug('caret', comp, options)\n const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]\n const z = options.includePrerelease ? '-0' : ''\n return comp.replace(r, (_, M, m, p, pr) => {\n debug('caret', comp, _, M, m, p, pr)\n let ret\n\n if (isX(M)) {\n ret = ''\n } else if (isX(m)) {\n ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`\n } else if (isX(p)) {\n if (M === '0') {\n ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`\n } else {\n ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`\n }\n } else if (pr) {\n debug('replaceCaret pr', pr)\n if (M === '0') {\n if (m === '0') {\n ret = `>=${M}.${m}.${p}-${pr\n } <${M}.${m}.${+p + 1}-0`\n } else {\n ret = `>=${M}.${m}.${p}-${pr\n } <${M}.${+m + 1}.0-0`\n }\n } else {\n ret = `>=${M}.${m}.${p}-${pr\n } <${+M + 1}.0.0-0`\n }\n } else {\n debug('no pr')\n if (M === '0') {\n if (m === '0') {\n ret = `>=${M}.${m}.${p\n }${z} <${M}.${m}.${+p + 1}-0`\n } else {\n ret = `>=${M}.${m}.${p\n }${z} <${M}.${+m + 1}.0-0`\n }\n } else {\n ret = `>=${M}.${m}.${p\n } <${+M + 1}.0.0-0`\n }\n }\n\n debug('caret return', ret)\n return ret\n })\n}\n\nconst replaceXRanges = (comp, options) => {\n debug('replaceXRanges', comp, options)\n return comp\n .split(/\\s+/)\n .map((c) => replaceXRange(c, options))\n .join(' ')\n}\n\nconst replaceXRange = (comp, options) => {\n comp = comp.trim()\n const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]\n return comp.replace(r, (ret, gtlt, M, m, p, pr) => {\n debug('xRange', comp, ret, gtlt, M, m, p, pr)\n const xM = isX(M)\n const xm = xM || isX(m)\n const xp = xm || isX(p)\n const anyX = xp\n\n if (gtlt === '=' && anyX) {\n gtlt = ''\n }\n\n // if we're including prereleases in the match, then we need\n // to fix this to -0, the lowest possible prerelease value\n pr = options.includePrerelease ? '-0' : ''\n\n if (xM) {\n if (gtlt === '>' || gtlt === '<') {\n // nothing is allowed\n ret = '<0.0.0-0'\n } else {\n // nothing is forbidden\n ret = '*'\n }\n } else if (gtlt && anyX) {\n // we know patch is an x, because we have any x at all.\n // replace X with 0\n if (xm) {\n m = 0\n }\n p = 0\n\n if (gtlt === '>') {\n // >1 => >=2.0.0\n // >1.2 => >=1.3.0\n gtlt = '>='\n if (xm) {\n M = +M + 1\n m = 0\n p = 0\n } else {\n m = +m + 1\n p = 0\n }\n } else if (gtlt === '<=') {\n // <=0.7.x is actually <0.8.0, since any 0.7.x should\n // pass. Similarly, <=7.x is actually <8.0.0, etc.\n gtlt = '<'\n if (xm) {\n M = +M + 1\n } else {\n m = +m + 1\n }\n }\n\n if (gtlt === '<') {\n pr = '-0'\n }\n\n ret = `${gtlt + M}.${m}.${p}${pr}`\n } else if (xm) {\n ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`\n } else if (xp) {\n ret = `>=${M}.${m}.0${pr\n } <${M}.${+m + 1}.0-0`\n }\n\n debug('xRange return', ret)\n\n return ret\n })\n}\n\n// Because * is AND-ed with everything else in the comparator,\n// and '' means \"any version\", just remove the *s entirely.\nconst replaceStars = (comp, options) => {\n debug('replaceStars', comp, options)\n // Looseness is ignored here. star is always as loose as it gets!\n return comp\n .trim()\n .replace(re[t.STAR], '')\n}\n\nconst replaceGTE0 = (comp, options) => {\n debug('replaceGTE0', comp, options)\n return comp\n .trim()\n .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')\n}\n\n// This function is passed to string.replace(re[t.HYPHENRANGE])\n// M, m, patch, prerelease, build\n// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5\n// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do\n// 1.2 - 3.4 => >=1.2.0 <3.5.0-0\nconst hyphenReplace = incPr => ($0,\n from, fM, fm, fp, fpr, fb,\n to, tM, tm, tp, tpr, tb) => {\n if (isX(fM)) {\n from = ''\n } else if (isX(fm)) {\n from = `>=${fM}.0.0${incPr ? '-0' : ''}`\n } else if (isX(fp)) {\n from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`\n } else if (fpr) {\n from = `>=${from}`\n } else {\n from = `>=${from}${incPr ? '-0' : ''}`\n }\n\n if (isX(tM)) {\n to = ''\n } else if (isX(tm)) {\n to = `<${+tM + 1}.0.0-0`\n } else if (isX(tp)) {\n to = `<${tM}.${+tm + 1}.0-0`\n } else if (tpr) {\n to = `<=${tM}.${tm}.${tp}-${tpr}`\n } else if (incPr) {\n to = `<${tM}.${tm}.${+tp + 1}-0`\n } else {\n to = `<=${to}`\n }\n\n return `${from} ${to}`.trim()\n}\n\nconst testSet = (set, version, options) => {\n for (let i = 0; i < set.length; i++) {\n if (!set[i].test(version)) {\n return false\n }\n }\n\n if (version.prerelease.length && !options.includePrerelease) {\n // Find the set of versions that are allowed to have prereleases\n // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0\n // That should allow `1.2.3-pr.2` to pass.\n // However, `1.2.4-alpha.notready` should NOT be allowed,\n // even though it's within the range set by the comparators.\n for (let i = 0; i < set.length; i++) {\n debug(set[i].semver)\n if (set[i].semver === Comparator.ANY) {\n continue\n }\n\n if (set[i].semver.prerelease.length > 0) {\n const allowed = set[i].semver\n if (allowed.major === version.major &&\n allowed.minor === version.minor &&\n allowed.patch === version.patch) {\n return true\n }\n }\n }\n\n // Version has a -pre, but it's not one of the ones we like.\n return false\n }\n\n return true\n}\n","'use strict'\n\n// A linked list to keep track of recently-used-ness\nconst Yallist = require('yallist')\n\nconst MAX = Symbol('max')\nconst LENGTH = Symbol('length')\nconst LENGTH_CALCULATOR = Symbol('lengthCalculator')\nconst ALLOW_STALE = Symbol('allowStale')\nconst MAX_AGE = Symbol('maxAge')\nconst DISPOSE = Symbol('dispose')\nconst NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet')\nconst LRU_LIST = Symbol('lruList')\nconst CACHE = Symbol('cache')\nconst UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet')\n\nconst naiveLength = () => 1\n\n// lruList is a yallist where the head is the youngest\n// item, and the tail is the oldest. the list contains the Hit\n// objects as the entries.\n// Each Hit object has a reference to its Yallist.Node. This\n// never changes.\n//\n// cache is a Map (or PseudoMap) that matches the keys to\n// the Yallist.Node object.\nclass LRUCache {\n constructor (options) {\n if (typeof options === 'number')\n options = { max: options }\n\n if (!options)\n options = {}\n\n if (options.max && (typeof options.max !== 'number' || options.max < 0))\n throw new TypeError('max must be a non-negative number')\n // Kind of weird to have a default max of Infinity, but oh well.\n const max = this[MAX] = options.max || Infinity\n\n const lc = options.length || naiveLength\n this[LENGTH_CALCULATOR] = (typeof lc !== 'function') ? naiveLength : lc\n this[ALLOW_STALE] = options.stale || false\n if (options.maxAge && typeof options.maxAge !== 'number')\n throw new TypeError('maxAge must be a number')\n this[MAX_AGE] = options.maxAge || 0\n this[DISPOSE] = options.dispose\n this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false\n this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false\n this.reset()\n }\n\n // resize the cache when the max changes.\n set max (mL) {\n if (typeof mL !== 'number' || mL < 0)\n throw new TypeError('max must be a non-negative number')\n\n this[MAX] = mL || Infinity\n trim(this)\n }\n get max () {\n return this[MAX]\n }\n\n set allowStale (allowStale) {\n this[ALLOW_STALE] = !!allowStale\n }\n get allowStale () {\n return this[ALLOW_STALE]\n }\n\n set maxAge (mA) {\n if (typeof mA !== 'number')\n throw new TypeError('maxAge must be a non-negative number')\n\n this[MAX_AGE] = mA\n trim(this)\n }\n get maxAge () {\n return this[MAX_AGE]\n }\n\n // resize the cache when the lengthCalculator changes.\n set lengthCalculator (lC) {\n if (typeof lC !== 'function')\n lC = naiveLength\n\n if (lC !== this[LENGTH_CALCULATOR]) {\n this[LENGTH_CALCULATOR] = lC\n this[LENGTH] = 0\n this[LRU_LIST].forEach(hit => {\n hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key)\n this[LENGTH] += hit.length\n })\n }\n trim(this)\n }\n get lengthCalculator () { return this[LENGTH_CALCULATOR] }\n\n get length () { return this[LENGTH] }\n get itemCount () { return this[LRU_LIST].length }\n\n rforEach (fn, thisp) {\n thisp = thisp || this\n for (let walker = this[LRU_LIST].tail; walker !== null;) {\n const prev = walker.prev\n forEachStep(this, fn, walker, thisp)\n walker = prev\n }\n }\n\n forEach (fn, thisp) {\n thisp = thisp || this\n for (let walker = this[LRU_LIST].head; walker !== null;) {\n const next = walker.next\n forEachStep(this, fn, walker, thisp)\n walker = next\n }\n }\n\n keys () {\n return this[LRU_LIST].toArray().map(k => k.key)\n }\n\n values () {\n return this[LRU_LIST].toArray().map(k => k.value)\n }\n\n reset () {\n if (this[DISPOSE] &&\n this[LRU_LIST] &&\n this[LRU_LIST].length) {\n this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value))\n }\n\n this[CACHE] = new Map() // hash of items by key\n this[LRU_LIST] = new Yallist() // list of items in order of use recency\n this[LENGTH] = 0 // length of items in the list\n }\n\n dump () {\n return this[LRU_LIST].map(hit =>\n isStale(this, hit) ? false : {\n k: hit.key,\n v: hit.value,\n e: hit.now + (hit.maxAge || 0)\n }).toArray().filter(h => h)\n }\n\n dumpLru () {\n return this[LRU_LIST]\n }\n\n set (key, value, maxAge) {\n maxAge = maxAge || this[MAX_AGE]\n\n if (maxAge && typeof maxAge !== 'number')\n throw new TypeError('maxAge must be a number')\n\n const now = maxAge ? Date.now() : 0\n const len = this[LENGTH_CALCULATOR](value, key)\n\n if (this[CACHE].has(key)) {\n if (len > this[MAX]) {\n del(this, this[CACHE].get(key))\n return false\n }\n\n const node = this[CACHE].get(key)\n const item = node.value\n\n // dispose of the old one before overwriting\n // split out into 2 ifs for better coverage tracking\n if (this[DISPOSE]) {\n if (!this[NO_DISPOSE_ON_SET])\n this[DISPOSE](key, item.value)\n }\n\n item.now = now\n item.maxAge = maxAge\n item.value = value\n this[LENGTH] += len - item.length\n item.length = len\n this.get(key)\n trim(this)\n return true\n }\n\n const hit = new Entry(key, value, len, now, maxAge)\n\n // oversized objects fall out of cache automatically.\n if (hit.length > this[MAX]) {\n if (this[DISPOSE])\n this[DISPOSE](key, value)\n\n return false\n }\n\n this[LENGTH] += hit.length\n this[LRU_LIST].unshift(hit)\n this[CACHE].set(key, this[LRU_LIST].head)\n trim(this)\n return true\n }\n\n has (key) {\n if (!this[CACHE].has(key)) return false\n const hit = this[CACHE].get(key).value\n return !isStale(this, hit)\n }\n\n get (key) {\n return get(this, key, true)\n }\n\n peek (key) {\n return get(this, key, false)\n }\n\n pop () {\n const node = this[LRU_LIST].tail\n if (!node)\n return null\n\n del(this, node)\n return node.value\n }\n\n del (key) {\n del(this, this[CACHE].get(key))\n }\n\n load (arr) {\n // reset the cache\n this.reset()\n\n const now = Date.now()\n // A previous serialized cache has the most recent items first\n for (let l = arr.length - 1; l >= 0; l--) {\n const hit = arr[l]\n const expiresAt = hit.e || 0\n if (expiresAt === 0)\n // the item was created without expiration in a non aged cache\n this.set(hit.k, hit.v)\n else {\n const maxAge = expiresAt - now\n // dont add already expired items\n if (maxAge > 0) {\n this.set(hit.k, hit.v, maxAge)\n }\n }\n }\n }\n\n prune () {\n this[CACHE].forEach((value, key) => get(this, key, false))\n }\n}\n\nconst get = (self, key, doUse) => {\n const node = self[CACHE].get(key)\n if (node) {\n const hit = node.value\n if (isStale(self, hit)) {\n del(self, node)\n if (!self[ALLOW_STALE])\n return undefined\n } else {\n if (doUse) {\n if (self[UPDATE_AGE_ON_GET])\n node.value.now = Date.now()\n self[LRU_LIST].unshiftNode(node)\n }\n }\n return hit.value\n }\n}\n\nconst isStale = (self, hit) => {\n if (!hit || (!hit.maxAge && !self[MAX_AGE]))\n return false\n\n const diff = Date.now() - hit.now\n return hit.maxAge ? diff > hit.maxAge\n : self[MAX_AGE] && (diff > self[MAX_AGE])\n}\n\nconst trim = self => {\n if (self[LENGTH] > self[MAX]) {\n for (let walker = self[LRU_LIST].tail;\n self[LENGTH] > self[MAX] && walker !== null;) {\n // We know that we're about to delete this one, and also\n // what the next least recently used key will be, so just\n // go ahead and set it now.\n const prev = walker.prev\n del(self, walker)\n walker = prev\n }\n }\n}\n\nconst del = (self, node) => {\n if (node) {\n const hit = node.value\n if (self[DISPOSE])\n self[DISPOSE](hit.key, hit.value)\n\n self[LENGTH] -= hit.length\n self[CACHE].delete(hit.key)\n self[LRU_LIST].removeNode(node)\n }\n}\n\nclass Entry {\n constructor (key, value, length, now, maxAge) {\n this.key = key\n this.value = value\n this.length = length\n this.now = now\n this.maxAge = maxAge || 0\n }\n}\n\nconst forEachStep = (self, fn, node, thisp) => {\n let hit = node.value\n if (isStale(self, hit)) {\n del(self, node)\n if (!self[ALLOW_STALE])\n hit = undefined\n }\n if (hit)\n fn.call(thisp, hit.value, hit.key, self)\n}\n\nmodule.exports = LRUCache\n","'use strict'\nmodule.exports = Yallist\n\nYallist.Node = Node\nYallist.create = Yallist\n\nfunction Yallist (list) {\n var self = this\n if (!(self instanceof Yallist)) {\n self = new Yallist()\n }\n\n self.tail = null\n self.head = null\n self.length = 0\n\n if (list && typeof list.forEach === 'function') {\n list.forEach(function (item) {\n self.push(item)\n })\n } else if (arguments.length > 0) {\n for (var i = 0, l = arguments.length; i < l; i++) {\n self.push(arguments[i])\n }\n }\n\n return self\n}\n\nYallist.prototype.removeNode = function (node) {\n if (node.list !== this) {\n throw new Error('removing node which does not belong to this list')\n }\n\n var next = node.next\n var prev = node.prev\n\n if (next) {\n next.prev = prev\n }\n\n if (prev) {\n prev.next = next\n }\n\n if (node === this.head) {\n this.head = next\n }\n if (node === this.tail) {\n this.tail = prev\n }\n\n node.list.length--\n node.next = null\n node.prev = null\n node.list = null\n\n return next\n}\n\nYallist.prototype.unshiftNode = function (node) {\n if (node === this.head) {\n return\n }\n\n if (node.list) {\n node.list.removeNode(node)\n }\n\n var head = this.head\n node.list = this\n node.next = head\n if (head) {\n head.prev = node\n }\n\n this.head = node\n if (!this.tail) {\n this.tail = node\n }\n this.length++\n}\n\nYallist.prototype.pushNode = function (node) {\n if (node === this.tail) {\n return\n }\n\n if (node.list) {\n node.list.removeNode(node)\n }\n\n var tail = this.tail\n node.list = this\n node.prev = tail\n if (tail) {\n tail.next = node\n }\n\n this.tail = node\n if (!this.head) {\n this.head = node\n }\n this.length++\n}\n\nYallist.prototype.push = function () {\n for (var i = 0, l = arguments.length; i < l; i++) {\n push(this, arguments[i])\n }\n return this.length\n}\n\nYallist.prototype.unshift = function () {\n for (var i = 0, l = arguments.length; i < l; i++) {\n unshift(this, arguments[i])\n }\n return this.length\n}\n\nYallist.prototype.pop = function () {\n if (!this.tail) {\n return undefined\n }\n\n var res = this.tail.value\n this.tail = this.tail.prev\n if (this.tail) {\n this.tail.next = null\n } else {\n this.head = null\n }\n this.length--\n return res\n}\n\nYallist.prototype.shift = function () {\n if (!this.head) {\n return undefined\n }\n\n var res = this.head.value\n this.head = this.head.next\n if (this.head) {\n this.head.prev = null\n } else {\n this.tail = null\n }\n this.length--\n return res\n}\n\nYallist.prototype.forEach = function (fn, thisp) {\n thisp = thisp || this\n for (var walker = this.head, i = 0; walker !== null; i++) {\n fn.call(thisp, walker.value, i, this)\n walker = walker.next\n }\n}\n\nYallist.prototype.forEachReverse = function (fn, thisp) {\n thisp = thisp || this\n for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {\n fn.call(thisp, walker.value, i, this)\n walker = walker.prev\n }\n}\n\nYallist.prototype.get = function (n) {\n for (var i = 0, walker = this.head; walker !== null && i < n; i++) {\n // abort out of the list early if we hit a cycle\n walker = walker.next\n }\n if (i === n && walker !== null) {\n return walker.value\n }\n}\n\nYallist.prototype.getReverse = function (n) {\n for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {\n // abort out of the list early if we hit a cycle\n walker = walker.prev\n }\n if (i === n && walker !== null) {\n return walker.value\n }\n}\n\nYallist.prototype.map = function (fn, thisp) {\n thisp = thisp || this\n var res = new Yallist()\n for (var walker = this.head; walker !== null;) {\n res.push(fn.call(thisp, walker.value, this))\n walker = walker.next\n }\n return res\n}\n\nYallist.prototype.mapReverse = function (fn, thisp) {\n thisp = thisp || this\n var res = new Yallist()\n for (var walker = this.tail; walker !== null;) {\n res.push(fn.call(thisp, walker.value, this))\n walker = walker.prev\n }\n return res\n}\n\nYallist.prototype.reduce = function (fn, initial) {\n var acc\n var walker = this.head\n if (arguments.length > 1) {\n acc = initial\n } else if (this.head) {\n walker = this.head.next\n acc = this.head.value\n } else {\n throw new TypeError('Reduce of empty list with no initial value')\n }\n\n for (var i = 0; walker !== null; i++) {\n acc = fn(acc, walker.value, i)\n walker = walker.next\n }\n\n return acc\n}\n\nYallist.prototype.reduceReverse = function (fn, initial) {\n var acc\n var walker = this.tail\n if (arguments.length > 1) {\n acc = initial\n } else if (this.tail) {\n walker = this.tail.prev\n acc = this.tail.value\n } else {\n throw new TypeError('Reduce of empty list with no initial value')\n }\n\n for (var i = this.length - 1; walker !== null; i--) {\n acc = fn(acc, walker.value, i)\n walker = walker.prev\n }\n\n return acc\n}\n\nYallist.prototype.toArray = function () {\n var arr = new Array(this.length)\n for (var i = 0, walker = this.head; walker !== null; i++) {\n arr[i] = walker.value\n walker = walker.next\n }\n return arr\n}\n\nYallist.prototype.toArrayReverse = function () {\n var arr = new Array(this.length)\n for (var i = 0, walker = this.tail; walker !== null; i++) {\n arr[i] = walker.value\n walker = walker.prev\n }\n return arr\n}\n\nYallist.prototype.slice = function (from, to) {\n to = to || this.length\n if (to < 0) {\n to += this.length\n }\n from = from || 0\n if (from < 0) {\n from += this.length\n }\n var ret = new Yallist()\n if (to < from || to < 0) {\n return ret\n }\n if (from < 0) {\n from = 0\n }\n if (to > this.length) {\n to = this.length\n }\n for (var i = 0, walker = this.head; walker !== null && i < from; i++) {\n walker = walker.next\n }\n for (; walker !== null && i < to; i++, walker = walker.next) {\n ret.push(walker.value)\n }\n return ret\n}\n\nYallist.prototype.sliceReverse = function (from, to) {\n to = to || this.length\n if (to < 0) {\n to += this.length\n }\n from = from || 0\n if (from < 0) {\n from += this.length\n }\n var ret = new Yallist()\n if (to < from || to < 0) {\n return ret\n }\n if (from < 0) {\n from = 0\n }\n if (to > this.length) {\n to = this.length\n }\n for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {\n walker = walker.prev\n }\n for (; walker !== null && i > from; i--, walker = walker.prev) {\n ret.push(walker.value)\n }\n return ret\n}\n\nYallist.prototype.splice = function (start, deleteCount, ...nodes) {\n if (start > this.length) {\n start = this.length - 1\n }\n if (start < 0) {\n start = this.length + start;\n }\n\n for (var i = 0, walker = this.head; walker !== null && i < start; i++) {\n walker = walker.next\n }\n\n var ret = []\n for (var i = 0; walker && i < deleteCount; i++) {\n ret.push(walker.value)\n walker = this.removeNode(walker)\n }\n if (walker === null) {\n walker = this.tail\n }\n\n if (walker !== this.head && walker !== this.tail) {\n walker = walker.prev\n }\n\n for (var i = 0; i < nodes.length; i++) {\n walker = insert(this, walker, nodes[i])\n }\n return ret;\n}\n\nYallist.prototype.reverse = function () {\n var head = this.head\n var tail = this.tail\n for (var walker = head; walker !== null; walker = walker.prev) {\n var p = walker.prev\n walker.prev = walker.next\n walker.next = p\n }\n this.head = tail\n this.tail = head\n return this\n}\n\nfunction insert (self, node, value) {\n var inserted = node === self.head ?\n new Node(value, null, node, self) :\n new Node(value, node, node.next, self)\n\n if (inserted.next === null) {\n self.tail = inserted\n }\n if (inserted.prev === null) {\n self.head = inserted\n }\n\n self.length++\n\n return inserted\n}\n\nfunction push (self, item) {\n self.tail = new Node(item, self.tail, null, self)\n if (!self.head) {\n self.head = self.tail\n }\n self.length++\n}\n\nfunction unshift (self, item) {\n self.head = new Node(item, null, self.head, self)\n if (!self.tail) {\n self.tail = self.head\n }\n self.length++\n}\n\nfunction Node (value, prev, next, list) {\n if (!(this instanceof Node)) {\n return new Node(value, prev, next, list)\n }\n\n this.list = list\n this.value = value\n\n if (prev) {\n prev.next = this\n this.prev = prev\n } else {\n this.prev = null\n }\n\n if (next) {\n next.prev = this\n this.next = next\n } else {\n this.next = null\n }\n}\n\ntry {\n // add if support for Symbol.iterator is present\n require('./iterator.js')(Yallist)\n} catch (er) {}\n","'use strict'\nmodule.exports = function (Yallist) {\n Yallist.prototype[Symbol.iterator] = function* () {\n for (let walker = this.head; walker; walker = walker.next) {\n yield walker.value\n }\n }\n}\n","const Range = require('../classes/range')\nconst satisfies = (version, range, options) => {\n try {\n range = new Range(range, options)\n } catch (er) {\n return false\n }\n return range.test(version)\n}\nmodule.exports = satisfies\n","const Range = require('../classes/range')\n\n// Mostly just for testing and legacy API reasons\nconst toComparators = (range, options) =>\n new Range(range, options).set\n .map(comp => comp.map(c => c.value).join(' ').trim().split(' '))\n\nmodule.exports = toComparators\n","const SemVer = require('../classes/semver')\nconst Range = require('../classes/range')\n\nconst maxSatisfying = (versions, range, options) => {\n let max = null\n let maxSV = null\n let rangeObj = null\n try {\n rangeObj = new Range(range, options)\n } catch (er) {\n return null\n }\n versions.forEach((v) => {\n if (rangeObj.test(v)) {\n // satisfies(v, range, options)\n if (!max || maxSV.compare(v) === -1) {\n // compare(max, v, true)\n max = v\n maxSV = new SemVer(max, options)\n }\n }\n })\n return max\n}\nmodule.exports = maxSatisfying\n","const SemVer = require('../classes/semver')\nconst Range = require('../classes/range')\nconst minSatisfying = (versions, range, options) => {\n let min = null\n let minSV = null\n let rangeObj = null\n try {\n rangeObj = new Range(range, options)\n } catch (er) {\n return null\n }\n versions.forEach((v) => {\n if (rangeObj.test(v)) {\n // satisfies(v, range, options)\n if (!min || minSV.compare(v) === 1) {\n // compare(min, v, true)\n min = v\n minSV = new SemVer(min, options)\n }\n }\n })\n return min\n}\nmodule.exports = minSatisfying\n","const SemVer = require('../classes/semver')\nconst Range = require('../classes/range')\nconst gt = require('../functions/gt')\n\nconst minVersion = (range, loose) => {\n range = new Range(range, loose)\n\n let minver = new SemVer('0.0.0')\n if (range.test(minver)) {\n return minver\n }\n\n minver = new SemVer('0.0.0-0')\n if (range.test(minver)) {\n return minver\n }\n\n minver = null\n for (let i = 0; i < range.set.length; ++i) {\n const comparators = range.set[i]\n\n let setMin = null\n comparators.forEach((comparator) => {\n // Clone to avoid manipulating the comparator's semver object.\n const compver = new SemVer(comparator.semver.version)\n switch (comparator.operator) {\n case '>':\n if (compver.prerelease.length === 0) {\n compver.patch++\n } else {\n compver.prerelease.push(0)\n }\n compver.raw = compver.format()\n /* fallthrough */\n case '':\n case '>=':\n if (!setMin || gt(compver, setMin)) {\n setMin = compver\n }\n break\n case '<':\n case '<=':\n /* Ignore maximum versions */\n break\n /* istanbul ignore next */\n default:\n throw new Error(`Unexpected operation: ${comparator.operator}`)\n }\n })\n if (setMin && (!minver || gt(minver, setMin))) {\n minver = setMin\n }\n }\n\n if (minver && range.test(minver)) {\n return minver\n }\n\n return null\n}\nmodule.exports = minVersion\n","const Range = require('../classes/range')\nconst validRange = (range, options) => {\n try {\n // Return '*' instead of '' so that truthiness works.\n // This will throw if it's invalid anyway\n return new Range(range, options).range || '*'\n } catch (er) {\n return null\n }\n}\nmodule.exports = validRange\n","const SemVer = require('../classes/semver')\nconst Comparator = require('../classes/comparator')\nconst { ANY } = Comparator\nconst Range = require('../classes/range')\nconst satisfies = require('../functions/satisfies')\nconst gt = require('../functions/gt')\nconst lt = require('../functions/lt')\nconst lte = require('../functions/lte')\nconst gte = require('../functions/gte')\n\nconst outside = (version, range, hilo, options) => {\n version = new SemVer(version, options)\n range = new Range(range, options)\n\n let gtfn, ltefn, ltfn, comp, ecomp\n switch (hilo) {\n case '>':\n gtfn = gt\n ltefn = lte\n ltfn = lt\n comp = '>'\n ecomp = '>='\n break\n case '<':\n gtfn = lt\n ltefn = gte\n ltfn = gt\n comp = '<'\n ecomp = '<='\n break\n default:\n throw new TypeError('Must provide a hilo val of \"<\" or \">\"')\n }\n\n // If it satisfies the range it is not outside\n if (satisfies(version, range, options)) {\n return false\n }\n\n // From now on, variable terms are as if we're in \"gtr\" mode.\n // but note that everything is flipped for the \"ltr\" function.\n\n for (let i = 0; i < range.set.length; ++i) {\n const comparators = range.set[i]\n\n let high = null\n let low = null\n\n comparators.forEach((comparator) => {\n if (comparator.semver === ANY) {\n comparator = new Comparator('>=0.0.0')\n }\n high = high || comparator\n low = low || comparator\n if (gtfn(comparator.semver, high.semver, options)) {\n high = comparator\n } else if (ltfn(comparator.semver, low.semver, options)) {\n low = comparator\n }\n })\n\n // If the edge version comparator has a operator then our version\n // isn't outside it\n if (high.operator === comp || high.operator === ecomp) {\n return false\n }\n\n // If the lowest version comparator has an operator and our version\n // is less than it then it isn't higher than the range\n if ((!low.operator || low.operator === comp) &&\n ltefn(version, low.semver)) {\n return false\n } else if (low.operator === ecomp && ltfn(version, low.semver)) {\n return false\n }\n }\n return true\n}\n\nmodule.exports = outside\n","// Determine if version is greater than all the versions possible in the range.\nconst outside = require('./outside')\nconst gtr = (version, range, options) => outside(version, range, '>', options)\nmodule.exports = gtr\n","const outside = require('./outside')\n// Determine if version is less than all the versions possible in the range\nconst ltr = (version, range, options) => outside(version, range, '<', options)\nmodule.exports = ltr\n","const Range = require('../classes/range')\nconst intersects = (r1, r2, options) => {\n r1 = new Range(r1, options)\n r2 = new Range(r2, options)\n return r1.intersects(r2, options)\n}\nmodule.exports = intersects\n","// given a set of versions and a range, create a \"simplified\" range\n// that includes the same versions that the original range does\n// If the original range is shorter than the simplified one, return that.\nconst satisfies = require('../functions/satisfies.js')\nconst compare = require('../functions/compare.js')\nmodule.exports = (versions, range, options) => {\n const set = []\n let first = null\n let prev = null\n const v = versions.sort((a, b) => compare(a, b, options))\n for (const version of v) {\n const included = satisfies(version, range, options)\n if (included) {\n prev = version\n if (!first) {\n first = version\n }\n } else {\n if (prev) {\n set.push([first, prev])\n }\n prev = null\n first = null\n }\n }\n if (first) {\n set.push([first, null])\n }\n\n const ranges = []\n for (const [min, max] of set) {\n if (min === max) {\n ranges.push(min)\n } else if (!max && min === v[0]) {\n ranges.push('*')\n } else if (!max) {\n ranges.push(`>=${min}`)\n } else if (min === v[0]) {\n ranges.push(`<=${max}`)\n } else {\n ranges.push(`${min} - ${max}`)\n }\n }\n const simplified = ranges.join(' || ')\n const original = typeof range.raw === 'string' ? range.raw : String(range)\n return simplified.length < original.length ? simplified : range\n}\n","const Range = require('../classes/range.js')\nconst Comparator = require('../classes/comparator.js')\nconst { ANY } = Comparator\nconst satisfies = require('../functions/satisfies.js')\nconst compare = require('../functions/compare.js')\n\n// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:\n// - Every simple range `r1, r2, ...` is a null set, OR\n// - Every simple range `r1, r2, ...` which is not a null set is a subset of\n// some `R1, R2, ...`\n//\n// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:\n// - If c is only the ANY comparator\n// - If C is only the ANY comparator, return true\n// - Else if in prerelease mode, return false\n// - else replace c with `[>=0.0.0]`\n// - If C is only the ANY comparator\n// - if in prerelease mode, return true\n// - else replace C with `[>=0.0.0]`\n// - Let EQ be the set of = comparators in c\n// - If EQ is more than one, return true (null set)\n// - Let GT be the highest > or >= comparator in c\n// - Let LT be the lowest < or <= comparator in c\n// - If GT and LT, and GT.semver > LT.semver, return true (null set)\n// - If any C is a = range, and GT or LT are set, return false\n// - If EQ\n// - If GT, and EQ does not satisfy GT, return true (null set)\n// - If LT, and EQ does not satisfy LT, return true (null set)\n// - If EQ satisfies every C, return true\n// - Else return false\n// - If GT\n// - If GT.semver is lower than any > or >= comp in C, return false\n// - If GT is >=, and GT.semver does not satisfy every C, return false\n// - If GT.semver has a prerelease, and not in prerelease mode\n// - If no C has a prerelease and the GT.semver tuple, return false\n// - If LT\n// - If LT.semver is greater than any < or <= comp in C, return false\n// - If LT is <=, and LT.semver does not satisfy every C, return false\n// - If GT.semver has a prerelease, and not in prerelease mode\n// - If no C has a prerelease and the LT.semver tuple, return false\n// - Else return true\n\nconst subset = (sub, dom, options = {}) => {\n if (sub === dom) {\n return true\n }\n\n sub = new Range(sub, options)\n dom = new Range(dom, options)\n let sawNonNull = false\n\n OUTER: for (const simpleSub of sub.set) {\n for (const simpleDom of dom.set) {\n const isSub = simpleSubset(simpleSub, simpleDom, options)\n sawNonNull = sawNonNull || isSub !== null\n if (isSub) {\n continue OUTER\n }\n }\n // the null set is a subset of everything, but null simple ranges in\n // a complex range should be ignored. so if we saw a non-null range,\n // then we know this isn't a subset, but if EVERY simple range was null,\n // then it is a subset.\n if (sawNonNull) {\n return false\n }\n }\n return true\n}\n\nconst minimumVersionWithPreRelease = [new Comparator('>=0.0.0-0')]\nconst minimumVersion = [new Comparator('>=0.0.0')]\n\nconst simpleSubset = (sub, dom, options) => {\n if (sub === dom) {\n return true\n }\n\n if (sub.length === 1 && sub[0].semver === ANY) {\n if (dom.length === 1 && dom[0].semver === ANY) {\n return true\n } else if (options.includePrerelease) {\n sub = minimumVersionWithPreRelease\n } else {\n sub = minimumVersion\n }\n }\n\n if (dom.length === 1 && dom[0].semver === ANY) {\n if (options.includePrerelease) {\n return true\n } else {\n dom = minimumVersion\n }\n }\n\n const eqSet = new Set()\n let gt, lt\n for (const c of sub) {\n if (c.operator === '>' || c.operator === '>=') {\n gt = higherGT(gt, c, options)\n } else if (c.operator === '<' || c.operator === '<=') {\n lt = lowerLT(lt, c, options)\n } else {\n eqSet.add(c.semver)\n }\n }\n\n if (eqSet.size > 1) {\n return null\n }\n\n let gtltComp\n if (gt && lt) {\n gtltComp = compare(gt.semver, lt.semver, options)\n if (gtltComp > 0) {\n return null\n } else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) {\n return null\n }\n }\n\n // will iterate one or zero times\n for (const eq of eqSet) {\n if (gt && !satisfies(eq, String(gt), options)) {\n return null\n }\n\n if (lt && !satisfies(eq, String(lt), options)) {\n return null\n }\n\n for (const c of dom) {\n if (!satisfies(eq, String(c), options)) {\n return false\n }\n }\n\n return true\n }\n\n let higher, lower\n let hasDomLT, hasDomGT\n // if the subset has a prerelease, we need a comparator in the superset\n // with the same tuple and a prerelease, or it's not a subset\n let needDomLTPre = lt &&\n !options.includePrerelease &&\n lt.semver.prerelease.length ? lt.semver : false\n let needDomGTPre = gt &&\n !options.includePrerelease &&\n gt.semver.prerelease.length ? gt.semver : false\n // exception: <1.2.3-0 is the same as <1.2.3\n if (needDomLTPre && needDomLTPre.prerelease.length === 1 &&\n lt.operator === '<' && needDomLTPre.prerelease[0] === 0) {\n needDomLTPre = false\n }\n\n for (const c of dom) {\n hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>='\n hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<='\n if (gt) {\n if (needDomGTPre) {\n if (c.semver.prerelease && c.semver.prerelease.length &&\n c.semver.major === needDomGTPre.major &&\n c.semver.minor === needDomGTPre.minor &&\n c.semver.patch === needDomGTPre.patch) {\n needDomGTPre = false\n }\n }\n if (c.operator === '>' || c.operator === '>=') {\n higher = higherGT(gt, c, options)\n if (higher === c && higher !== gt) {\n return false\n }\n } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options)) {\n return false\n }\n }\n if (lt) {\n if (needDomLTPre) {\n if (c.semver.prerelease && c.semver.prerelease.length &&\n c.semver.major === needDomLTPre.major &&\n c.semver.minor === needDomLTPre.minor &&\n c.semver.patch === needDomLTPre.patch) {\n needDomLTPre = false\n }\n }\n if (c.operator === '<' || c.operator === '<=') {\n lower = lowerLT(lt, c, options)\n if (lower === c && lower !== lt) {\n return false\n }\n } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options)) {\n return false\n }\n }\n if (!c.operator && (lt || gt) && gtltComp !== 0) {\n return false\n }\n }\n\n // if there was a < or >, and nothing in the dom, then must be false\n // UNLESS it was limited by another range in the other direction.\n // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0\n if (gt && hasDomLT && !lt && gtltComp !== 0) {\n return false\n }\n\n if (lt && hasDomGT && !gt && gtltComp !== 0) {\n return false\n }\n\n // we needed a prerelease range in a specific tuple, but didn't get one\n // then this isn't a subset. eg >=1.2.3-pre is not a subset of >=1.0.0,\n // because it includes prereleases in the 1.2.3 tuple\n if (needDomGTPre || needDomLTPre) {\n return false\n }\n\n return true\n}\n\n// >=1.2.3 is lower than >1.2.3\nconst higherGT = (a, b, options) => {\n if (!a) {\n return b\n }\n const comp = compare(a.semver, b.semver, options)\n return comp > 0 ? a\n : comp < 0 ? b\n : b.operator === '>' && a.operator === '>=' ? b\n : a\n}\n\n// <=1.2.3 is higher than <1.2.3\nconst lowerLT = (a, b, options) => {\n if (!a) {\n return b\n }\n const comp = compare(a.semver, b.semver, options)\n return comp < 0 ? a\n : comp > 0 ? b\n : b.operator === '<' && a.operator === '<=' ? b\n : a\n}\n\nmodule.exports = subset\n","'use strict';\n\nvar matchOperatorsRe = /[|\\\\{}()[\\]^$+*?.]/g;\n\nmodule.exports = function (str) {\n\tif (typeof str !== 'string') {\n\t\tthrow new TypeError('Expected a string');\n\t}\n\n\treturn str.replace(matchOperatorsRe, '\\\\$&');\n};\n","import fs, {promises as fsPromises} from 'node:fs';\n\nexport async function pathExists(path) {\n\ttry {\n\t\tawait fsPromises.access(path);\n\t\treturn true;\n\t} catch {\n\t\treturn false;\n\t}\n}\n\nexport function pathExistsSync(path) {\n\ttry {\n\t\tfs.accessSync(path);\n\t\treturn true;\n\t} catch {\n\t\treturn false;\n\t}\n}\n",null,"import { basename, extname } from \"path\"\n\n/**\n * Get the name of the given file path.\n *\n * By default the file extension is included in the returned name. To remove the extension, set the second parameter to `false`.\n *\n * @example\n *\n * ```js\n * import { name } from \"patha\"\n *\n * name(\"path/to/file.md\") // gives \"file.md\"\n *\n * name(\"path/to/file.md\", false) // gives \"file\"\n * ```\n *\n * @param path The given file path\n * @param includeExtension If the name should include the file extension as well\n * @returns The base name without the extension\n */\nexport function name(path: string, includeExtension: boolean = true) {\n if (includeExtension) {\n return basename(path)\n } else {\n return basename(path, extname(path))\n }\n}\n","import { normalize, sep } from \"path\"\nimport escapeRegexp from \"escape-string-regexp\"\n\n/**\n * Normalizes the path and removes the trailing slashes.\n *\n * @example\n *\n * ```js\n * import { normalize, normalizeTrim } from \"patha\"\n *\n * normalizeTrim(\"/foo/bar//baz/asdf/hello/../\") // gives \"/foo/bar/baz/asdf\"\n *\n * normalize(\"/foo/bar//baz/asdf/hello/../\") // gives \"/foo/bar/baz/asdf/\"\n * ```\n *\n * @param path The given file path\n * @returns The normalized and trimmed file path\n */\nexport function normalizeTrim(path: string) {\n return normalize(path).replace(new RegExp(`${escapeRegexp(sep)}$`), \"\")\n}\n","/**\n * Add bin extension to the given binary name.\n *\n * @example\n *\n * ```js\n * import { addExeExt } from \"patha\"\n *\n * addExeExt(\"path/to/file-name\") // gives \"path/to/file-name.exe\" on Windows and \"path/to/file-name\" on others\n * ```\n *\n * @param name The name you want to add the shell extension to\n * @param win_ext Defaults to `.exe` on Windows\n * @param other_ext Defaults to `\"\"` On other platforms.\n */\nexport function addExeExt(name: string, win_ext = \".exe\", other_ext = \"\") {\n if (process.platform === \"win32\") {\n return `${name}${win_ext}`\n }\n return `${name}${other_ext}`\n}\n","import { basename, dirname, extname, join } from \"path\"\n\n/**\n * Adds a prefix to the start of the name of the given path\n *\n * @example\n *\n * ```js\n * import { addNamePrefix } from \"patha\"\n *\n * addNamePrefix(\"path/to/file-name.ext\", \"new-\") // gives \"path/to/new-file-name.ext\"\n * ```\n *\n * @param path The given file path\n * @param prefix The prefix to add to the start of the file name\n * @returns The path with a prefix added to its file name\n */\nexport function addNamePrefix(path: string, prefix: string) {\n // get the extension and the file name\n const ext = extname(path)\n const nameWithoutExt = basename(path, ext)\n\n // add the name prefix\n const NameWithPrefix = `${prefix}${nameWithoutExt}${ext}`\n\n // add the dirname back\n return join(dirname(path), NameWithPrefix)\n}\n","import { basename, dirname, extname, join } from \"path\"\n\n/**\n * Adds a suffix to the end of the name of the given path\n *\n * @example\n *\n * ```js\n * import { addNameSuffix } from \"patha\"\n *\n * addNameSuffix(\"path/to/file-name.ext\", \"-old\") // gives \"path/to/file-name-old.ext\"\n *\n * addNameSuffix(\"path/to/file-name.ext\", \".test\") // gives \"path/to/file-name.test.ext\"\n * ```\n *\n * @param path The given file path\n * @param suffix The suffix to add to the end of the file name\n * @returns The path with a suffix added to its file name\n */\nexport function addNameSuffix(path: string, suffix: string) {\n // get the extension and the file name\n const ext = extname(path)\n const nameWithoutExt = basename(path, ext)\n\n // add the name suffix\n const NameWithSuffix = `${nameWithoutExt}${suffix}${ext}`\n\n // add the dirname back\n return join(dirname(path), NameWithSuffix)\n}\n","/**\n * Add a native shell extension to the given name.\n *\n * @example\n *\n * ```js\n * import { addShExt } from \"patha\"\n *\n * addShExt(\"path/to/file-name\") // gives \"path/to/file-name.cmd\" on Windows and \"path/to/file-name.sh\" on others\n *\n * addShExt(\"path/to/file-name\", \".bat\") // gives \"path/to/file-name.bat\" on Windows and \"path/to/file-name.sh\" on others\n * ```\n *\n * @param name The name you want to add the shell extension to\n * @param win_ext `.cmd` on Windows\n * @param other_ext `.sh` On others.\n * @returns The file path with the shell extension added\n */\nexport function addShExt(name: string, win_ext = \".cmd\", other_ext = \".sh\") {\n if (process.platform === \"win32\") {\n return `${name}${win_ext}`\n }\n return `${name}${other_ext}`\n}\n","/**\n * Prefix a `./` for unix shell and nothing for `cmd`.\n *\n * @example\n *\n * ```js\n * import { addShRelativePrefix } from \"patha\"\n *\n * addShRelativePrefix(\"some/file-name\") // gives \"some/file-name\" on Windows and \"./some/file-name\" on others.\n * ```\n *\n * @param path The given path\n * @returns The path with `./` added on Unix\n */\nexport function addShRelativePrefix(path: string) {\n if (process.platform === \"win32\") {\n return path\n }\n return `./${path}`\n}\n","import { extname } from \"path\"\n\n/**\n * Remove a path's extension.\n *\n * @example\n *\n * ```js\n * import { removeExt } from \"patha\"\n *\n * removeExt(\"some/dir/file.ext\") // gives \"some/dir/file\"\n * ```\n *\n * @param path The given path\n * @returns The path without its file extension\n */\nexport function removeExt(path: string) {\n const extensionLength = extname(path).length\n return path.slice(0, -extensionLength)\n}\n","import replaceExtOrig from \"replace-ext\"\n\n/**\n * Replaces the extension from path with extension and returns the updated path string.\n *\n * Does not replace the extension if path is not a string or is empty.\n *\n * @example\n *\n * ```js\n * import { replaceExt } from \"patha\"\n *\n * replaceExt(\"path/to/file.md\", \".html\") // gives \"path/to/file.html\"\n * ```\n *\n * @param path The given path\n * @param extension The extension to replace\n */\nexport function replaceExt(path: string, extension: string) {\n // TODO replaceExt should not change `/` to `\\\\` on Windows\n return replaceExtOrig(path, extension)\n}\n","import { relative, resolve, sep } from \"path\"\n\n/**\n * Check if a path is inside another path.\n *\n * Note that relative paths are resolved against `process.cwd()` to make them absolute.\n *\n * This function does not check if the paths exist and it only works with strings.\n *\n * @example\n *\n * ```js\n * import { isPathInside } from \"patha\"\n *\n * isPathInside(\"a/b/c\", \"a/b\")\n * //=> true\n *\n * isPathInside(\"a/b/c\", \"x/y\")\n * //=> false\n *\n * isPathInside(\"a/b/c\", \"a/b/c\")\n * //=> false\n *\n * isPathInside(\"/Users/some/dev/aa\", \"/Users/some\")\n * //=> true\n * ```\n */\nexport function isPathInside(childPath: string, parentPath: string): boolean {\n // copied from is-path-inside because the package uses node:path that can't be bundled for the browser\n\n const relation = relative(parentPath, childPath)\n\n return Boolean(relation && relation !== \"..\" && !relation.startsWith(`..${sep}`) && relation !== resolve(childPath))\n}\n","export default function escapeStringRegexp(string) {\n\tif (typeof string !== 'string') {\n\t\tthrow new TypeError('Expected a string');\n\t}\n\n\t// Escape characters with special meaning either inside or outside character sets.\n\t// Use a simple backslash escape when it’s always valid, and a `\\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.\n\treturn string\n\t\t.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&')\n\t\t.replace(/-/g, '\\\\x2d');\n}\n","'use strict';\n\nvar path = require('path');\n\nfunction replaceExt(npath, ext) {\n if (typeof npath !== 'string') {\n return npath;\n }\n\n if (npath.length === 0) {\n return npath;\n }\n\n var nFileName = path.basename(npath, path.extname(npath)) + ext;\n var nFilepath = path.join(path.dirname(npath), nFileName);\n\n // Because `path.join` removes the head './' from the given path.\n // This removal can cause a problem when passing the result to `require` or\n // `import`.\n if (startsWithSingleDot(npath)) {\n return '.' + path.sep + nFilepath;\n }\n\n return nFilepath;\n}\n\nfunction startsWithSingleDot(fpath) {\n var first2chars = fpath.slice(0, 2);\n return first2chars === '.' + path.sep || first2chars === './';\n}\n\nmodule.exports = replaceExt;\n",null,null,null,null,null,null,"exports = module.exports = SemVer\n\nvar debug\n/* istanbul ignore next */\nif (typeof process === 'object' &&\n process.env &&\n process.env.NODE_DEBUG &&\n /\\bsemver\\b/i.test(process.env.NODE_DEBUG)) {\n debug = function () {\n var args = Array.prototype.slice.call(arguments, 0)\n args.unshift('SEMVER')\n console.log.apply(console, args)\n }\n} else {\n debug = function () {}\n}\n\n// Note: this is the semver.org version of the spec that it implements\n// Not necessarily the package version of this code.\nexports.SEMVER_SPEC_VERSION = '2.0.0'\n\nvar MAX_LENGTH = 256\nvar MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||\n /* istanbul ignore next */ 9007199254740991\n\n// Max safe segment length for coercion.\nvar MAX_SAFE_COMPONENT_LENGTH = 16\n\nvar MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6\n\n// The actual regexps go on exports.re\nvar re = exports.re = []\nvar safeRe = exports.safeRe = []\nvar src = exports.src = []\nvar t = exports.tokens = {}\nvar R = 0\n\nfunction tok (n) {\n t[n] = R++\n}\n\nvar LETTERDASHNUMBER = '[a-zA-Z0-9-]'\n\n// Replace some greedy regex tokens to prevent regex dos issues. These regex are\n// used internally via the safeRe object since all inputs in this library get\n// normalized first to trim and collapse all extra whitespace. The original\n// regexes are exported for userland consumption and lower level usage. A\n// future breaking change could export the safer regex only with a note that\n// all input should have extra whitespace removed.\nvar safeRegexReplacements = [\n ['\\\\s', 1],\n ['\\\\d', MAX_LENGTH],\n [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],\n]\n\nfunction makeSafeRe (value) {\n for (var i = 0; i < safeRegexReplacements.length; i++) {\n var token = safeRegexReplacements[i][0]\n var max = safeRegexReplacements[i][1]\n value = value\n .split(token + '*').join(token + '{0,' + max + '}')\n .split(token + '+').join(token + '{1,' + max + '}')\n }\n return value\n}\n\n// The following Regular Expressions can be used for tokenizing,\n// validating, and parsing SemVer version strings.\n\n// ## Numeric Identifier\n// A single `0`, or a non-zero digit followed by zero or more digits.\n\ntok('NUMERICIDENTIFIER')\nsrc[t.NUMERICIDENTIFIER] = '0|[1-9]\\\\d*'\ntok('NUMERICIDENTIFIERLOOSE')\nsrc[t.NUMERICIDENTIFIERLOOSE] = '\\\\d+'\n\n// ## Non-numeric Identifier\n// Zero or more digits, followed by a letter or hyphen, and then zero or\n// more letters, digits, or hyphens.\n\ntok('NONNUMERICIDENTIFIER')\nsrc[t.NONNUMERICIDENTIFIER] = '\\\\d*[a-zA-Z-]' + LETTERDASHNUMBER + '*'\n\n// ## Main Version\n// Three dot-separated numeric identifiers.\n\ntok('MAINVERSION')\nsrc[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\\\.' +\n '(' + src[t.NUMERICIDENTIFIER] + ')\\\\.' +\n '(' + src[t.NUMERICIDENTIFIER] + ')'\n\ntok('MAINVERSIONLOOSE')\nsrc[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\\\.' +\n '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\\\.' +\n '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')'\n\n// ## Pre-release Version Identifier\n// A numeric identifier, or a non-numeric identifier.\n\ntok('PRERELEASEIDENTIFIER')\nsrc[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] +\n '|' + src[t.NONNUMERICIDENTIFIER] + ')'\n\ntok('PRERELEASEIDENTIFIERLOOSE')\nsrc[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] +\n '|' + src[t.NONNUMERICIDENTIFIER] + ')'\n\n// ## Pre-release Version\n// Hyphen, followed by one or more dot-separated pre-release version\n// identifiers.\n\ntok('PRERELEASE')\nsrc[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] +\n '(?:\\\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))'\n\ntok('PRERELEASELOOSE')\nsrc[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] +\n '(?:\\\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))'\n\n// ## Build Metadata Identifier\n// Any combination of digits, letters, or hyphens.\n\ntok('BUILDIDENTIFIER')\nsrc[t.BUILDIDENTIFIER] = LETTERDASHNUMBER + '+'\n\n// ## Build Metadata\n// Plus sign, followed by one or more period-separated build metadata\n// identifiers.\n\ntok('BUILD')\nsrc[t.BUILD] = '(?:\\\\+(' + src[t.BUILDIDENTIFIER] +\n '(?:\\\\.' + src[t.BUILDIDENTIFIER] + ')*))'\n\n// ## Full Version String\n// A main version, followed optionally by a pre-release version and\n// build metadata.\n\n// Note that the only major, minor, patch, and pre-release sections of\n// the version string are capturing groups. The build metadata is not a\n// capturing group, because it should not ever be used in version\n// comparison.\n\ntok('FULL')\ntok('FULLPLAIN')\nsrc[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] +\n src[t.PRERELEASE] + '?' +\n src[t.BUILD] + '?'\n\nsrc[t.FULL] = '^' + src[t.FULLPLAIN] + '$'\n\n// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.\n// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty\n// common in the npm registry.\ntok('LOOSEPLAIN')\nsrc[t.LOOSEPLAIN] = '[v=\\\\s]*' + src[t.MAINVERSIONLOOSE] +\n src[t.PRERELEASELOOSE] + '?' +\n src[t.BUILD] + '?'\n\ntok('LOOSE')\nsrc[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$'\n\ntok('GTLT')\nsrc[t.GTLT] = '((?:<|>)?=?)'\n\n// Something like \"2.*\" or \"1.2.x\".\n// Note that \"x.x\" is a valid xRange identifer, meaning \"any version\"\n// Only the first item is strictly required.\ntok('XRANGEIDENTIFIERLOOSE')\nsrc[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\\\*'\ntok('XRANGEIDENTIFIER')\nsrc[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\\\*'\n\ntok('XRANGEPLAIN')\nsrc[t.XRANGEPLAIN] = '[v=\\\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' +\n '(?:\\\\.(' + src[t.XRANGEIDENTIFIER] + ')' +\n '(?:\\\\.(' + src[t.XRANGEIDENTIFIER] + ')' +\n '(?:' + src[t.PRERELEASE] + ')?' +\n src[t.BUILD] + '?' +\n ')?)?'\n\ntok('XRANGEPLAINLOOSE')\nsrc[t.XRANGEPLAINLOOSE] = '[v=\\\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +\n '(?:\\\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +\n '(?:\\\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +\n '(?:' + src[t.PRERELEASELOOSE] + ')?' +\n src[t.BUILD] + '?' +\n ')?)?'\n\ntok('XRANGE')\nsrc[t.XRANGE] = '^' + src[t.GTLT] + '\\\\s*' + src[t.XRANGEPLAIN] + '$'\ntok('XRANGELOOSE')\nsrc[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\\\s*' + src[t.XRANGEPLAINLOOSE] + '$'\n\n// Coercion.\n// Extract anything that could conceivably be a part of a valid semver\ntok('COERCE')\nsrc[t.COERCE] = '(^|[^\\\\d])' +\n '(\\\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' +\n '(?:\\\\.(\\\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +\n '(?:\\\\.(\\\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +\n '(?:$|[^\\\\d])'\ntok('COERCERTL')\nre[t.COERCERTL] = new RegExp(src[t.COERCE], 'g')\nsafeRe[t.COERCERTL] = new RegExp(makeSafeRe(src[t.COERCE]), 'g')\n\n// Tilde ranges.\n// Meaning is \"reasonably at or greater than\"\ntok('LONETILDE')\nsrc[t.LONETILDE] = '(?:~>?)'\n\ntok('TILDETRIM')\nsrc[t.TILDETRIM] = '(\\\\s*)' + src[t.LONETILDE] + '\\\\s+'\nre[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g')\nsafeRe[t.TILDETRIM] = new RegExp(makeSafeRe(src[t.TILDETRIM]), 'g')\nvar tildeTrimReplace = '$1~'\n\ntok('TILDE')\nsrc[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$'\ntok('TILDELOOSE')\nsrc[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$'\n\n// Caret ranges.\n// Meaning is \"at least and backwards compatible with\"\ntok('LONECARET')\nsrc[t.LONECARET] = '(?:\\\\^)'\n\ntok('CARETTRIM')\nsrc[t.CARETTRIM] = '(\\\\s*)' + src[t.LONECARET] + '\\\\s+'\nre[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g')\nsafeRe[t.CARETTRIM] = new RegExp(makeSafeRe(src[t.CARETTRIM]), 'g')\nvar caretTrimReplace = '$1^'\n\ntok('CARET')\nsrc[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$'\ntok('CARETLOOSE')\nsrc[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$'\n\n// A simple gt/lt/eq thing, or just \"\" to indicate \"any version\"\ntok('COMPARATORLOOSE')\nsrc[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\\\s*(' + src[t.LOOSEPLAIN] + ')$|^$'\ntok('COMPARATOR')\nsrc[t.COMPARATOR] = '^' + src[t.GTLT] + '\\\\s*(' + src[t.FULLPLAIN] + ')$|^$'\n\n// An expression to strip any whitespace between the gtlt and the thing\n// it modifies, so that `> 1.2.3` ==> `>1.2.3`\ntok('COMPARATORTRIM')\nsrc[t.COMPARATORTRIM] = '(\\\\s*)' + src[t.GTLT] +\n '\\\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')'\n\n// this one has to use the /g flag\nre[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g')\nsafeRe[t.COMPARATORTRIM] = new RegExp(makeSafeRe(src[t.COMPARATORTRIM]), 'g')\nvar comparatorTrimReplace = '$1$2$3'\n\n// Something like `1.2.3 - 1.2.4`\n// Note that these all use the loose form, because they'll be\n// checked against either the strict or loose comparator form\n// later.\ntok('HYPHENRANGE')\nsrc[t.HYPHENRANGE] = '^\\\\s*(' + src[t.XRANGEPLAIN] + ')' +\n '\\\\s+-\\\\s+' +\n '(' + src[t.XRANGEPLAIN] + ')' +\n '\\\\s*$'\n\ntok('HYPHENRANGELOOSE')\nsrc[t.HYPHENRANGELOOSE] = '^\\\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' +\n '\\\\s+-\\\\s+' +\n '(' + src[t.XRANGEPLAINLOOSE] + ')' +\n '\\\\s*$'\n\n// Star ranges basically just allow anything at all.\ntok('STAR')\nsrc[t.STAR] = '(<|>)?=?\\\\s*\\\\*'\n\n// Compile to actual regexp objects.\n// All are flag-free, unless they were created above with a flag.\nfor (var i = 0; i < R; i++) {\n debug(i, src[i])\n if (!re[i]) {\n re[i] = new RegExp(src[i])\n\n // Replace all greedy whitespace to prevent regex dos issues. These regex are\n // used internally via the safeRe object since all inputs in this library get\n // normalized first to trim and collapse all extra whitespace. The original\n // regexes are exported for userland consumption and lower level usage. A\n // future breaking change could export the safer regex only with a note that\n // all input should have extra whitespace removed.\n safeRe[i] = new RegExp(makeSafeRe(src[i]))\n }\n}\n\nexports.parse = parse\nfunction parse (version, options) {\n if (!options || typeof options !== 'object') {\n options = {\n loose: !!options,\n includePrerelease: false\n }\n }\n\n if (version instanceof SemVer) {\n return version\n }\n\n if (typeof version !== 'string') {\n return null\n }\n\n if (version.length > MAX_LENGTH) {\n return null\n }\n\n var r = options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL]\n if (!r.test(version)) {\n return null\n }\n\n try {\n return new SemVer(version, options)\n } catch (er) {\n return null\n }\n}\n\nexports.valid = valid\nfunction valid (version, options) {\n var v = parse(version, options)\n return v ? v.version : null\n}\n\nexports.clean = clean\nfunction clean (version, options) {\n var s = parse(version.trim().replace(/^[=v]+/, ''), options)\n return s ? s.version : null\n}\n\nexports.SemVer = SemVer\n\nfunction SemVer (version, options) {\n if (!options || typeof options !== 'object') {\n options = {\n loose: !!options,\n includePrerelease: false\n }\n }\n if (version instanceof SemVer) {\n if (version.loose === options.loose) {\n return version\n } else {\n version = version.version\n }\n } else if (typeof version !== 'string') {\n throw new TypeError('Invalid Version: ' + version)\n }\n\n if (version.length > MAX_LENGTH) {\n throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters')\n }\n\n if (!(this instanceof SemVer)) {\n return new SemVer(version, options)\n }\n\n debug('SemVer', version, options)\n this.options = options\n this.loose = !!options.loose\n\n var m = version.trim().match(options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL])\n\n if (!m) {\n throw new TypeError('Invalid Version: ' + version)\n }\n\n this.raw = version\n\n // these are actually numbers\n this.major = +m[1]\n this.minor = +m[2]\n this.patch = +m[3]\n\n if (this.major > MAX_SAFE_INTEGER || this.major < 0) {\n throw new TypeError('Invalid major version')\n }\n\n if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {\n throw new TypeError('Invalid minor version')\n }\n\n if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {\n throw new TypeError('Invalid patch version')\n }\n\n // numberify any prerelease numeric ids\n if (!m[4]) {\n this.prerelease = []\n } else {\n this.prerelease = m[4].split('.').map(function (id) {\n if (/^[0-9]+$/.test(id)) {\n var num = +id\n if (num >= 0 && num < MAX_SAFE_INTEGER) {\n return num\n }\n }\n return id\n })\n }\n\n this.build = m[5] ? m[5].split('.') : []\n this.format()\n}\n\nSemVer.prototype.format = function () {\n this.version = this.major + '.' + this.minor + '.' + this.patch\n if (this.prerelease.length) {\n this.version += '-' + this.prerelease.join('.')\n }\n return this.version\n}\n\nSemVer.prototype.toString = function () {\n return this.version\n}\n\nSemVer.prototype.compare = function (other) {\n debug('SemVer.compare', this.version, this.options, other)\n if (!(other instanceof SemVer)) {\n other = new SemVer(other, this.options)\n }\n\n return this.compareMain(other) || this.comparePre(other)\n}\n\nSemVer.prototype.compareMain = function (other) {\n if (!(other instanceof SemVer)) {\n other = new SemVer(other, this.options)\n }\n\n return compareIdentifiers(this.major, other.major) ||\n compareIdentifiers(this.minor, other.minor) ||\n compareIdentifiers(this.patch, other.patch)\n}\n\nSemVer.prototype.comparePre = function (other) {\n if (!(other instanceof SemVer)) {\n other = new SemVer(other, this.options)\n }\n\n // NOT having a prerelease is > having one\n if (this.prerelease.length && !other.prerelease.length) {\n return -1\n } else if (!this.prerelease.length && other.prerelease.length) {\n return 1\n } else if (!this.prerelease.length && !other.prerelease.length) {\n return 0\n }\n\n var i = 0\n do {\n var a = this.prerelease[i]\n var b = other.prerelease[i]\n debug('prerelease compare', i, a, b)\n if (a === undefined && b === undefined) {\n return 0\n } else if (b === undefined) {\n return 1\n } else if (a === undefined) {\n return -1\n } else if (a === b) {\n continue\n } else {\n return compareIdentifiers(a, b)\n }\n } while (++i)\n}\n\nSemVer.prototype.compareBuild = function (other) {\n if (!(other instanceof SemVer)) {\n other = new SemVer(other, this.options)\n }\n\n var i = 0\n do {\n var a = this.build[i]\n var b = other.build[i]\n debug('prerelease compare', i, a, b)\n if (a === undefined && b === undefined) {\n return 0\n } else if (b === undefined) {\n return 1\n } else if (a === undefined) {\n return -1\n } else if (a === b) {\n continue\n } else {\n return compareIdentifiers(a, b)\n }\n } while (++i)\n}\n\n// preminor will bump the version up to the next minor release, and immediately\n// down to pre-release. premajor and prepatch work the same way.\nSemVer.prototype.inc = function (release, identifier) {\n switch (release) {\n case 'premajor':\n this.prerelease.length = 0\n this.patch = 0\n this.minor = 0\n this.major++\n this.inc('pre', identifier)\n break\n case 'preminor':\n this.prerelease.length = 0\n this.patch = 0\n this.minor++\n this.inc('pre', identifier)\n break\n case 'prepatch':\n // If this is already a prerelease, it will bump to the next version\n // drop any prereleases that might already exist, since they are not\n // relevant at this point.\n this.prerelease.length = 0\n this.inc('patch', identifier)\n this.inc('pre', identifier)\n break\n // If the input is a non-prerelease version, this acts the same as\n // prepatch.\n case 'prerelease':\n if (this.prerelease.length === 0) {\n this.inc('patch', identifier)\n }\n this.inc('pre', identifier)\n break\n\n case 'major':\n // If this is a pre-major version, bump up to the same major version.\n // Otherwise increment major.\n // 1.0.0-5 bumps to 1.0.0\n // 1.1.0 bumps to 2.0.0\n if (this.minor !== 0 ||\n this.patch !== 0 ||\n this.prerelease.length === 0) {\n this.major++\n }\n this.minor = 0\n this.patch = 0\n this.prerelease = []\n break\n case 'minor':\n // If this is a pre-minor version, bump up to the same minor version.\n // Otherwise increment minor.\n // 1.2.0-5 bumps to 1.2.0\n // 1.2.1 bumps to 1.3.0\n if (this.patch !== 0 || this.prerelease.length === 0) {\n this.minor++\n }\n this.patch = 0\n this.prerelease = []\n break\n case 'patch':\n // If this is not a pre-release version, it will increment the patch.\n // If it is a pre-release it will bump up to the same patch version.\n // 1.2.0-5 patches to 1.2.0\n // 1.2.0 patches to 1.2.1\n if (this.prerelease.length === 0) {\n this.patch++\n }\n this.prerelease = []\n break\n // This probably shouldn't be used publicly.\n // 1.0.0 \"pre\" would become 1.0.0-0 which is the wrong direction.\n case 'pre':\n if (this.prerelease.length === 0) {\n this.prerelease = [0]\n } else {\n var i = this.prerelease.length\n while (--i >= 0) {\n if (typeof this.prerelease[i] === 'number') {\n this.prerelease[i]++\n i = -2\n }\n }\n if (i === -1) {\n // didn't increment anything\n this.prerelease.push(0)\n }\n }\n if (identifier) {\n // 1.2.0-beta.1 bumps to 1.2.0-beta.2,\n // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0\n if (this.prerelease[0] === identifier) {\n if (isNaN(this.prerelease[1])) {\n this.prerelease = [identifier, 0]\n }\n } else {\n this.prerelease = [identifier, 0]\n }\n }\n break\n\n default:\n throw new Error('invalid increment argument: ' + release)\n }\n this.format()\n this.raw = this.version\n return this\n}\n\nexports.inc = inc\nfunction inc (version, release, loose, identifier) {\n if (typeof (loose) === 'string') {\n identifier = loose\n loose = undefined\n }\n\n try {\n return new SemVer(version, loose).inc(release, identifier).version\n } catch (er) {\n return null\n }\n}\n\nexports.diff = diff\nfunction diff (version1, version2) {\n if (eq(version1, version2)) {\n return null\n } else {\n var v1 = parse(version1)\n var v2 = parse(version2)\n var prefix = ''\n if (v1.prerelease.length || v2.prerelease.length) {\n prefix = 'pre'\n var defaultResult = 'prerelease'\n }\n for (var key in v1) {\n if (key === 'major' || key === 'minor' || key === 'patch') {\n if (v1[key] !== v2[key]) {\n return prefix + key\n }\n }\n }\n return defaultResult // may be undefined\n }\n}\n\nexports.compareIdentifiers = compareIdentifiers\n\nvar numeric = /^[0-9]+$/\nfunction compareIdentifiers (a, b) {\n var anum = numeric.test(a)\n var bnum = numeric.test(b)\n\n if (anum && bnum) {\n a = +a\n b = +b\n }\n\n return a === b ? 0\n : (anum && !bnum) ? -1\n : (bnum && !anum) ? 1\n : a < b ? -1\n : 1\n}\n\nexports.rcompareIdentifiers = rcompareIdentifiers\nfunction rcompareIdentifiers (a, b) {\n return compareIdentifiers(b, a)\n}\n\nexports.major = major\nfunction major (a, loose) {\n return new SemVer(a, loose).major\n}\n\nexports.minor = minor\nfunction minor (a, loose) {\n return new SemVer(a, loose).minor\n}\n\nexports.patch = patch\nfunction patch (a, loose) {\n return new SemVer(a, loose).patch\n}\n\nexports.compare = compare\nfunction compare (a, b, loose) {\n return new SemVer(a, loose).compare(new SemVer(b, loose))\n}\n\nexports.compareLoose = compareLoose\nfunction compareLoose (a, b) {\n return compare(a, b, true)\n}\n\nexports.compareBuild = compareBuild\nfunction compareBuild (a, b, loose) {\n var versionA = new SemVer(a, loose)\n var versionB = new SemVer(b, loose)\n return versionA.compare(versionB) || versionA.compareBuild(versionB)\n}\n\nexports.rcompare = rcompare\nfunction rcompare (a, b, loose) {\n return compare(b, a, loose)\n}\n\nexports.sort = sort\nfunction sort (list, loose) {\n return list.sort(function (a, b) {\n return exports.compareBuild(a, b, loose)\n })\n}\n\nexports.rsort = rsort\nfunction rsort (list, loose) {\n return list.sort(function (a, b) {\n return exports.compareBuild(b, a, loose)\n })\n}\n\nexports.gt = gt\nfunction gt (a, b, loose) {\n return compare(a, b, loose) > 0\n}\n\nexports.lt = lt\nfunction lt (a, b, loose) {\n return compare(a, b, loose) < 0\n}\n\nexports.eq = eq\nfunction eq (a, b, loose) {\n return compare(a, b, loose) === 0\n}\n\nexports.neq = neq\nfunction neq (a, b, loose) {\n return compare(a, b, loose) !== 0\n}\n\nexports.gte = gte\nfunction gte (a, b, loose) {\n return compare(a, b, loose) >= 0\n}\n\nexports.lte = lte\nfunction lte (a, b, loose) {\n return compare(a, b, loose) <= 0\n}\n\nexports.cmp = cmp\nfunction cmp (a, op, b, loose) {\n switch (op) {\n case '===':\n if (typeof a === 'object')\n a = a.version\n if (typeof b === 'object')\n b = b.version\n return a === b\n\n case '!==':\n if (typeof a === 'object')\n a = a.version\n if (typeof b === 'object')\n b = b.version\n return a !== b\n\n case '':\n case '=':\n case '==':\n return eq(a, b, loose)\n\n case '!=':\n return neq(a, b, loose)\n\n case '>':\n return gt(a, b, loose)\n\n case '>=':\n return gte(a, b, loose)\n\n case '<':\n return lt(a, b, loose)\n\n case '<=':\n return lte(a, b, loose)\n\n default:\n throw new TypeError('Invalid operator: ' + op)\n }\n}\n\nexports.Comparator = Comparator\nfunction Comparator (comp, options) {\n if (!options || typeof options !== 'object') {\n options = {\n loose: !!options,\n includePrerelease: false\n }\n }\n\n if (comp instanceof Comparator) {\n if (comp.loose === !!options.loose) {\n return comp\n } else {\n comp = comp.value\n }\n }\n\n if (!(this instanceof Comparator)) {\n return new Comparator(comp, options)\n }\n\n comp = comp.trim().split(/\\s+/).join(' ')\n debug('comparator', comp, options)\n this.options = options\n this.loose = !!options.loose\n this.parse(comp)\n\n if (this.semver === ANY) {\n this.value = ''\n } else {\n this.value = this.operator + this.semver.version\n }\n\n debug('comp', this)\n}\n\nvar ANY = {}\nComparator.prototype.parse = function (comp) {\n var r = this.options.loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR]\n var m = comp.match(r)\n\n if (!m) {\n throw new TypeError('Invalid comparator: ' + comp)\n }\n\n this.operator = m[1] !== undefined ? m[1] : ''\n if (this.operator === '=') {\n this.operator = ''\n }\n\n // if it literally is just '>' or '' then allow anything.\n if (!m[2]) {\n this.semver = ANY\n } else {\n this.semver = new SemVer(m[2], this.options.loose)\n }\n}\n\nComparator.prototype.toString = function () {\n return this.value\n}\n\nComparator.prototype.test = function (version) {\n debug('Comparator.test', version, this.options.loose)\n\n if (this.semver === ANY || version === ANY) {\n return true\n }\n\n if (typeof version === 'string') {\n try {\n version = new SemVer(version, this.options)\n } catch (er) {\n return false\n }\n }\n\n return cmp(version, this.operator, this.semver, this.options)\n}\n\nComparator.prototype.intersects = function (comp, options) {\n if (!(comp instanceof Comparator)) {\n throw new TypeError('a Comparator is required')\n }\n\n if (!options || typeof options !== 'object') {\n options = {\n loose: !!options,\n includePrerelease: false\n }\n }\n\n var rangeTmp\n\n if (this.operator === '') {\n if (this.value === '') {\n return true\n }\n rangeTmp = new Range(comp.value, options)\n return satisfies(this.value, rangeTmp, options)\n } else if (comp.operator === '') {\n if (comp.value === '') {\n return true\n }\n rangeTmp = new Range(this.value, options)\n return satisfies(comp.semver, rangeTmp, options)\n }\n\n var sameDirectionIncreasing =\n (this.operator === '>=' || this.operator === '>') &&\n (comp.operator === '>=' || comp.operator === '>')\n var sameDirectionDecreasing =\n (this.operator === '<=' || this.operator === '<') &&\n (comp.operator === '<=' || comp.operator === '<')\n var sameSemVer = this.semver.version === comp.semver.version\n var differentDirectionsInclusive =\n (this.operator === '>=' || this.operator === '<=') &&\n (comp.operator === '>=' || comp.operator === '<=')\n var oppositeDirectionsLessThan =\n cmp(this.semver, '<', comp.semver, options) &&\n ((this.operator === '>=' || this.operator === '>') &&\n (comp.operator === '<=' || comp.operator === '<'))\n var oppositeDirectionsGreaterThan =\n cmp(this.semver, '>', comp.semver, options) &&\n ((this.operator === '<=' || this.operator === '<') &&\n (comp.operator === '>=' || comp.operator === '>'))\n\n return sameDirectionIncreasing || sameDirectionDecreasing ||\n (sameSemVer && differentDirectionsInclusive) ||\n oppositeDirectionsLessThan || oppositeDirectionsGreaterThan\n}\n\nexports.Range = Range\nfunction Range (range, options) {\n if (!options || typeof options !== 'object') {\n options = {\n loose: !!options,\n includePrerelease: false\n }\n }\n\n if (range instanceof Range) {\n if (range.loose === !!options.loose &&\n range.includePrerelease === !!options.includePrerelease) {\n return range\n } else {\n return new Range(range.raw, options)\n }\n }\n\n if (range instanceof Comparator) {\n return new Range(range.value, options)\n }\n\n if (!(this instanceof Range)) {\n return new Range(range, options)\n }\n\n this.options = options\n this.loose = !!options.loose\n this.includePrerelease = !!options.includePrerelease\n\n // First reduce all whitespace as much as possible so we do not have to rely\n // on potentially slow regexes like \\s*. This is then stored and used for\n // future error messages as well.\n this.raw = range\n .trim()\n .split(/\\s+/)\n .join(' ')\n\n // First, split based on boolean or ||\n this.set = this.raw.split('||').map(function (range) {\n return this.parseRange(range.trim())\n }, this).filter(function (c) {\n // throw out any that are not relevant for whatever reason\n return c.length\n })\n\n if (!this.set.length) {\n throw new TypeError('Invalid SemVer Range: ' + this.raw)\n }\n\n this.format()\n}\n\nRange.prototype.format = function () {\n this.range = this.set.map(function (comps) {\n return comps.join(' ').trim()\n }).join('||').trim()\n return this.range\n}\n\nRange.prototype.toString = function () {\n return this.range\n}\n\nRange.prototype.parseRange = function (range) {\n var loose = this.options.loose\n // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`\n var hr = loose ? safeRe[t.HYPHENRANGELOOSE] : safeRe[t.HYPHENRANGE]\n range = range.replace(hr, hyphenReplace)\n debug('hyphen replace', range)\n // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`\n range = range.replace(safeRe[t.COMPARATORTRIM], comparatorTrimReplace)\n debug('comparator trim', range, safeRe[t.COMPARATORTRIM])\n\n // `~ 1.2.3` => `~1.2.3`\n range = range.replace(safeRe[t.TILDETRIM], tildeTrimReplace)\n\n // `^ 1.2.3` => `^1.2.3`\n range = range.replace(safeRe[t.CARETTRIM], caretTrimReplace)\n\n // normalize spaces\n range = range.split(/\\s+/).join(' ')\n\n // At this point, the range is completely trimmed and\n // ready to be split into comparators.\n\n var compRe = loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR]\n var set = range.split(' ').map(function (comp) {\n return parseComparator(comp, this.options)\n }, this).join(' ').split(/\\s+/)\n if (this.options.loose) {\n // in loose mode, throw out any that are not valid comparators\n set = set.filter(function (comp) {\n return !!comp.match(compRe)\n })\n }\n set = set.map(function (comp) {\n return new Comparator(comp, this.options)\n }, this)\n\n return set\n}\n\nRange.prototype.intersects = function (range, options) {\n if (!(range instanceof Range)) {\n throw new TypeError('a Range is required')\n }\n\n return this.set.some(function (thisComparators) {\n return (\n isSatisfiable(thisComparators, options) &&\n range.set.some(function (rangeComparators) {\n return (\n isSatisfiable(rangeComparators, options) &&\n thisComparators.every(function (thisComparator) {\n return rangeComparators.every(function (rangeComparator) {\n return thisComparator.intersects(rangeComparator, options)\n })\n })\n )\n })\n )\n })\n}\n\n// take a set of comparators and determine whether there\n// exists a version which can satisfy it\nfunction isSatisfiable (comparators, options) {\n var result = true\n var remainingComparators = comparators.slice()\n var testComparator = remainingComparators.pop()\n\n while (result && remainingComparators.length) {\n result = remainingComparators.every(function (otherComparator) {\n return testComparator.intersects(otherComparator, options)\n })\n\n testComparator = remainingComparators.pop()\n }\n\n return result\n}\n\n// Mostly just for testing and legacy API reasons\nexports.toComparators = toComparators\nfunction toComparators (range, options) {\n return new Range(range, options).set.map(function (comp) {\n return comp.map(function (c) {\n return c.value\n }).join(' ').trim().split(' ')\n })\n}\n\n// comprised of xranges, tildes, stars, and gtlt's at this point.\n// already replaced the hyphen ranges\n// turn into a set of JUST comparators.\nfunction parseComparator (comp, options) {\n debug('comp', comp, options)\n comp = replaceCarets(comp, options)\n debug('caret', comp)\n comp = replaceTildes(comp, options)\n debug('tildes', comp)\n comp = replaceXRanges(comp, options)\n debug('xrange', comp)\n comp = replaceStars(comp, options)\n debug('stars', comp)\n return comp\n}\n\nfunction isX (id) {\n return !id || id.toLowerCase() === 'x' || id === '*'\n}\n\n// ~, ~> --> * (any, kinda silly)\n// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0\n// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0\n// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0\n// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0\n// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0\nfunction replaceTildes (comp, options) {\n return comp.trim().split(/\\s+/).map(function (comp) {\n return replaceTilde(comp, options)\n }).join(' ')\n}\n\nfunction replaceTilde (comp, options) {\n var r = options.loose ? safeRe[t.TILDELOOSE] : safeRe[t.TILDE]\n return comp.replace(r, function (_, M, m, p, pr) {\n debug('tilde', comp, _, M, m, p, pr)\n var ret\n\n if (isX(M)) {\n ret = ''\n } else if (isX(m)) {\n ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'\n } else if (isX(p)) {\n // ~1.2 == >=1.2.0 <1.3.0\n ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'\n } else if (pr) {\n debug('replaceTilde pr', pr)\n ret = '>=' + M + '.' + m + '.' + p + '-' + pr +\n ' <' + M + '.' + (+m + 1) + '.0'\n } else {\n // ~1.2.3 == >=1.2.3 <1.3.0\n ret = '>=' + M + '.' + m + '.' + p +\n ' <' + M + '.' + (+m + 1) + '.0'\n }\n\n debug('tilde return', ret)\n return ret\n })\n}\n\n// ^ --> * (any, kinda silly)\n// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0\n// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0\n// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0\n// ^1.2.3 --> >=1.2.3 <2.0.0\n// ^1.2.0 --> >=1.2.0 <2.0.0\nfunction replaceCarets (comp, options) {\n return comp.trim().split(/\\s+/).map(function (comp) {\n return replaceCaret(comp, options)\n }).join(' ')\n}\n\nfunction replaceCaret (comp, options) {\n debug('caret', comp, options)\n var r = options.loose ? safeRe[t.CARETLOOSE] : safeRe[t.CARET]\n return comp.replace(r, function (_, M, m, p, pr) {\n debug('caret', comp, _, M, m, p, pr)\n var ret\n\n if (isX(M)) {\n ret = ''\n } else if (isX(m)) {\n ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'\n } else if (isX(p)) {\n if (M === '0') {\n ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'\n } else {\n ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0'\n }\n } else if (pr) {\n debug('replaceCaret pr', pr)\n if (M === '0') {\n if (m === '0') {\n ret = '>=' + M + '.' + m + '.' + p + '-' + pr +\n ' <' + M + '.' + m + '.' + (+p + 1)\n } else {\n ret = '>=' + M + '.' + m + '.' + p + '-' + pr +\n ' <' + M + '.' + (+m + 1) + '.0'\n }\n } else {\n ret = '>=' + M + '.' + m + '.' + p + '-' + pr +\n ' <' + (+M + 1) + '.0.0'\n }\n } else {\n debug('no pr')\n if (M === '0') {\n if (m === '0') {\n ret = '>=' + M + '.' + m + '.' + p +\n ' <' + M + '.' + m + '.' + (+p + 1)\n } else {\n ret = '>=' + M + '.' + m + '.' + p +\n ' <' + M + '.' + (+m + 1) + '.0'\n }\n } else {\n ret = '>=' + M + '.' + m + '.' + p +\n ' <' + (+M + 1) + '.0.0'\n }\n }\n\n debug('caret return', ret)\n return ret\n })\n}\n\nfunction replaceXRanges (comp, options) {\n debug('replaceXRanges', comp, options)\n return comp.split(/\\s+/).map(function (comp) {\n return replaceXRange(comp, options)\n }).join(' ')\n}\n\nfunction replaceXRange (comp, options) {\n comp = comp.trim()\n var r = options.loose ? safeRe[t.XRANGELOOSE] : safeRe[t.XRANGE]\n return comp.replace(r, function (ret, gtlt, M, m, p, pr) {\n debug('xRange', comp, ret, gtlt, M, m, p, pr)\n var xM = isX(M)\n var xm = xM || isX(m)\n var xp = xm || isX(p)\n var anyX = xp\n\n if (gtlt === '=' && anyX) {\n gtlt = ''\n }\n\n // if we're including prereleases in the match, then we need\n // to fix this to -0, the lowest possible prerelease value\n pr = options.includePrerelease ? '-0' : ''\n\n if (xM) {\n if (gtlt === '>' || gtlt === '<') {\n // nothing is allowed\n ret = '<0.0.0-0'\n } else {\n // nothing is forbidden\n ret = '*'\n }\n } else if (gtlt && anyX) {\n // we know patch is an x, because we have any x at all.\n // replace X with 0\n if (xm) {\n m = 0\n }\n p = 0\n\n if (gtlt === '>') {\n // >1 => >=2.0.0\n // >1.2 => >=1.3.0\n // >1.2.3 => >= 1.2.4\n gtlt = '>='\n if (xm) {\n M = +M + 1\n m = 0\n p = 0\n } else {\n m = +m + 1\n p = 0\n }\n } else if (gtlt === '<=') {\n // <=0.7.x is actually <0.8.0, since any 0.7.x should\n // pass. Similarly, <=7.x is actually <8.0.0, etc.\n gtlt = '<'\n if (xm) {\n M = +M + 1\n } else {\n m = +m + 1\n }\n }\n\n ret = gtlt + M + '.' + m + '.' + p + pr\n } else if (xm) {\n ret = '>=' + M + '.0.0' + pr + ' <' + (+M + 1) + '.0.0' + pr\n } else if (xp) {\n ret = '>=' + M + '.' + m + '.0' + pr +\n ' <' + M + '.' + (+m + 1) + '.0' + pr\n }\n\n debug('xRange return', ret)\n\n return ret\n })\n}\n\n// Because * is AND-ed with everything else in the comparator,\n// and '' means \"any version\", just remove the *s entirely.\nfunction replaceStars (comp, options) {\n debug('replaceStars', comp, options)\n // Looseness is ignored here. star is always as loose as it gets!\n return comp.trim().replace(safeRe[t.STAR], '')\n}\n\n// This function is passed to string.replace(re[t.HYPHENRANGE])\n// M, m, patch, prerelease, build\n// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5\n// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do\n// 1.2 - 3.4 => >=1.2.0 <3.5.0\nfunction hyphenReplace ($0,\n from, fM, fm, fp, fpr, fb,\n to, tM, tm, tp, tpr, tb) {\n if (isX(fM)) {\n from = ''\n } else if (isX(fm)) {\n from = '>=' + fM + '.0.0'\n } else if (isX(fp)) {\n from = '>=' + fM + '.' + fm + '.0'\n } else {\n from = '>=' + from\n }\n\n if (isX(tM)) {\n to = ''\n } else if (isX(tm)) {\n to = '<' + (+tM + 1) + '.0.0'\n } else if (isX(tp)) {\n to = '<' + tM + '.' + (+tm + 1) + '.0'\n } else if (tpr) {\n to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr\n } else {\n to = '<=' + to\n }\n\n return (from + ' ' + to).trim()\n}\n\n// if ANY of the sets match ALL of its comparators, then pass\nRange.prototype.test = function (version) {\n if (!version) {\n return false\n }\n\n if (typeof version === 'string') {\n try {\n version = new SemVer(version, this.options)\n } catch (er) {\n return false\n }\n }\n\n for (var i = 0; i < this.set.length; i++) {\n if (testSet(this.set[i], version, this.options)) {\n return true\n }\n }\n return false\n}\n\nfunction testSet (set, version, options) {\n for (var i = 0; i < set.length; i++) {\n if (!set[i].test(version)) {\n return false\n }\n }\n\n if (version.prerelease.length && !options.includePrerelease) {\n // Find the set of versions that are allowed to have prereleases\n // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0\n // That should allow `1.2.3-pr.2` to pass.\n // However, `1.2.4-alpha.notready` should NOT be allowed,\n // even though it's within the range set by the comparators.\n for (i = 0; i < set.length; i++) {\n debug(set[i].semver)\n if (set[i].semver === ANY) {\n continue\n }\n\n if (set[i].semver.prerelease.length > 0) {\n var allowed = set[i].semver\n if (allowed.major === version.major &&\n allowed.minor === version.minor &&\n allowed.patch === version.patch) {\n return true\n }\n }\n }\n\n // Version has a -pre, but it's not one of the ones we like.\n return false\n }\n\n return true\n}\n\nexports.satisfies = satisfies\nfunction satisfies (version, range, options) {\n try {\n range = new Range(range, options)\n } catch (er) {\n return false\n }\n return range.test(version)\n}\n\nexports.maxSatisfying = maxSatisfying\nfunction maxSatisfying (versions, range, options) {\n var max = null\n var maxSV = null\n try {\n var rangeObj = new Range(range, options)\n } catch (er) {\n return null\n }\n versions.forEach(function (v) {\n if (rangeObj.test(v)) {\n // satisfies(v, range, options)\n if (!max || maxSV.compare(v) === -1) {\n // compare(max, v, true)\n max = v\n maxSV = new SemVer(max, options)\n }\n }\n })\n return max\n}\n\nexports.minSatisfying = minSatisfying\nfunction minSatisfying (versions, range, options) {\n var min = null\n var minSV = null\n try {\n var rangeObj = new Range(range, options)\n } catch (er) {\n return null\n }\n versions.forEach(function (v) {\n if (rangeObj.test(v)) {\n // satisfies(v, range, options)\n if (!min || minSV.compare(v) === 1) {\n // compare(min, v, true)\n min = v\n minSV = new SemVer(min, options)\n }\n }\n })\n return min\n}\n\nexports.minVersion = minVersion\nfunction minVersion (range, loose) {\n range = new Range(range, loose)\n\n var minver = new SemVer('0.0.0')\n if (range.test(minver)) {\n return minver\n }\n\n minver = new SemVer('0.0.0-0')\n if (range.test(minver)) {\n return minver\n }\n\n minver = null\n for (var i = 0; i < range.set.length; ++i) {\n var comparators = range.set[i]\n\n comparators.forEach(function (comparator) {\n // Clone to avoid manipulating the comparator's semver object.\n var compver = new SemVer(comparator.semver.version)\n switch (comparator.operator) {\n case '>':\n if (compver.prerelease.length === 0) {\n compver.patch++\n } else {\n compver.prerelease.push(0)\n }\n compver.raw = compver.format()\n /* fallthrough */\n case '':\n case '>=':\n if (!minver || gt(minver, compver)) {\n minver = compver\n }\n break\n case '<':\n case '<=':\n /* Ignore maximum versions */\n break\n /* istanbul ignore next */\n default:\n throw new Error('Unexpected operation: ' + comparator.operator)\n }\n })\n }\n\n if (minver && range.test(minver)) {\n return minver\n }\n\n return null\n}\n\nexports.validRange = validRange\nfunction validRange (range, options) {\n try {\n // Return '*' instead of '' so that truthiness works.\n // This will throw if it's invalid anyway\n return new Range(range, options).range || '*'\n } catch (er) {\n return null\n }\n}\n\n// Determine if version is less than all the versions possible in the range\nexports.ltr = ltr\nfunction ltr (version, range, options) {\n return outside(version, range, '<', options)\n}\n\n// Determine if version is greater than all the versions possible in the range.\nexports.gtr = gtr\nfunction gtr (version, range, options) {\n return outside(version, range, '>', options)\n}\n\nexports.outside = outside\nfunction outside (version, range, hilo, options) {\n version = new SemVer(version, options)\n range = new Range(range, options)\n\n var gtfn, ltefn, ltfn, comp, ecomp\n switch (hilo) {\n case '>':\n gtfn = gt\n ltefn = lte\n ltfn = lt\n comp = '>'\n ecomp = '>='\n break\n case '<':\n gtfn = lt\n ltefn = gte\n ltfn = gt\n comp = '<'\n ecomp = '<='\n break\n default:\n throw new TypeError('Must provide a hilo val of \"<\" or \">\"')\n }\n\n // If it satisifes the range it is not outside\n if (satisfies(version, range, options)) {\n return false\n }\n\n // From now on, variable terms are as if we're in \"gtr\" mode.\n // but note that everything is flipped for the \"ltr\" function.\n\n for (var i = 0; i < range.set.length; ++i) {\n var comparators = range.set[i]\n\n var high = null\n var low = null\n\n comparators.forEach(function (comparator) {\n if (comparator.semver === ANY) {\n comparator = new Comparator('>=0.0.0')\n }\n high = high || comparator\n low = low || comparator\n if (gtfn(comparator.semver, high.semver, options)) {\n high = comparator\n } else if (ltfn(comparator.semver, low.semver, options)) {\n low = comparator\n }\n })\n\n // If the edge version comparator has a operator then our version\n // isn't outside it\n if (high.operator === comp || high.operator === ecomp) {\n return false\n }\n\n // If the lowest version comparator has an operator and our version\n // is less than it then it isn't higher than the range\n if ((!low.operator || low.operator === comp) &&\n ltefn(version, low.semver)) {\n return false\n } else if (low.operator === ecomp && ltfn(version, low.semver)) {\n return false\n }\n }\n return true\n}\n\nexports.prerelease = prerelease\nfunction prerelease (version, options) {\n var parsed = parse(version, options)\n return (parsed && parsed.prerelease.length) ? parsed.prerelease : null\n}\n\nexports.intersects = intersects\nfunction intersects (r1, r2, options) {\n r1 = new Range(r1, options)\n r2 = new Range(r2, options)\n return r1.intersects(r2)\n}\n\nexports.coerce = coerce\nfunction coerce (version, options) {\n if (version instanceof SemVer) {\n return version\n }\n\n if (typeof version === 'number') {\n version = String(version)\n }\n\n if (typeof version !== 'string') {\n return null\n }\n\n options = options || {}\n\n var match = null\n if (!options.rtl) {\n match = version.match(safeRe[t.COERCE])\n } else {\n // Find the right-most coercible string that does not share\n // a terminus with a more left-ward coercible string.\n // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'\n //\n // Walk through the string checking with a /g regexp\n // Manually set the index so as to pick up overlapping matches.\n // Stop when we get a match that ends at the string end, since no\n // coercible string can be more right-ward without the same terminus.\n var next\n while ((next = safeRe[t.COERCERTL].exec(version)) &&\n (!match || match.index + match[0].length !== version.length)\n ) {\n if (!match ||\n next.index + next[0].length !== match.index + match[0].length) {\n match = next\n }\n safeRe[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length\n }\n // leave it in a clean state\n safeRe[t.COERCERTL].lastIndex = -1\n }\n\n if (match === null) {\n return null\n }\n\n return parse(match[2] +\n '.' + (match[3] || '0') +\n '.' + (match[4] || '0'), options)\n}\n","var rng = require('./lib/rng');\nvar bytesToUuid = require('./lib/bytesToUuid');\n\nfunction v4(options, buf, offset) {\n var i = buf && offset || 0;\n\n if (typeof(options) == 'string') {\n buf = options === 'binary' ? new Array(16) : null;\n options = null;\n }\n options = options || {};\n\n var rnds = options.random || (options.rng || rng)();\n\n // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n rnds[6] = (rnds[6] & 0x0f) | 0x40;\n rnds[8] = (rnds[8] & 0x3f) | 0x80;\n\n // Copy bytes to buffer, if provided\n if (buf) {\n for (var ii = 0; ii < 16; ++ii) {\n buf[i + ii] = rnds[ii];\n }\n }\n\n return buf || bytesToUuid(rnds);\n}\n\nmodule.exports = v4;\n","// Unique ID creation requires a high quality random # generator. In node.js\n// this is pretty straight-forward - we use the crypto API.\n\nvar crypto = require('crypto');\n\nmodule.exports = function nodeRNG() {\n return crypto.randomBytes(16);\n};\n","/**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */\nvar byteToHex = [];\nfor (var i = 0; i < 256; ++i) {\n byteToHex[i] = (i + 0x100).toString(16).substr(1);\n}\n\nfunction bytesToUuid(buf, offset) {\n var i = offset || 0;\n var bth = byteToHex;\n // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4\n return ([\n bth[buf[i++]], bth[buf[i++]],\n bth[buf[i++]], bth[buf[i++]], '-',\n bth[buf[i++]], bth[buf[i++]], '-',\n bth[buf[i++]], bth[buf[i++]], '-',\n bth[buf[i++]], bth[buf[i++]], '-',\n bth[buf[i++]], bth[buf[i++]],\n bth[buf[i++]], bth[buf[i++]],\n bth[buf[i++]], bth[buf[i++]]\n ]).join('');\n}\n\nmodule.exports = bytesToUuid;\n",null,null,null,null,"module.exports = (Promise.resolve(__parcel__require__(\"./\" + \"actions_python.4fb6b558.js\"))).then(() => parcelRequire('4kQHk'));","var conventions = require(\"./conventions\");\nvar dom = require('./dom')\nvar entities = require('./entities');\nvar sax = require('./sax');\n\nvar DOMImplementation = dom.DOMImplementation;\n\nvar NAMESPACE = conventions.NAMESPACE;\n\nvar ParseError = sax.ParseError;\nvar XMLReader = sax.XMLReader;\n\n/**\n * Normalizes line ending according to https://www.w3.org/TR/xml11/#sec-line-ends:\n *\n * > XML parsed entities are often stored in computer files which,\n * > for editing convenience, are organized into lines.\n * > These lines are typically separated by some combination\n * > of the characters CARRIAGE RETURN (#xD) and LINE FEED (#xA).\n * >\n * > To simplify the tasks of applications, the XML processor must behave\n * > as if it normalized all line breaks in external parsed entities (including the document entity)\n * > on input, before parsing, by translating all of the following to a single #xA character:\n * >\n * > 1. the two-character sequence #xD #xA\n * > 2. the two-character sequence #xD #x85\n * > 3. the single character #x85\n * > 4. the single character #x2028\n * > 5. any #xD character that is not immediately followed by #xA or #x85.\n *\n * @param {string} input\n * @returns {string}\n */\nfunction normalizeLineEndings(input) {\n\treturn input\n\t\t.replace(/\\r[\\n\\u0085]/g, '\\n')\n\t\t.replace(/[\\r\\u0085\\u2028]/g, '\\n')\n}\n\n/**\n * @typedef Locator\n * @property {number} [columnNumber]\n * @property {number} [lineNumber]\n */\n\n/**\n * @typedef DOMParserOptions\n * @property {DOMHandler} [domBuilder]\n * @property {Function} [errorHandler]\n * @property {(string) => string} [normalizeLineEndings] used to replace line endings before parsing\n * \t\t\t\t\t\tdefaults to `normalizeLineEndings`\n * @property {Locator} [locator]\n * @property {Record} [xmlns]\n *\n * @see normalizeLineEndings\n */\n\n/**\n * The DOMParser interface provides the ability to parse XML or HTML source code\n * from a string into a DOM `Document`.\n *\n * _xmldom is different from the spec in that it allows an `options` parameter,\n * to override the default behavior._\n *\n * @param {DOMParserOptions} [options]\n * @constructor\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser\n * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-parsing-and-serialization\n */\nfunction DOMParser(options){\n\tthis.options = options ||{locator:{}};\n}\n\nDOMParser.prototype.parseFromString = function(source,mimeType){\n\tvar options = this.options;\n\tvar sax = new XMLReader();\n\tvar domBuilder = options.domBuilder || new DOMHandler();//contentHandler and LexicalHandler\n\tvar errorHandler = options.errorHandler;\n\tvar locator = options.locator;\n\tvar defaultNSMap = options.xmlns||{};\n\tvar isHTML = /\\/x?html?$/.test(mimeType);//mimeType.toLowerCase().indexOf('html') > -1;\n \tvar entityMap = isHTML ? entities.HTML_ENTITIES : entities.XML_ENTITIES;\n\tif(locator){\n\t\tdomBuilder.setDocumentLocator(locator)\n\t}\n\n\tsax.errorHandler = buildErrorHandler(errorHandler,domBuilder,locator);\n\tsax.domBuilder = options.domBuilder || domBuilder;\n\tif(isHTML){\n\t\tdefaultNSMap[''] = NAMESPACE.HTML;\n\t}\n\tdefaultNSMap.xml = defaultNSMap.xml || NAMESPACE.XML;\n\tvar normalize = options.normalizeLineEndings || normalizeLineEndings;\n\tif (source && typeof source === 'string') {\n\t\tsax.parse(\n\t\t\tnormalize(source),\n\t\t\tdefaultNSMap,\n\t\t\tentityMap\n\t\t)\n\t} else {\n\t\tsax.errorHandler.error('invalid doc source')\n\t}\n\treturn domBuilder.doc;\n}\nfunction buildErrorHandler(errorImpl,domBuilder,locator){\n\tif(!errorImpl){\n\t\tif(domBuilder instanceof DOMHandler){\n\t\t\treturn domBuilder;\n\t\t}\n\t\terrorImpl = domBuilder ;\n\t}\n\tvar errorHandler = {}\n\tvar isCallback = errorImpl instanceof Function;\n\tlocator = locator||{}\n\tfunction build(key){\n\t\tvar fn = errorImpl[key];\n\t\tif(!fn && isCallback){\n\t\t\tfn = errorImpl.length == 2?function(msg){errorImpl(key,msg)}:errorImpl;\n\t\t}\n\t\terrorHandler[key] = fn && function(msg){\n\t\t\tfn('[xmldom '+key+']\\t'+msg+_locator(locator));\n\t\t}||function(){};\n\t}\n\tbuild('warning');\n\tbuild('error');\n\tbuild('fatalError');\n\treturn errorHandler;\n}\n\n//console.log('#\\n\\n\\n\\n\\n\\n\\n####')\n/**\n * +ContentHandler+ErrorHandler\n * +LexicalHandler+EntityResolver2\n * -DeclHandler-DTDHandler\n *\n * DefaultHandler:EntityResolver, DTDHandler, ContentHandler, ErrorHandler\n * DefaultHandler2:DefaultHandler,LexicalHandler, DeclHandler, EntityResolver2\n * @link http://www.saxproject.org/apidoc/org/xml/sax/helpers/DefaultHandler.html\n */\nfunction DOMHandler() {\n this.cdata = false;\n}\nfunction position(locator,node){\n\tnode.lineNumber = locator.lineNumber;\n\tnode.columnNumber = locator.columnNumber;\n}\n/**\n * @see org.xml.sax.ContentHandler#startDocument\n * @link http://www.saxproject.org/apidoc/org/xml/sax/ContentHandler.html\n */\nDOMHandler.prototype = {\n\tstartDocument : function() {\n \tthis.doc = new DOMImplementation().createDocument(null, null, null);\n \tif (this.locator) {\n \tthis.doc.documentURI = this.locator.systemId;\n \t}\n\t},\n\tstartElement:function(namespaceURI, localName, qName, attrs) {\n\t\tvar doc = this.doc;\n\t var el = doc.createElementNS(namespaceURI, qName||localName);\n\t var len = attrs.length;\n\t appendElement(this, el);\n\t this.currentElement = el;\n\n\t\tthis.locator && position(this.locator,el)\n\t for (var i = 0 ; i < len; i++) {\n\t var namespaceURI = attrs.getURI(i);\n\t var value = attrs.getValue(i);\n\t var qName = attrs.getQName(i);\n\t\t\tvar attr = doc.createAttributeNS(namespaceURI, qName);\n\t\t\tthis.locator &&position(attrs.getLocator(i),attr);\n\t\t\tattr.value = attr.nodeValue = value;\n\t\t\tel.setAttributeNode(attr)\n\t }\n\t},\n\tendElement:function(namespaceURI, localName, qName) {\n\t\tvar current = this.currentElement\n\t\tvar tagName = current.tagName;\n\t\tthis.currentElement = current.parentNode;\n\t},\n\tstartPrefixMapping:function(prefix, uri) {\n\t},\n\tendPrefixMapping:function(prefix) {\n\t},\n\tprocessingInstruction:function(target, data) {\n\t var ins = this.doc.createProcessingInstruction(target, data);\n\t this.locator && position(this.locator,ins)\n\t appendElement(this, ins);\n\t},\n\tignorableWhitespace:function(ch, start, length) {\n\t},\n\tcharacters:function(chars, start, length) {\n\t\tchars = _toString.apply(this,arguments)\n\t\t//console.log(chars)\n\t\tif(chars){\n\t\t\tif (this.cdata) {\n\t\t\t\tvar charNode = this.doc.createCDATASection(chars);\n\t\t\t} else {\n\t\t\t\tvar charNode = this.doc.createTextNode(chars);\n\t\t\t}\n\t\t\tif(this.currentElement){\n\t\t\t\tthis.currentElement.appendChild(charNode);\n\t\t\t}else if(/^\\s*$/.test(chars)){\n\t\t\t\tthis.doc.appendChild(charNode);\n\t\t\t\t//process xml\n\t\t\t}\n\t\t\tthis.locator && position(this.locator,charNode)\n\t\t}\n\t},\n\tskippedEntity:function(name) {\n\t},\n\tendDocument:function() {\n\t\tthis.doc.normalize();\n\t},\n\tsetDocumentLocator:function (locator) {\n\t if(this.locator = locator){// && !('lineNumber' in locator)){\n\t \tlocator.lineNumber = 0;\n\t }\n\t},\n\t//LexicalHandler\n\tcomment:function(chars, start, length) {\n\t\tchars = _toString.apply(this,arguments)\n\t var comm = this.doc.createComment(chars);\n\t this.locator && position(this.locator,comm)\n\t appendElement(this, comm);\n\t},\n\n\tstartCDATA:function() {\n\t //used in characters() methods\n\t this.cdata = true;\n\t},\n\tendCDATA:function() {\n\t this.cdata = false;\n\t},\n\n\tstartDTD:function(name, publicId, systemId) {\n\t\tvar impl = this.doc.implementation;\n\t if (impl && impl.createDocumentType) {\n\t var dt = impl.createDocumentType(name, publicId, systemId);\n\t this.locator && position(this.locator,dt)\n\t appendElement(this, dt);\n\t\t\t\t\tthis.doc.doctype = dt;\n\t }\n\t},\n\t/**\n\t * @see org.xml.sax.ErrorHandler\n\t * @link http://www.saxproject.org/apidoc/org/xml/sax/ErrorHandler.html\n\t */\n\twarning:function(error) {\n\t\tconsole.warn('[xmldom warning]\\t'+error,_locator(this.locator));\n\t},\n\terror:function(error) {\n\t\tconsole.error('[xmldom error]\\t'+error,_locator(this.locator));\n\t},\n\tfatalError:function(error) {\n\t\tthrow new ParseError(error, this.locator);\n\t}\n}\nfunction _locator(l){\n\tif(l){\n\t\treturn '\\n@'+(l.systemId ||'')+'#[line:'+l.lineNumber+',col:'+l.columnNumber+']'\n\t}\n}\nfunction _toString(chars,start,length){\n\tif(typeof chars == 'string'){\n\t\treturn chars.substr(start,length)\n\t}else{//java sax connect width xmldom on rhino(what about: \"? && !(chars instanceof String)\")\n\t\tif(chars.length >= start+length || start){\n\t\t\treturn new java.lang.String(chars,start,length)+'';\n\t\t}\n\t\treturn chars;\n\t}\n}\n\n/*\n * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/LexicalHandler.html\n * used method of org.xml.sax.ext.LexicalHandler:\n * #comment(chars, start, length)\n * #startCDATA()\n * #endCDATA()\n * #startDTD(name, publicId, systemId)\n *\n *\n * IGNORED method of org.xml.sax.ext.LexicalHandler:\n * #endDTD()\n * #startEntity(name)\n * #endEntity(name)\n *\n *\n * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/DeclHandler.html\n * IGNORED method of org.xml.sax.ext.DeclHandler\n * \t#attributeDecl(eName, aName, type, mode, value)\n * #elementDecl(name, model)\n * #externalEntityDecl(name, publicId, systemId)\n * #internalEntityDecl(name, value)\n * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/EntityResolver2.html\n * IGNORED method of org.xml.sax.EntityResolver2\n * #resolveEntity(String name,String publicId,String baseURI,String systemId)\n * #resolveEntity(publicId, systemId)\n * #getExternalSubset(name, baseURI)\n * @link http://www.saxproject.org/apidoc/org/xml/sax/DTDHandler.html\n * IGNORED method of org.xml.sax.DTDHandler\n * #notationDecl(name, publicId, systemId) {};\n * #unparsedEntityDecl(name, publicId, systemId, notationName) {};\n */\n\"endDTD,startEntity,endEntity,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,resolveEntity,getExternalSubset,notationDecl,unparsedEntityDecl\".replace(/\\w+/g,function(key){\n\tDOMHandler.prototype[key] = function(){return null}\n})\n\n/* Private static helpers treated below as private instance methods, so don't need to add these to the public API; we might use a Relator to also get rid of non-standard public properties */\nfunction appendElement (hander,node) {\n if (!hander.currentElement) {\n hander.doc.appendChild(node);\n } else {\n hander.currentElement.appendChild(node);\n }\n}//appendChild and setAttributeNS are preformance key\n\nexports.__DOMHandler = DOMHandler;\nexports.normalizeLineEndings = normalizeLineEndings;\nexports.DOMParser = DOMParser;\n","'use strict'\n\n/**\n * Ponyfill for `Array.prototype.find` which is only available in ES6 runtimes.\n *\n * Works with anything that has a `length` property and index access properties, including NodeList.\n *\n * @template {unknown} T\n * @param {Array | ({length:number, [number]: T})} list\n * @param {function (item: T, index: number, list:Array | ({length:number, [number]: T})):boolean} predicate\n * @param {Partial>?} ac `Array.prototype` by default,\n * \t\t\t\tallows injecting a custom implementation in tests\n * @returns {T | undefined}\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find\n * @see https://tc39.es/ecma262/multipage/indexed-collections.html#sec-array.prototype.find\n */\nfunction find(list, predicate, ac) {\n\tif (ac === undefined) {\n\t\tac = Array.prototype;\n\t}\n\tif (list && typeof ac.find === 'function') {\n\t\treturn ac.find.call(list, predicate);\n\t}\n\tfor (var i = 0; i < list.length; i++) {\n\t\tif (Object.prototype.hasOwnProperty.call(list, i)) {\n\t\t\tvar item = list[i];\n\t\t\tif (predicate.call(undefined, item, i, list)) {\n\t\t\t\treturn item;\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * \"Shallow freezes\" an object to render it immutable.\n * Uses `Object.freeze` if available,\n * otherwise the immutability is only in the type.\n *\n * Is used to create \"enum like\" objects.\n *\n * @template T\n * @param {T} object the object to freeze\n * @param {Pick = Object} oc `Object` by default,\n * \t\t\t\tallows to inject custom object constructor for tests\n * @returns {Readonly}\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze\n */\nfunction freeze(object, oc) {\n\tif (oc === undefined) {\n\t\toc = Object\n\t}\n\treturn oc && typeof oc.freeze === 'function' ? oc.freeze(object) : object\n}\n\n/**\n * Since we can not rely on `Object.assign` we provide a simplified version\n * that is sufficient for our needs.\n *\n * @param {Object} target\n * @param {Object | null | undefined} source\n *\n * @returns {Object} target\n * @throws TypeError if target is not an object\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign\n * @see https://tc39.es/ecma262/multipage/fundamental-objects.html#sec-object.assign\n */\nfunction assign(target, source) {\n\tif (target === null || typeof target !== 'object') {\n\t\tthrow new TypeError('target is not an object')\n\t}\n\tfor (var key in source) {\n\t\tif (Object.prototype.hasOwnProperty.call(source, key)) {\n\t\t\ttarget[key] = source[key]\n\t\t}\n\t}\n\treturn target\n}\n\n/**\n * All mime types that are allowed as input to `DOMParser.parseFromString`\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString#Argument02 MDN\n * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#domparsersupportedtype WHATWG HTML Spec\n * @see DOMParser.prototype.parseFromString\n */\nvar MIME_TYPE = freeze({\n\t/**\n\t * `text/html`, the only mime type that triggers treating an XML document as HTML.\n\t *\n\t * @see DOMParser.SupportedType.isHTML\n\t * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration\n\t * @see https://en.wikipedia.org/wiki/HTML Wikipedia\n\t * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN\n\t * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring WHATWG HTML Spec\n\t */\n\tHTML: 'text/html',\n\n\t/**\n\t * Helper method to check a mime type if it indicates an HTML document\n\t *\n\t * @param {string} [value]\n\t * @returns {boolean}\n\t *\n\t * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration\n\t * @see https://en.wikipedia.org/wiki/HTML Wikipedia\n\t * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN\n\t * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring \t */\n\tisHTML: function (value) {\n\t\treturn value === MIME_TYPE.HTML\n\t},\n\n\t/**\n\t * `application/xml`, the standard mime type for XML documents.\n\t *\n\t * @see https://www.iana.org/assignments/media-types/application/xml IANA MimeType registration\n\t * @see https://tools.ietf.org/html/rfc7303#section-9.1 RFC 7303\n\t * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia\n\t */\n\tXML_APPLICATION: 'application/xml',\n\n\t/**\n\t * `text/html`, an alias for `application/xml`.\n\t *\n\t * @see https://tools.ietf.org/html/rfc7303#section-9.2 RFC 7303\n\t * @see https://www.iana.org/assignments/media-types/text/xml IANA MimeType registration\n\t * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia\n\t */\n\tXML_TEXT: 'text/xml',\n\n\t/**\n\t * `application/xhtml+xml`, indicates an XML document that has the default HTML namespace,\n\t * but is parsed as an XML document.\n\t *\n\t * @see https://www.iana.org/assignments/media-types/application/xhtml+xml IANA MimeType registration\n\t * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument WHATWG DOM Spec\n\t * @see https://en.wikipedia.org/wiki/XHTML Wikipedia\n\t */\n\tXML_XHTML_APPLICATION: 'application/xhtml+xml',\n\n\t/**\n\t * `image/svg+xml`,\n\t *\n\t * @see https://www.iana.org/assignments/media-types/image/svg+xml IANA MimeType registration\n\t * @see https://www.w3.org/TR/SVG11/ W3C SVG 1.1\n\t * @see https://en.wikipedia.org/wiki/Scalable_Vector_Graphics Wikipedia\n\t */\n\tXML_SVG_IMAGE: 'image/svg+xml',\n})\n\n/**\n * Namespaces that are used in this code base.\n *\n * @see http://www.w3.org/TR/REC-xml-names\n */\nvar NAMESPACE = freeze({\n\t/**\n\t * The XHTML namespace.\n\t *\n\t * @see http://www.w3.org/1999/xhtml\n\t */\n\tHTML: 'http://www.w3.org/1999/xhtml',\n\n\t/**\n\t * Checks if `uri` equals `NAMESPACE.HTML`.\n\t *\n\t * @param {string} [uri]\n\t *\n\t * @see NAMESPACE.HTML\n\t */\n\tisHTML: function (uri) {\n\t\treturn uri === NAMESPACE.HTML\n\t},\n\n\t/**\n\t * The SVG namespace.\n\t *\n\t * @see http://www.w3.org/2000/svg\n\t */\n\tSVG: 'http://www.w3.org/2000/svg',\n\n\t/**\n\t * The `xml:` namespace.\n\t *\n\t * @see http://www.w3.org/XML/1998/namespace\n\t */\n\tXML: 'http://www.w3.org/XML/1998/namespace',\n\n\t/**\n\t * The `xmlns:` namespace\n\t *\n\t * @see https://www.w3.org/2000/xmlns/\n\t */\n\tXMLNS: 'http://www.w3.org/2000/xmlns/',\n})\n\nexports.assign = assign;\nexports.find = find;\nexports.freeze = freeze;\nexports.MIME_TYPE = MIME_TYPE;\nexports.NAMESPACE = NAMESPACE;\n","var conventions = require(\"./conventions\");\n\nvar find = conventions.find;\nvar NAMESPACE = conventions.NAMESPACE;\n\n/**\n * A prerequisite for `[].filter`, to drop elements that are empty\n * @param {string} input\n * @returns {boolean}\n */\nfunction notEmptyString (input) {\n\treturn input !== ''\n}\n/**\n * @see https://infra.spec.whatwg.org/#split-on-ascii-whitespace\n * @see https://infra.spec.whatwg.org/#ascii-whitespace\n *\n * @param {string} input\n * @returns {string[]} (can be empty)\n */\nfunction splitOnASCIIWhitespace(input) {\n\t// U+0009 TAB, U+000A LF, U+000C FF, U+000D CR, U+0020 SPACE\n\treturn input ? input.split(/[\\t\\n\\f\\r ]+/).filter(notEmptyString) : []\n}\n\n/**\n * Adds element as a key to current if it is not already present.\n *\n * @param {Record} current\n * @param {string} element\n * @returns {Record}\n */\nfunction orderedSetReducer (current, element) {\n\tif (!current.hasOwnProperty(element)) {\n\t\tcurrent[element] = true;\n\t}\n\treturn current;\n}\n\n/**\n * @see https://infra.spec.whatwg.org/#ordered-set\n * @param {string} input\n * @returns {string[]}\n */\nfunction toOrderedSet(input) {\n\tif (!input) return [];\n\tvar list = splitOnASCIIWhitespace(input);\n\treturn Object.keys(list.reduce(orderedSetReducer, {}))\n}\n\n/**\n * Uses `list.indexOf` to implement something like `Array.prototype.includes`,\n * which we can not rely on being available.\n *\n * @param {any[]} list\n * @returns {function(any): boolean}\n */\nfunction arrayIncludes (list) {\n\treturn function(element) {\n\t\treturn list && list.indexOf(element) !== -1;\n\t}\n}\n\nfunction copy(src,dest){\n\tfor(var p in src){\n\t\tif (Object.prototype.hasOwnProperty.call(src, p)) {\n\t\t\tdest[p] = src[p];\n\t\t}\n\t}\n}\n\n/**\n^\\w+\\.prototype\\.([_\\w]+)\\s*=\\s*((?:.*\\{\\s*?[\\r\\n][\\s\\S]*?^})|\\S.*?(?=[;\\r\\n]));?\n^\\w+\\.prototype\\.([_\\w]+)\\s*=\\s*(\\S.*?(?=[;\\r\\n]));?\n */\nfunction _extends(Class,Super){\n\tvar pt = Class.prototype;\n\tif(!(pt instanceof Super)){\n\t\tfunction t(){};\n\t\tt.prototype = Super.prototype;\n\t\tt = new t();\n\t\tcopy(pt,t);\n\t\tClass.prototype = pt = t;\n\t}\n\tif(pt.constructor != Class){\n\t\tif(typeof Class != 'function'){\n\t\t\tconsole.error(\"unknown Class:\"+Class)\n\t\t}\n\t\tpt.constructor = Class\n\t}\n}\n\n// Node Types\nvar NodeType = {}\nvar ELEMENT_NODE = NodeType.ELEMENT_NODE = 1;\nvar ATTRIBUTE_NODE = NodeType.ATTRIBUTE_NODE = 2;\nvar TEXT_NODE = NodeType.TEXT_NODE = 3;\nvar CDATA_SECTION_NODE = NodeType.CDATA_SECTION_NODE = 4;\nvar ENTITY_REFERENCE_NODE = NodeType.ENTITY_REFERENCE_NODE = 5;\nvar ENTITY_NODE = NodeType.ENTITY_NODE = 6;\nvar PROCESSING_INSTRUCTION_NODE = NodeType.PROCESSING_INSTRUCTION_NODE = 7;\nvar COMMENT_NODE = NodeType.COMMENT_NODE = 8;\nvar DOCUMENT_NODE = NodeType.DOCUMENT_NODE = 9;\nvar DOCUMENT_TYPE_NODE = NodeType.DOCUMENT_TYPE_NODE = 10;\nvar DOCUMENT_FRAGMENT_NODE = NodeType.DOCUMENT_FRAGMENT_NODE = 11;\nvar NOTATION_NODE = NodeType.NOTATION_NODE = 12;\n\n// ExceptionCode\nvar ExceptionCode = {}\nvar ExceptionMessage = {};\nvar INDEX_SIZE_ERR = ExceptionCode.INDEX_SIZE_ERR = ((ExceptionMessage[1]=\"Index size error\"),1);\nvar DOMSTRING_SIZE_ERR = ExceptionCode.DOMSTRING_SIZE_ERR = ((ExceptionMessage[2]=\"DOMString size error\"),2);\nvar HIERARCHY_REQUEST_ERR = ExceptionCode.HIERARCHY_REQUEST_ERR = ((ExceptionMessage[3]=\"Hierarchy request error\"),3);\nvar WRONG_DOCUMENT_ERR = ExceptionCode.WRONG_DOCUMENT_ERR = ((ExceptionMessage[4]=\"Wrong document\"),4);\nvar INVALID_CHARACTER_ERR = ExceptionCode.INVALID_CHARACTER_ERR = ((ExceptionMessage[5]=\"Invalid character\"),5);\nvar NO_DATA_ALLOWED_ERR = ExceptionCode.NO_DATA_ALLOWED_ERR = ((ExceptionMessage[6]=\"No data allowed\"),6);\nvar NO_MODIFICATION_ALLOWED_ERR = ExceptionCode.NO_MODIFICATION_ALLOWED_ERR = ((ExceptionMessage[7]=\"No modification allowed\"),7);\nvar NOT_FOUND_ERR = ExceptionCode.NOT_FOUND_ERR = ((ExceptionMessage[8]=\"Not found\"),8);\nvar NOT_SUPPORTED_ERR = ExceptionCode.NOT_SUPPORTED_ERR = ((ExceptionMessage[9]=\"Not supported\"),9);\nvar INUSE_ATTRIBUTE_ERR = ExceptionCode.INUSE_ATTRIBUTE_ERR = ((ExceptionMessage[10]=\"Attribute in use\"),10);\n//level2\nvar INVALID_STATE_ERR \t= ExceptionCode.INVALID_STATE_ERR \t= ((ExceptionMessage[11]=\"Invalid state\"),11);\nvar SYNTAX_ERR \t= ExceptionCode.SYNTAX_ERR \t= ((ExceptionMessage[12]=\"Syntax error\"),12);\nvar INVALID_MODIFICATION_ERR \t= ExceptionCode.INVALID_MODIFICATION_ERR \t= ((ExceptionMessage[13]=\"Invalid modification\"),13);\nvar NAMESPACE_ERR \t= ExceptionCode.NAMESPACE_ERR \t= ((ExceptionMessage[14]=\"Invalid namespace\"),14);\nvar INVALID_ACCESS_ERR \t= ExceptionCode.INVALID_ACCESS_ERR \t= ((ExceptionMessage[15]=\"Invalid access\"),15);\n\n/**\n * DOM Level 2\n * Object DOMException\n * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/ecma-script-binding.html\n * @see http://www.w3.org/TR/REC-DOM-Level-1/ecma-script-language-binding.html\n */\nfunction DOMException(code, message) {\n\tif(message instanceof Error){\n\t\tvar error = message;\n\t}else{\n\t\terror = this;\n\t\tError.call(this, ExceptionMessage[code]);\n\t\tthis.message = ExceptionMessage[code];\n\t\tif(Error.captureStackTrace) Error.captureStackTrace(this, DOMException);\n\t}\n\terror.code = code;\n\tif(message) this.message = this.message + \": \" + message;\n\treturn error;\n};\nDOMException.prototype = Error.prototype;\ncopy(ExceptionCode,DOMException)\n\n/**\n * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-536297177\n * The NodeList interface provides the abstraction of an ordered collection of nodes, without defining or constraining how this collection is implemented. NodeList objects in the DOM are live.\n * The items in the NodeList are accessible via an integral index, starting from 0.\n */\nfunction NodeList() {\n};\nNodeList.prototype = {\n\t/**\n\t * The number of nodes in the list. The range of valid child node indices is 0 to length-1 inclusive.\n\t * @standard level1\n\t */\n\tlength:0,\n\t/**\n\t * Returns the indexth item in the collection. If index is greater than or equal to the number of nodes in the list, this returns null.\n\t * @standard level1\n\t * @param index unsigned long\n\t * Index into the collection.\n\t * @return Node\n\t * \tThe node at the indexth position in the NodeList, or null if that is not a valid index.\n\t */\n\titem: function(index) {\n\t\treturn index >= 0 && index < this.length ? this[index] : null;\n\t},\n\ttoString:function(isHTML,nodeFilter){\n\t\tfor(var buf = [], i = 0;i=0){\n\t\tvar lastIndex = list.length-1\n\t\twhile(i0 || key == 'xmlns'){\n//\t\t\treturn null;\n//\t\t}\n\t\t//console.log()\n\t\tvar i = this.length;\n\t\twhile(i--){\n\t\t\tvar attr = this[i];\n\t\t\t//console.log(attr.nodeName,key)\n\t\t\tif(attr.nodeName == key){\n\t\t\t\treturn attr;\n\t\t\t}\n\t\t}\n\t},\n\tsetNamedItem: function(attr) {\n\t\tvar el = attr.ownerElement;\n\t\tif(el && el!=this._ownerElement){\n\t\t\tthrow new DOMException(INUSE_ATTRIBUTE_ERR);\n\t\t}\n\t\tvar oldAttr = this.getNamedItem(attr.nodeName);\n\t\t_addNamedNode(this._ownerElement,this,attr,oldAttr);\n\t\treturn oldAttr;\n\t},\n\t/* returns Node */\n\tsetNamedItemNS: function(attr) {// raises: WRONG_DOCUMENT_ERR,NO_MODIFICATION_ALLOWED_ERR,INUSE_ATTRIBUTE_ERR\n\t\tvar el = attr.ownerElement, oldAttr;\n\t\tif(el && el!=this._ownerElement){\n\t\t\tthrow new DOMException(INUSE_ATTRIBUTE_ERR);\n\t\t}\n\t\toldAttr = this.getNamedItemNS(attr.namespaceURI,attr.localName);\n\t\t_addNamedNode(this._ownerElement,this,attr,oldAttr);\n\t\treturn oldAttr;\n\t},\n\n\t/* returns Node */\n\tremoveNamedItem: function(key) {\n\t\tvar attr = this.getNamedItem(key);\n\t\t_removeNamedNode(this._ownerElement,this,attr);\n\t\treturn attr;\n\n\n\t},// raises: NOT_FOUND_ERR,NO_MODIFICATION_ALLOWED_ERR\n\n\t//for level2\n\tremoveNamedItemNS:function(namespaceURI,localName){\n\t\tvar attr = this.getNamedItemNS(namespaceURI,localName);\n\t\t_removeNamedNode(this._ownerElement,this,attr);\n\t\treturn attr;\n\t},\n\tgetNamedItemNS: function(namespaceURI, localName) {\n\t\tvar i = this.length;\n\t\twhile(i--){\n\t\t\tvar node = this[i];\n\t\t\tif(node.localName == localName && node.namespaceURI == namespaceURI){\n\t\t\t\treturn node;\n\t\t\t}\n\t\t}\n\t\treturn null;\n\t}\n};\n\n/**\n * The DOMImplementation interface represents an object providing methods\n * which are not dependent on any particular document.\n * Such an object is returned by the `Document.implementation` property.\n *\n * __The individual methods describe the differences compared to the specs.__\n *\n * @constructor\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation MDN\n * @see https://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-102161490 DOM Level 1 Core (Initial)\n * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-102161490 DOM Level 2 Core\n * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-102161490 DOM Level 3 Core\n * @see https://dom.spec.whatwg.org/#domimplementation DOM Living Standard\n */\nfunction DOMImplementation() {\n}\n\nDOMImplementation.prototype = {\n\t/**\n\t * The DOMImplementation.hasFeature() method returns a Boolean flag indicating if a given feature is supported.\n\t * The different implementations fairly diverged in what kind of features were reported.\n\t * The latest version of the spec settled to force this method to always return true, where the functionality was accurate and in use.\n\t *\n\t * @deprecated It is deprecated and modern browsers return true in all cases.\n\t *\n\t * @param {string} feature\n\t * @param {string} [version]\n\t * @returns {boolean} always true\n\t *\n\t * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/hasFeature MDN\n\t * @see https://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-5CED94D7 DOM Level 1 Core\n\t * @see https://dom.spec.whatwg.org/#dom-domimplementation-hasfeature DOM Living Standard\n\t */\n\thasFeature: function(feature, version) {\n\t\t\treturn true;\n\t},\n\t/**\n\t * Creates an XML Document object of the specified type with its document element.\n\t *\n\t * __It behaves slightly different from the description in the living standard__:\n\t * - There is no interface/class `XMLDocument`, it returns a `Document` instance.\n\t * - `contentType`, `encoding`, `mode`, `origin`, `url` fields are currently not declared.\n\t * - this implementation is not validating names or qualified names\n\t * (when parsing XML strings, the SAX parser takes care of that)\n\t *\n\t * @param {string|null} namespaceURI\n\t * @param {string} qualifiedName\n\t * @param {DocumentType=null} doctype\n\t * @returns {Document}\n\t *\n\t * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocument MDN\n\t * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocument DOM Level 2 Core (initial)\n\t * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument DOM Level 2 Core\n\t *\n\t * @see https://dom.spec.whatwg.org/#validate-and-extract DOM: Validate and extract\n\t * @see https://www.w3.org/TR/xml/#NT-NameStartChar XML Spec: Names\n\t * @see https://www.w3.org/TR/xml-names/#ns-qualnames XML Namespaces: Qualified names\n\t */\n\tcreateDocument: function(namespaceURI, qualifiedName, doctype){\n\t\tvar doc = new Document();\n\t\tdoc.implementation = this;\n\t\tdoc.childNodes = new NodeList();\n\t\tdoc.doctype = doctype || null;\n\t\tif (doctype){\n\t\t\tdoc.appendChild(doctype);\n\t\t}\n\t\tif (qualifiedName){\n\t\t\tvar root = doc.createElementNS(namespaceURI, qualifiedName);\n\t\t\tdoc.appendChild(root);\n\t\t}\n\t\treturn doc;\n\t},\n\t/**\n\t * Returns a doctype, with the given `qualifiedName`, `publicId`, and `systemId`.\n\t *\n\t * __This behavior is slightly different from the in the specs__:\n\t * - this implementation is not validating names or qualified names\n\t * (when parsing XML strings, the SAX parser takes care of that)\n\t *\n\t * @param {string} qualifiedName\n\t * @param {string} [publicId]\n\t * @param {string} [systemId]\n\t * @returns {DocumentType} which can either be used with `DOMImplementation.createDocument` upon document creation\n\t * \t\t\t\t or can be put into the document via methods like `Node.insertBefore()` or `Node.replaceChild()`\n\t *\n\t * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocumentType MDN\n\t * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocType DOM Level 2 Core\n\t * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocumenttype DOM Living Standard\n\t *\n\t * @see https://dom.spec.whatwg.org/#validate-and-extract DOM: Validate and extract\n\t * @see https://www.w3.org/TR/xml/#NT-NameStartChar XML Spec: Names\n\t * @see https://www.w3.org/TR/xml-names/#ns-qualnames XML Namespaces: Qualified names\n\t */\n\tcreateDocumentType: function(qualifiedName, publicId, systemId){\n\t\tvar node = new DocumentType();\n\t\tnode.name = qualifiedName;\n\t\tnode.nodeName = qualifiedName;\n\t\tnode.publicId = publicId || '';\n\t\tnode.systemId = systemId || '';\n\n\t\treturn node;\n\t}\n};\n\n\n/**\n * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-1950641247\n */\n\nfunction Node() {\n};\n\nNode.prototype = {\n\tfirstChild : null,\n\tlastChild : null,\n\tpreviousSibling : null,\n\tnextSibling : null,\n\tattributes : null,\n\tparentNode : null,\n\tchildNodes : null,\n\townerDocument : null,\n\tnodeValue : null,\n\tnamespaceURI : null,\n\tprefix : null,\n\tlocalName : null,\n\t// Modified in DOM Level 2:\n\tinsertBefore:function(newChild, refChild){//raises\n\t\treturn _insertBefore(this,newChild,refChild);\n\t},\n\treplaceChild:function(newChild, oldChild){//raises\n\t\t_insertBefore(this, newChild,oldChild, assertPreReplacementValidityInDocument);\n\t\tif(oldChild){\n\t\t\tthis.removeChild(oldChild);\n\t\t}\n\t},\n\tremoveChild:function(oldChild){\n\t\treturn _removeChild(this,oldChild);\n\t},\n\tappendChild:function(newChild){\n\t\treturn this.insertBefore(newChild,null);\n\t},\n\thasChildNodes:function(){\n\t\treturn this.firstChild != null;\n\t},\n\tcloneNode:function(deep){\n\t\treturn cloneNode(this.ownerDocument||this,this,deep);\n\t},\n\t// Modified in DOM Level 2:\n\tnormalize:function(){\n\t\tvar child = this.firstChild;\n\t\twhile(child){\n\t\t\tvar next = child.nextSibling;\n\t\t\tif(next && next.nodeType == TEXT_NODE && child.nodeType == TEXT_NODE){\n\t\t\t\tthis.removeChild(next);\n\t\t\t\tchild.appendData(next.data);\n\t\t\t}else{\n\t\t\t\tchild.normalize();\n\t\t\t\tchild = next;\n\t\t\t}\n\t\t}\n\t},\n \t// Introduced in DOM Level 2:\n\tisSupported:function(feature, version){\n\t\treturn this.ownerDocument.implementation.hasFeature(feature,version);\n\t},\n // Introduced in DOM Level 2:\n hasAttributes:function(){\n \treturn this.attributes.length>0;\n },\n\t/**\n\t * Look up the prefix associated to the given namespace URI, starting from this node.\n\t * **The default namespace declarations are ignored by this method.**\n\t * See Namespace Prefix Lookup for details on the algorithm used by this method.\n\t *\n\t * _Note: The implementation seems to be incomplete when compared to the algorithm described in the specs._\n\t *\n\t * @param {string | null} namespaceURI\n\t * @returns {string | null}\n\t * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-lookupNamespacePrefix\n\t * @see https://www.w3.org/TR/DOM-Level-3-Core/namespaces-algorithms.html#lookupNamespacePrefixAlgo\n\t * @see https://dom.spec.whatwg.org/#dom-node-lookupprefix\n\t * @see https://github.com/xmldom/xmldom/issues/322\n\t */\n lookupPrefix:function(namespaceURI){\n \tvar el = this;\n \twhile(el){\n \t\tvar map = el._nsMap;\n \t\t//console.dir(map)\n \t\tif(map){\n \t\t\tfor(var n in map){\n\t\t\t\t\t\tif (Object.prototype.hasOwnProperty.call(map, n) && map[n] === namespaceURI) {\n\t\t\t\t\t\t\treturn n;\n\t\t\t\t\t\t}\n \t\t\t}\n \t\t}\n \t\tel = el.nodeType == ATTRIBUTE_NODE?el.ownerDocument : el.parentNode;\n \t}\n \treturn null;\n },\n // Introduced in DOM Level 3:\n lookupNamespaceURI:function(prefix){\n \tvar el = this;\n \twhile(el){\n \t\tvar map = el._nsMap;\n \t\t//console.dir(map)\n \t\tif(map){\n \t\t\tif(Object.prototype.hasOwnProperty.call(map, prefix)){\n \t\t\t\treturn map[prefix] ;\n \t\t\t}\n \t\t}\n \t\tel = el.nodeType == ATTRIBUTE_NODE?el.ownerDocument : el.parentNode;\n \t}\n \treturn null;\n },\n // Introduced in DOM Level 3:\n isDefaultNamespace:function(namespaceURI){\n \tvar prefix = this.lookupPrefix(namespaceURI);\n \treturn prefix == null;\n }\n};\n\n\nfunction _xmlEncoder(c){\n\treturn c == '<' && '<' ||\n c == '>' && '>' ||\n c == '&' && '&' ||\n c == '\"' && '"' ||\n '&#'+c.charCodeAt()+';'\n}\n\n\ncopy(NodeType,Node);\ncopy(NodeType,Node.prototype);\n\n/**\n * @param callback return true for continue,false for break\n * @return boolean true: break visit;\n */\nfunction _visitNode(node,callback){\n\tif(callback(node)){\n\t\treturn true;\n\t}\n\tif(node = node.firstChild){\n\t\tdo{\n\t\t\tif(_visitNode(node,callback)){return true}\n }while(node=node.nextSibling)\n }\n}\n\n\n\nfunction Document(){\n\tthis.ownerDocument = this;\n}\n\nfunction _onAddAttribute(doc,el,newAttr){\n\tdoc && doc._inc++;\n\tvar ns = newAttr.namespaceURI ;\n\tif(ns === NAMESPACE.XMLNS){\n\t\t//update namespace\n\t\tel._nsMap[newAttr.prefix?newAttr.localName:''] = newAttr.value\n\t}\n}\n\nfunction _onRemoveAttribute(doc,el,newAttr,remove){\n\tdoc && doc._inc++;\n\tvar ns = newAttr.namespaceURI ;\n\tif(ns === NAMESPACE.XMLNS){\n\t\t//update namespace\n\t\tdelete el._nsMap[newAttr.prefix?newAttr.localName:'']\n\t}\n}\n\n/**\n * Updates `el.childNodes`, updating the indexed items and it's `length`.\n * Passing `newChild` means it will be appended.\n * Otherwise it's assumed that an item has been removed,\n * and `el.firstNode` and it's `.nextSibling` are used\n * to walk the current list of child nodes.\n *\n * @param {Document} doc\n * @param {Node} el\n * @param {Node} [newChild]\n * @private\n */\nfunction _onUpdateChild (doc, el, newChild) {\n\tif(doc && doc._inc){\n\t\tdoc._inc++;\n\t\t//update childNodes\n\t\tvar cs = el.childNodes;\n\t\tif (newChild) {\n\t\t\tcs[cs.length++] = newChild;\n\t\t} else {\n\t\t\tvar child = el.firstChild;\n\t\t\tvar i = 0;\n\t\t\twhile (child) {\n\t\t\t\tcs[i++] = child;\n\t\t\t\tchild = child.nextSibling;\n\t\t\t}\n\t\t\tcs.length = i;\n\t\t\tdelete cs[cs.length];\n\t\t}\n\t}\n}\n\n/**\n * Removes the connections between `parentNode` and `child`\n * and any existing `child.previousSibling` or `child.nextSibling`.\n *\n * @see https://github.com/xmldom/xmldom/issues/135\n * @see https://github.com/xmldom/xmldom/issues/145\n *\n * @param {Node} parentNode\n * @param {Node} child\n * @returns {Node} the child that was removed.\n * @private\n */\nfunction _removeChild (parentNode, child) {\n\tvar previous = child.previousSibling;\n\tvar next = child.nextSibling;\n\tif (previous) {\n\t\tprevious.nextSibling = next;\n\t} else {\n\t\tparentNode.firstChild = next;\n\t}\n\tif (next) {\n\t\tnext.previousSibling = previous;\n\t} else {\n\t\tparentNode.lastChild = previous;\n\t}\n\tchild.parentNode = null;\n\tchild.previousSibling = null;\n\tchild.nextSibling = null;\n\t_onUpdateChild(parentNode.ownerDocument, parentNode);\n\treturn child;\n}\n\n/**\n * Returns `true` if `node` can be a parent for insertion.\n * @param {Node} node\n * @returns {boolean}\n */\nfunction hasValidParentNodeType(node) {\n\treturn (\n\t\tnode &&\n\t\t(node.nodeType === Node.DOCUMENT_NODE || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE || node.nodeType === Node.ELEMENT_NODE)\n\t);\n}\n\n/**\n * Returns `true` if `node` can be inserted according to it's `nodeType`.\n * @param {Node} node\n * @returns {boolean}\n */\nfunction hasInsertableNodeType(node) {\n\treturn (\n\t\tnode &&\n\t\t(isElementNode(node) ||\n\t\t\tisTextNode(node) ||\n\t\t\tisDocTypeNode(node) ||\n\t\t\tnode.nodeType === Node.DOCUMENT_FRAGMENT_NODE ||\n\t\t\tnode.nodeType === Node.COMMENT_NODE ||\n\t\t\tnode.nodeType === Node.PROCESSING_INSTRUCTION_NODE)\n\t);\n}\n\n/**\n * Returns true if `node` is a DOCTYPE node\n * @param {Node} node\n * @returns {boolean}\n */\nfunction isDocTypeNode(node) {\n\treturn node && node.nodeType === Node.DOCUMENT_TYPE_NODE;\n}\n\n/**\n * Returns true if the node is an element\n * @param {Node} node\n * @returns {boolean}\n */\nfunction isElementNode(node) {\n\treturn node && node.nodeType === Node.ELEMENT_NODE;\n}\n/**\n * Returns true if `node` is a text node\n * @param {Node} node\n * @returns {boolean}\n */\nfunction isTextNode(node) {\n\treturn node && node.nodeType === Node.TEXT_NODE;\n}\n\n/**\n * Check if en element node can be inserted before `child`, or at the end if child is falsy,\n * according to the presence and position of a doctype node on the same level.\n *\n * @param {Document} doc The document node\n * @param {Node} child the node that would become the nextSibling if the element would be inserted\n * @returns {boolean} `true` if an element can be inserted before child\n * @private\n * https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity\n */\nfunction isElementInsertionPossible(doc, child) {\n\tvar parentChildNodes = doc.childNodes || [];\n\tif (find(parentChildNodes, isElementNode) || isDocTypeNode(child)) {\n\t\treturn false;\n\t}\n\tvar docTypeNode = find(parentChildNodes, isDocTypeNode);\n\treturn !(child && docTypeNode && parentChildNodes.indexOf(docTypeNode) > parentChildNodes.indexOf(child));\n}\n\n/**\n * Check if en element node can be inserted before `child`, or at the end if child is falsy,\n * according to the presence and position of a doctype node on the same level.\n *\n * @param {Node} doc The document node\n * @param {Node} child the node that would become the nextSibling if the element would be inserted\n * @returns {boolean} `true` if an element can be inserted before child\n * @private\n * https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity\n */\nfunction isElementReplacementPossible(doc, child) {\n\tvar parentChildNodes = doc.childNodes || [];\n\n\tfunction hasElementChildThatIsNotChild(node) {\n\t\treturn isElementNode(node) && node !== child;\n\t}\n\n\tif (find(parentChildNodes, hasElementChildThatIsNotChild)) {\n\t\treturn false;\n\t}\n\tvar docTypeNode = find(parentChildNodes, isDocTypeNode);\n\treturn !(child && docTypeNode && parentChildNodes.indexOf(docTypeNode) > parentChildNodes.indexOf(child));\n}\n\n/**\n * @private\n * Steps 1-5 of the checks before inserting and before replacing a child are the same.\n *\n * @param {Node} parent the parent node to insert `node` into\n * @param {Node} node the node to insert\n * @param {Node=} child the node that should become the `nextSibling` of `node`\n * @returns {Node}\n * @throws DOMException for several node combinations that would create a DOM that is not well-formed.\n * @throws DOMException if `child` is provided but is not a child of `parent`.\n * @see https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity\n * @see https://dom.spec.whatwg.org/#concept-node-replace\n */\nfunction assertPreInsertionValidity1to5(parent, node, child) {\n\t// 1. If `parent` is not a Document, DocumentFragment, or Element node, then throw a \"HierarchyRequestError\" DOMException.\n\tif (!hasValidParentNodeType(parent)) {\n\t\tthrow new DOMException(HIERARCHY_REQUEST_ERR, 'Unexpected parent node type ' + parent.nodeType);\n\t}\n\t// 2. If `node` is a host-including inclusive ancestor of `parent`, then throw a \"HierarchyRequestError\" DOMException.\n\t// not implemented!\n\t// 3. If `child` is non-null and its parent is not `parent`, then throw a \"NotFoundError\" DOMException.\n\tif (child && child.parentNode !== parent) {\n\t\tthrow new DOMException(NOT_FOUND_ERR, 'child not in parent');\n\t}\n\tif (\n\t\t// 4. If `node` is not a DocumentFragment, DocumentType, Element, or CharacterData node, then throw a \"HierarchyRequestError\" DOMException.\n\t\t!hasInsertableNodeType(node) ||\n\t\t// 5. If either `node` is a Text node and `parent` is a document,\n\t\t// the sax parser currently adds top level text nodes, this will be fixed in 0.9.0\n\t\t// || (node.nodeType === Node.TEXT_NODE && parent.nodeType === Node.DOCUMENT_NODE)\n\t\t// or `node` is a doctype and `parent` is not a document, then throw a \"HierarchyRequestError\" DOMException.\n\t\t(isDocTypeNode(node) && parent.nodeType !== Node.DOCUMENT_NODE)\n\t) {\n\t\tthrow new DOMException(\n\t\t\tHIERARCHY_REQUEST_ERR,\n\t\t\t'Unexpected node type ' + node.nodeType + ' for parent node type ' + parent.nodeType\n\t\t);\n\t}\n}\n\n/**\n * @private\n * Step 6 of the checks before inserting and before replacing a child are different.\n *\n * @param {Document} parent the parent node to insert `node` into\n * @param {Node} node the node to insert\n * @param {Node | undefined} child the node that should become the `nextSibling` of `node`\n * @returns {Node}\n * @throws DOMException for several node combinations that would create a DOM that is not well-formed.\n * @throws DOMException if `child` is provided but is not a child of `parent`.\n * @see https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity\n * @see https://dom.spec.whatwg.org/#concept-node-replace\n */\nfunction assertPreInsertionValidityInDocument(parent, node, child) {\n\tvar parentChildNodes = parent.childNodes || [];\n\tvar nodeChildNodes = node.childNodes || [];\n\n\t// DocumentFragment\n\tif (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n\t\tvar nodeChildElements = nodeChildNodes.filter(isElementNode);\n\t\t// If node has more than one element child or has a Text node child.\n\t\tif (nodeChildElements.length > 1 || find(nodeChildNodes, isTextNode)) {\n\t\t\tthrow new DOMException(HIERARCHY_REQUEST_ERR, 'More than one element or text in fragment');\n\t\t}\n\t\t// Otherwise, if `node` has one element child and either `parent` has an element child,\n\t\t// `child` is a doctype, or `child` is non-null and a doctype is following `child`.\n\t\tif (nodeChildElements.length === 1 && !isElementInsertionPossible(parent, child)) {\n\t\t\tthrow new DOMException(HIERARCHY_REQUEST_ERR, 'Element in fragment can not be inserted before doctype');\n\t\t}\n\t}\n\t// Element\n\tif (isElementNode(node)) {\n\t\t// `parent` has an element child, `child` is a doctype,\n\t\t// or `child` is non-null and a doctype is following `child`.\n\t\tif (!isElementInsertionPossible(parent, child)) {\n\t\t\tthrow new DOMException(HIERARCHY_REQUEST_ERR, 'Only one element can be added and only after doctype');\n\t\t}\n\t}\n\t// DocumentType\n\tif (isDocTypeNode(node)) {\n\t\t// `parent` has a doctype child,\n\t\tif (find(parentChildNodes, isDocTypeNode)) {\n\t\t\tthrow new DOMException(HIERARCHY_REQUEST_ERR, 'Only one doctype is allowed');\n\t\t}\n\t\tvar parentElementChild = find(parentChildNodes, isElementNode);\n\t\t// `child` is non-null and an element is preceding `child`,\n\t\tif (child && parentChildNodes.indexOf(parentElementChild) < parentChildNodes.indexOf(child)) {\n\t\t\tthrow new DOMException(HIERARCHY_REQUEST_ERR, 'Doctype can only be inserted before an element');\n\t\t}\n\t\t// or `child` is null and `parent` has an element child.\n\t\tif (!child && parentElementChild) {\n\t\t\tthrow new DOMException(HIERARCHY_REQUEST_ERR, 'Doctype can not be appended since element is present');\n\t\t}\n\t}\n}\n\n/**\n * @private\n * Step 6 of the checks before inserting and before replacing a child are different.\n *\n * @param {Document} parent the parent node to insert `node` into\n * @param {Node} node the node to insert\n * @param {Node | undefined} child the node that should become the `nextSibling` of `node`\n * @returns {Node}\n * @throws DOMException for several node combinations that would create a DOM that is not well-formed.\n * @throws DOMException if `child` is provided but is not a child of `parent`.\n * @see https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity\n * @see https://dom.spec.whatwg.org/#concept-node-replace\n */\nfunction assertPreReplacementValidityInDocument(parent, node, child) {\n\tvar parentChildNodes = parent.childNodes || [];\n\tvar nodeChildNodes = node.childNodes || [];\n\n\t// DocumentFragment\n\tif (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n\t\tvar nodeChildElements = nodeChildNodes.filter(isElementNode);\n\t\t// If `node` has more than one element child or has a Text node child.\n\t\tif (nodeChildElements.length > 1 || find(nodeChildNodes, isTextNode)) {\n\t\t\tthrow new DOMException(HIERARCHY_REQUEST_ERR, 'More than one element or text in fragment');\n\t\t}\n\t\t// Otherwise, if `node` has one element child and either `parent` has an element child that is not `child` or a doctype is following `child`.\n\t\tif (nodeChildElements.length === 1 && !isElementReplacementPossible(parent, child)) {\n\t\t\tthrow new DOMException(HIERARCHY_REQUEST_ERR, 'Element in fragment can not be inserted before doctype');\n\t\t}\n\t}\n\t// Element\n\tif (isElementNode(node)) {\n\t\t// `parent` has an element child that is not `child` or a doctype is following `child`.\n\t\tif (!isElementReplacementPossible(parent, child)) {\n\t\t\tthrow new DOMException(HIERARCHY_REQUEST_ERR, 'Only one element can be added and only after doctype');\n\t\t}\n\t}\n\t// DocumentType\n\tif (isDocTypeNode(node)) {\n\t\tfunction hasDoctypeChildThatIsNotChild(node) {\n\t\t\treturn isDocTypeNode(node) && node !== child;\n\t\t}\n\n\t\t// `parent` has a doctype child that is not `child`,\n\t\tif (find(parentChildNodes, hasDoctypeChildThatIsNotChild)) {\n\t\t\tthrow new DOMException(HIERARCHY_REQUEST_ERR, 'Only one doctype is allowed');\n\t\t}\n\t\tvar parentElementChild = find(parentChildNodes, isElementNode);\n\t\t// or an element is preceding `child`.\n\t\tif (child && parentChildNodes.indexOf(parentElementChild) < parentChildNodes.indexOf(child)) {\n\t\t\tthrow new DOMException(HIERARCHY_REQUEST_ERR, 'Doctype can only be inserted before an element');\n\t\t}\n\t}\n}\n\n/**\n * @private\n * @param {Node} parent the parent node to insert `node` into\n * @param {Node} node the node to insert\n * @param {Node=} child the node that should become the `nextSibling` of `node`\n * @returns {Node}\n * @throws DOMException for several node combinations that would create a DOM that is not well-formed.\n * @throws DOMException if `child` is provided but is not a child of `parent`.\n * @see https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity\n */\nfunction _insertBefore(parent, node, child, _inDocumentAssertion) {\n\t// To ensure pre-insertion validity of a node into a parent before a child, run these steps:\n\tassertPreInsertionValidity1to5(parent, node, child);\n\n\t// If parent is a document, and any of the statements below, switched on the interface node implements,\n\t// are true, then throw a \"HierarchyRequestError\" DOMException.\n\tif (parent.nodeType === Node.DOCUMENT_NODE) {\n\t\t(_inDocumentAssertion || assertPreInsertionValidityInDocument)(parent, node, child);\n\t}\n\n\tvar cp = node.parentNode;\n\tif(cp){\n\t\tcp.removeChild(node);//remove and update\n\t}\n\tif(node.nodeType === DOCUMENT_FRAGMENT_NODE){\n\t\tvar newFirst = node.firstChild;\n\t\tif (newFirst == null) {\n\t\t\treturn node;\n\t\t}\n\t\tvar newLast = node.lastChild;\n\t}else{\n\t\tnewFirst = newLast = node;\n\t}\n\tvar pre = child ? child.previousSibling : parent.lastChild;\n\n\tnewFirst.previousSibling = pre;\n\tnewLast.nextSibling = child;\n\n\n\tif(pre){\n\t\tpre.nextSibling = newFirst;\n\t}else{\n\t\tparent.firstChild = newFirst;\n\t}\n\tif(child == null){\n\t\tparent.lastChild = newLast;\n\t}else{\n\t\tchild.previousSibling = newLast;\n\t}\n\tdo{\n\t\tnewFirst.parentNode = parent;\n\t}while(newFirst !== newLast && (newFirst= newFirst.nextSibling))\n\t_onUpdateChild(parent.ownerDocument||parent, parent);\n\t//console.log(parent.lastChild.nextSibling == null)\n\tif (node.nodeType == DOCUMENT_FRAGMENT_NODE) {\n\t\tnode.firstChild = node.lastChild = null;\n\t}\n\treturn node;\n}\n\n/**\n * Appends `newChild` to `parentNode`.\n * If `newChild` is already connected to a `parentNode` it is first removed from it.\n *\n * @see https://github.com/xmldom/xmldom/issues/135\n * @see https://github.com/xmldom/xmldom/issues/145\n * @param {Node} parentNode\n * @param {Node} newChild\n * @returns {Node}\n * @private\n */\nfunction _appendSingleChild (parentNode, newChild) {\n\tif (newChild.parentNode) {\n\t\tnewChild.parentNode.removeChild(newChild);\n\t}\n\tnewChild.parentNode = parentNode;\n\tnewChild.previousSibling = parentNode.lastChild;\n\tnewChild.nextSibling = null;\n\tif (newChild.previousSibling) {\n\t\tnewChild.previousSibling.nextSibling = newChild;\n\t} else {\n\t\tparentNode.firstChild = newChild;\n\t}\n\tparentNode.lastChild = newChild;\n\t_onUpdateChild(parentNode.ownerDocument, parentNode, newChild);\n\treturn newChild;\n}\n\nDocument.prototype = {\n\t//implementation : null,\n\tnodeName : '#document',\n\tnodeType : DOCUMENT_NODE,\n\t/**\n\t * The DocumentType node of the document.\n\t *\n\t * @readonly\n\t * @type DocumentType\n\t */\n\tdoctype : null,\n\tdocumentElement : null,\n\t_inc : 1,\n\n\tinsertBefore : function(newChild, refChild){//raises\n\t\tif(newChild.nodeType == DOCUMENT_FRAGMENT_NODE){\n\t\t\tvar child = newChild.firstChild;\n\t\t\twhile(child){\n\t\t\t\tvar next = child.nextSibling;\n\t\t\t\tthis.insertBefore(child,refChild);\n\t\t\t\tchild = next;\n\t\t\t}\n\t\t\treturn newChild;\n\t\t}\n\t\t_insertBefore(this, newChild, refChild);\n\t\tnewChild.ownerDocument = this;\n\t\tif (this.documentElement === null && newChild.nodeType === ELEMENT_NODE) {\n\t\t\tthis.documentElement = newChild;\n\t\t}\n\n\t\treturn newChild;\n\t},\n\tremoveChild : function(oldChild){\n\t\tif(this.documentElement == oldChild){\n\t\t\tthis.documentElement = null;\n\t\t}\n\t\treturn _removeChild(this,oldChild);\n\t},\n\treplaceChild: function (newChild, oldChild) {\n\t\t//raises\n\t\t_insertBefore(this, newChild, oldChild, assertPreReplacementValidityInDocument);\n\t\tnewChild.ownerDocument = this;\n\t\tif (oldChild) {\n\t\t\tthis.removeChild(oldChild);\n\t\t}\n\t\tif (isElementNode(newChild)) {\n\t\t\tthis.documentElement = newChild;\n\t\t}\n\t},\n\t// Introduced in DOM Level 2:\n\timportNode : function(importedNode,deep){\n\t\treturn importNode(this,importedNode,deep);\n\t},\n\t// Introduced in DOM Level 2:\n\tgetElementById :\tfunction(id){\n\t\tvar rtv = null;\n\t\t_visitNode(this.documentElement,function(node){\n\t\t\tif(node.nodeType == ELEMENT_NODE){\n\t\t\t\tif(node.getAttribute('id') == id){\n\t\t\t\t\trtv = node;\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t})\n\t\treturn rtv;\n\t},\n\n\t/**\n\t * The `getElementsByClassName` method of `Document` interface returns an array-like object\n\t * of all child elements which have **all** of the given class name(s).\n\t *\n\t * Returns an empty list if `classeNames` is an empty string or only contains HTML white space characters.\n\t *\n\t *\n\t * Warning: This is a live LiveNodeList.\n\t * Changes in the DOM will reflect in the array as the changes occur.\n\t * If an element selected by this array no longer qualifies for the selector,\n\t * it will automatically be removed. Be aware of this for iteration purposes.\n\t *\n\t * @param {string} classNames is a string representing the class name(s) to match; multiple class names are separated by (ASCII-)whitespace\n\t *\n\t * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/getElementsByClassName\n\t * @see https://dom.spec.whatwg.org/#concept-getelementsbyclassname\n\t */\n\tgetElementsByClassName: function(classNames) {\n\t\tvar classNamesSet = toOrderedSet(classNames)\n\t\treturn new LiveNodeList(this, function(base) {\n\t\t\tvar ls = [];\n\t\t\tif (classNamesSet.length > 0) {\n\t\t\t\t_visitNode(base.documentElement, function(node) {\n\t\t\t\t\tif(node !== base && node.nodeType === ELEMENT_NODE) {\n\t\t\t\t\t\tvar nodeClassNames = node.getAttribute('class')\n\t\t\t\t\t\t// can be null if the attribute does not exist\n\t\t\t\t\t\tif (nodeClassNames) {\n\t\t\t\t\t\t\t// before splitting and iterating just compare them for the most common case\n\t\t\t\t\t\t\tvar matches = classNames === nodeClassNames;\n\t\t\t\t\t\t\tif (!matches) {\n\t\t\t\t\t\t\t\tvar nodeClassNamesSet = toOrderedSet(nodeClassNames)\n\t\t\t\t\t\t\t\tmatches = classNamesSet.every(arrayIncludes(nodeClassNamesSet))\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tif(matches) {\n\t\t\t\t\t\t\t\tls.push(node);\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});\n\t\t\t}\n\t\t\treturn ls;\n\t\t});\n\t},\n\n\t//document factory method:\n\tcreateElement :\tfunction(tagName){\n\t\tvar node = new Element();\n\t\tnode.ownerDocument = this;\n\t\tnode.nodeName = tagName;\n\t\tnode.tagName = tagName;\n\t\tnode.localName = tagName;\n\t\tnode.childNodes = new NodeList();\n\t\tvar attrs\t= node.attributes = new NamedNodeMap();\n\t\tattrs._ownerElement = node;\n\t\treturn node;\n\t},\n\tcreateDocumentFragment :\tfunction(){\n\t\tvar node = new DocumentFragment();\n\t\tnode.ownerDocument = this;\n\t\tnode.childNodes = new NodeList();\n\t\treturn node;\n\t},\n\tcreateTextNode :\tfunction(data){\n\t\tvar node = new Text();\n\t\tnode.ownerDocument = this;\n\t\tnode.appendData(data)\n\t\treturn node;\n\t},\n\tcreateComment :\tfunction(data){\n\t\tvar node = new Comment();\n\t\tnode.ownerDocument = this;\n\t\tnode.appendData(data)\n\t\treturn node;\n\t},\n\tcreateCDATASection :\tfunction(data){\n\t\tvar node = new CDATASection();\n\t\tnode.ownerDocument = this;\n\t\tnode.appendData(data)\n\t\treturn node;\n\t},\n\tcreateProcessingInstruction :\tfunction(target,data){\n\t\tvar node = new ProcessingInstruction();\n\t\tnode.ownerDocument = this;\n\t\tnode.tagName = node.nodeName = node.target = target;\n\t\tnode.nodeValue = node.data = data;\n\t\treturn node;\n\t},\n\tcreateAttribute :\tfunction(name){\n\t\tvar node = new Attr();\n\t\tnode.ownerDocument\t= this;\n\t\tnode.name = name;\n\t\tnode.nodeName\t= name;\n\t\tnode.localName = name;\n\t\tnode.specified = true;\n\t\treturn node;\n\t},\n\tcreateEntityReference :\tfunction(name){\n\t\tvar node = new EntityReference();\n\t\tnode.ownerDocument\t= this;\n\t\tnode.nodeName\t= name;\n\t\treturn node;\n\t},\n\t// Introduced in DOM Level 2:\n\tcreateElementNS :\tfunction(namespaceURI,qualifiedName){\n\t\tvar node = new Element();\n\t\tvar pl = qualifiedName.split(':');\n\t\tvar attrs\t= node.attributes = new NamedNodeMap();\n\t\tnode.childNodes = new NodeList();\n\t\tnode.ownerDocument = this;\n\t\tnode.nodeName = qualifiedName;\n\t\tnode.tagName = qualifiedName;\n\t\tnode.namespaceURI = namespaceURI;\n\t\tif(pl.length == 2){\n\t\t\tnode.prefix = pl[0];\n\t\t\tnode.localName = pl[1];\n\t\t}else{\n\t\t\t//el.prefix = null;\n\t\t\tnode.localName = qualifiedName;\n\t\t}\n\t\tattrs._ownerElement = node;\n\t\treturn node;\n\t},\n\t// Introduced in DOM Level 2:\n\tcreateAttributeNS :\tfunction(namespaceURI,qualifiedName){\n\t\tvar node = new Attr();\n\t\tvar pl = qualifiedName.split(':');\n\t\tnode.ownerDocument = this;\n\t\tnode.nodeName = qualifiedName;\n\t\tnode.name = qualifiedName;\n\t\tnode.namespaceURI = namespaceURI;\n\t\tnode.specified = true;\n\t\tif(pl.length == 2){\n\t\t\tnode.prefix = pl[0];\n\t\t\tnode.localName = pl[1];\n\t\t}else{\n\t\t\t//el.prefix = null;\n\t\t\tnode.localName = qualifiedName;\n\t\t}\n\t\treturn node;\n\t}\n};\n_extends(Document,Node);\n\n\nfunction Element() {\n\tthis._nsMap = {};\n};\nElement.prototype = {\n\tnodeType : ELEMENT_NODE,\n\thasAttribute : function(name){\n\t\treturn this.getAttributeNode(name)!=null;\n\t},\n\tgetAttribute : function(name){\n\t\tvar attr = this.getAttributeNode(name);\n\t\treturn attr && attr.value || '';\n\t},\n\tgetAttributeNode : function(name){\n\t\treturn this.attributes.getNamedItem(name);\n\t},\n\tsetAttribute : function(name, value){\n\t\tvar attr = this.ownerDocument.createAttribute(name);\n\t\tattr.value = attr.nodeValue = \"\" + value;\n\t\tthis.setAttributeNode(attr)\n\t},\n\tremoveAttribute : function(name){\n\t\tvar attr = this.getAttributeNode(name)\n\t\tattr && this.removeAttributeNode(attr);\n\t},\n\n\t//four real opeartion method\n\tappendChild:function(newChild){\n\t\tif(newChild.nodeType === DOCUMENT_FRAGMENT_NODE){\n\t\t\treturn this.insertBefore(newChild,null);\n\t\t}else{\n\t\t\treturn _appendSingleChild(this,newChild);\n\t\t}\n\t},\n\tsetAttributeNode : function(newAttr){\n\t\treturn this.attributes.setNamedItem(newAttr);\n\t},\n\tsetAttributeNodeNS : function(newAttr){\n\t\treturn this.attributes.setNamedItemNS(newAttr);\n\t},\n\tremoveAttributeNode : function(oldAttr){\n\t\t//console.log(this == oldAttr.ownerElement)\n\t\treturn this.attributes.removeNamedItem(oldAttr.nodeName);\n\t},\n\t//get real attribute name,and remove it by removeAttributeNode\n\tremoveAttributeNS : function(namespaceURI, localName){\n\t\tvar old = this.getAttributeNodeNS(namespaceURI, localName);\n\t\told && this.removeAttributeNode(old);\n\t},\n\n\thasAttributeNS : function(namespaceURI, localName){\n\t\treturn this.getAttributeNodeNS(namespaceURI, localName)!=null;\n\t},\n\tgetAttributeNS : function(namespaceURI, localName){\n\t\tvar attr = this.getAttributeNodeNS(namespaceURI, localName);\n\t\treturn attr && attr.value || '';\n\t},\n\tsetAttributeNS : function(namespaceURI, qualifiedName, value){\n\t\tvar attr = this.ownerDocument.createAttributeNS(namespaceURI, qualifiedName);\n\t\tattr.value = attr.nodeValue = \"\" + value;\n\t\tthis.setAttributeNode(attr)\n\t},\n\tgetAttributeNodeNS : function(namespaceURI, localName){\n\t\treturn this.attributes.getNamedItemNS(namespaceURI, localName);\n\t},\n\n\tgetElementsByTagName : function(tagName){\n\t\treturn new LiveNodeList(this,function(base){\n\t\t\tvar ls = [];\n\t\t\t_visitNode(base,function(node){\n\t\t\t\tif(node !== base && node.nodeType == ELEMENT_NODE && (tagName === '*' || node.tagName == tagName)){\n\t\t\t\t\tls.push(node);\n\t\t\t\t}\n\t\t\t});\n\t\t\treturn ls;\n\t\t});\n\t},\n\tgetElementsByTagNameNS : function(namespaceURI, localName){\n\t\treturn new LiveNodeList(this,function(base){\n\t\t\tvar ls = [];\n\t\t\t_visitNode(base,function(node){\n\t\t\t\tif(node !== base && node.nodeType === ELEMENT_NODE && (namespaceURI === '*' || node.namespaceURI === namespaceURI) && (localName === '*' || node.localName == localName)){\n\t\t\t\t\tls.push(node);\n\t\t\t\t}\n\t\t\t});\n\t\t\treturn ls;\n\n\t\t});\n\t}\n};\nDocument.prototype.getElementsByTagName = Element.prototype.getElementsByTagName;\nDocument.prototype.getElementsByTagNameNS = Element.prototype.getElementsByTagNameNS;\n\n\n_extends(Element,Node);\nfunction Attr() {\n};\nAttr.prototype.nodeType = ATTRIBUTE_NODE;\n_extends(Attr,Node);\n\n\nfunction CharacterData() {\n};\nCharacterData.prototype = {\n\tdata : '',\n\tsubstringData : function(offset, count) {\n\t\treturn this.data.substring(offset, offset+count);\n\t},\n\tappendData: function(text) {\n\t\ttext = this.data+text;\n\t\tthis.nodeValue = this.data = text;\n\t\tthis.length = text.length;\n\t},\n\tinsertData: function(offset,text) {\n\t\tthis.replaceData(offset,0,text);\n\n\t},\n\tappendChild:function(newChild){\n\t\tthrow new Error(ExceptionMessage[HIERARCHY_REQUEST_ERR])\n\t},\n\tdeleteData: function(offset, count) {\n\t\tthis.replaceData(offset,count,\"\");\n\t},\n\treplaceData: function(offset, count, text) {\n\t\tvar start = this.data.substring(0,offset);\n\t\tvar end = this.data.substring(offset+count);\n\t\ttext = start + text + end;\n\t\tthis.nodeValue = this.data = text;\n\t\tthis.length = text.length;\n\t}\n}\n_extends(CharacterData,Node);\nfunction Text() {\n};\nText.prototype = {\n\tnodeName : \"#text\",\n\tnodeType : TEXT_NODE,\n\tsplitText : function(offset) {\n\t\tvar text = this.data;\n\t\tvar newText = text.substring(offset);\n\t\ttext = text.substring(0, offset);\n\t\tthis.data = this.nodeValue = text;\n\t\tthis.length = text.length;\n\t\tvar newNode = this.ownerDocument.createTextNode(newText);\n\t\tif(this.parentNode){\n\t\t\tthis.parentNode.insertBefore(newNode, this.nextSibling);\n\t\t}\n\t\treturn newNode;\n\t}\n}\n_extends(Text,CharacterData);\nfunction Comment() {\n};\nComment.prototype = {\n\tnodeName : \"#comment\",\n\tnodeType : COMMENT_NODE\n}\n_extends(Comment,CharacterData);\n\nfunction CDATASection() {\n};\nCDATASection.prototype = {\n\tnodeName : \"#cdata-section\",\n\tnodeType : CDATA_SECTION_NODE\n}\n_extends(CDATASection,CharacterData);\n\n\nfunction DocumentType() {\n};\nDocumentType.prototype.nodeType = DOCUMENT_TYPE_NODE;\n_extends(DocumentType,Node);\n\nfunction Notation() {\n};\nNotation.prototype.nodeType = NOTATION_NODE;\n_extends(Notation,Node);\n\nfunction Entity() {\n};\nEntity.prototype.nodeType = ENTITY_NODE;\n_extends(Entity,Node);\n\nfunction EntityReference() {\n};\nEntityReference.prototype.nodeType = ENTITY_REFERENCE_NODE;\n_extends(EntityReference,Node);\n\nfunction DocumentFragment() {\n};\nDocumentFragment.prototype.nodeName =\t\"#document-fragment\";\nDocumentFragment.prototype.nodeType =\tDOCUMENT_FRAGMENT_NODE;\n_extends(DocumentFragment,Node);\n\n\nfunction ProcessingInstruction() {\n}\nProcessingInstruction.prototype.nodeType = PROCESSING_INSTRUCTION_NODE;\n_extends(ProcessingInstruction,Node);\nfunction XMLSerializer(){}\nXMLSerializer.prototype.serializeToString = function(node,isHtml,nodeFilter){\n\treturn nodeSerializeToString.call(node,isHtml,nodeFilter);\n}\nNode.prototype.toString = nodeSerializeToString;\nfunction nodeSerializeToString(isHtml,nodeFilter){\n\tvar buf = [];\n\tvar refNode = this.nodeType == 9 && this.documentElement || this;\n\tvar prefix = refNode.prefix;\n\tvar uri = refNode.namespaceURI;\n\n\tif(uri && prefix == null){\n\t\t//console.log(prefix)\n\t\tvar prefix = refNode.lookupPrefix(uri);\n\t\tif(prefix == null){\n\t\t\t//isHTML = true;\n\t\t\tvar visibleNamespaces=[\n\t\t\t{namespace:uri,prefix:null}\n\t\t\t//{namespace:uri,prefix:''}\n\t\t\t]\n\t\t}\n\t}\n\tserializeToString(this,buf,isHtml,nodeFilter,visibleNamespaces);\n\t//console.log('###',this.nodeType,uri,prefix,buf.join(''))\n\treturn buf.join('');\n}\n\nfunction needNamespaceDefine(node, isHTML, visibleNamespaces) {\n\tvar prefix = node.prefix || '';\n\tvar uri = node.namespaceURI;\n\t// According to [Namespaces in XML 1.0](https://www.w3.org/TR/REC-xml-names/#ns-using) ,\n\t// and more specifically https://www.w3.org/TR/REC-xml-names/#nsc-NoPrefixUndecl :\n\t// > In a namespace declaration for a prefix [...], the attribute value MUST NOT be empty.\n\t// in a similar manner [Namespaces in XML 1.1](https://www.w3.org/TR/xml-names11/#ns-using)\n\t// and more specifically https://www.w3.org/TR/xml-names11/#nsc-NSDeclared :\n\t// > [...] Furthermore, the attribute value [...] must not be an empty string.\n\t// so serializing empty namespace value like xmlns:ds=\"\" would produce an invalid XML document.\n\tif (!uri) {\n\t\treturn false;\n\t}\n\tif (prefix === \"xml\" && uri === NAMESPACE.XML || uri === NAMESPACE.XMLNS) {\n\t\treturn false;\n\t}\n\n\tvar i = visibleNamespaces.length\n\twhile (i--) {\n\t\tvar ns = visibleNamespaces[i];\n\t\t// get namespace prefix\n\t\tif (ns.prefix === prefix) {\n\t\t\treturn ns.namespace !== uri;\n\t\t}\n\t}\n\treturn true;\n}\n/**\n * Well-formed constraint: No < in Attribute Values\n * > The replacement text of any entity referred to directly or indirectly\n * > in an attribute value must not contain a <.\n * @see https://www.w3.org/TR/xml11/#CleanAttrVals\n * @see https://www.w3.org/TR/xml11/#NT-AttValue\n *\n * Literal whitespace other than space that appear in attribute values\n * are serialized as their entity references, so they will be preserved.\n * (In contrast to whitespace literals in the input which are normalized to spaces)\n * @see https://www.w3.org/TR/xml11/#AVNormalize\n * @see https://w3c.github.io/DOM-Parsing/#serializing-an-element-s-attributes\n */\nfunction addSerializedAttribute(buf, qualifiedName, value) {\n\tbuf.push(' ', qualifiedName, '=\"', value.replace(/[<>&\"\\t\\n\\r]/g, _xmlEncoder), '\"')\n}\n\nfunction serializeToString(node,buf,isHTML,nodeFilter,visibleNamespaces){\n\tif (!visibleNamespaces) {\n\t\tvisibleNamespaces = [];\n\t}\n\n\tif(nodeFilter){\n\t\tnode = nodeFilter(node);\n\t\tif(node){\n\t\t\tif(typeof node == 'string'){\n\t\t\t\tbuf.push(node);\n\t\t\t\treturn;\n\t\t\t}\n\t\t}else{\n\t\t\treturn;\n\t\t}\n\t\t//buf.sort.apply(attrs, attributeSorter);\n\t}\n\n\tswitch(node.nodeType){\n\tcase ELEMENT_NODE:\n\t\tvar attrs = node.attributes;\n\t\tvar len = attrs.length;\n\t\tvar child = node.firstChild;\n\t\tvar nodeName = node.tagName;\n\n\t\tisHTML = NAMESPACE.isHTML(node.namespaceURI) || isHTML\n\n\t\tvar prefixedNodeName = nodeName\n\t\tif (!isHTML && !node.prefix && node.namespaceURI) {\n\t\t\tvar defaultNS\n\t\t\t// lookup current default ns from `xmlns` attribute\n\t\t\tfor (var ai = 0; ai < attrs.length; ai++) {\n\t\t\t\tif (attrs.item(ai).name === 'xmlns') {\n\t\t\t\t\tdefaultNS = attrs.item(ai).value\n\t\t\t\t\tbreak\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (!defaultNS) {\n\t\t\t\t// lookup current default ns in visibleNamespaces\n\t\t\t\tfor (var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--) {\n\t\t\t\t\tvar namespace = visibleNamespaces[nsi]\n\t\t\t\t\tif (namespace.prefix === '' && namespace.namespace === node.namespaceURI) {\n\t\t\t\t\t\tdefaultNS = namespace.namespace\n\t\t\t\t\t\tbreak\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (defaultNS !== node.namespaceURI) {\n\t\t\t\tfor (var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--) {\n\t\t\t\t\tvar namespace = visibleNamespaces[nsi]\n\t\t\t\t\tif (namespace.namespace === node.namespaceURI) {\n\t\t\t\t\t\tif (namespace.prefix) {\n\t\t\t\t\t\t\tprefixedNodeName = namespace.prefix + ':' + nodeName\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tbuf.push('<', prefixedNodeName);\n\n\t\tfor(var i=0;i');\n\t\t\t//if is cdata child node\n\t\t\tif(isHTML && /^script$/i.test(nodeName)){\n\t\t\t\twhile(child){\n\t\t\t\t\tif(child.data){\n\t\t\t\t\t\tbuf.push(child.data);\n\t\t\t\t\t}else{\n\t\t\t\t\t\tserializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());\n\t\t\t\t\t}\n\t\t\t\t\tchild = child.nextSibling;\n\t\t\t\t}\n\t\t\t}else\n\t\t\t{\n\t\t\t\twhile(child){\n\t\t\t\t\tserializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());\n\t\t\t\t\tchild = child.nextSibling;\n\t\t\t\t}\n\t\t\t}\n\t\t\tbuf.push('');\n\t\t}else{\n\t\t\tbuf.push('/>');\n\t\t}\n\t\t// remove added visible namespaces\n\t\t//visibleNamespaces.length = startVisibleNamespaces;\n\t\treturn;\n\tcase DOCUMENT_NODE:\n\tcase DOCUMENT_FRAGMENT_NODE:\n\t\tvar child = node.firstChild;\n\t\twhile(child){\n\t\t\tserializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());\n\t\t\tchild = child.nextSibling;\n\t\t}\n\t\treturn;\n\tcase ATTRIBUTE_NODE:\n\t\treturn addSerializedAttribute(buf, node.name, node.value);\n\tcase TEXT_NODE:\n\t\t/**\n\t\t * The ampersand character (&) and the left angle bracket (<) must not appear in their literal form,\n\t\t * except when used as markup delimiters, or within a comment, a processing instruction, or a CDATA section.\n\t\t * If they are needed elsewhere, they must be escaped using either numeric character references or the strings\n\t\t * `&` and `<` respectively.\n\t\t * The right angle bracket (>) may be represented using the string \" > \", and must, for compatibility,\n\t\t * be escaped using either `>` or a character reference when it appears in the string `]]>` in content,\n\t\t * when that string is not marking the end of a CDATA section.\n\t\t *\n\t\t * In the content of elements, character data is any string of characters\n\t\t * which does not contain the start-delimiter of any markup\n\t\t * and does not include the CDATA-section-close delimiter, `]]>`.\n\t\t *\n\t\t * @see https://www.w3.org/TR/xml/#NT-CharData\n\t\t * @see https://w3c.github.io/DOM-Parsing/#xml-serializing-a-text-node\n\t\t */\n\t\treturn buf.push(node.data\n\t\t\t.replace(/[<&>]/g,_xmlEncoder)\n\t\t);\n\tcase CDATA_SECTION_NODE:\n\t\treturn buf.push( '');\n\tcase COMMENT_NODE:\n\t\treturn buf.push( \"\");\n\tcase DOCUMENT_TYPE_NODE:\n\t\tvar pubid = node.publicId;\n\t\tvar sysid = node.systemId;\n\t\tbuf.push('');\n\t\t}else if(sysid && sysid!='.'){\n\t\t\tbuf.push(' SYSTEM ', sysid, '>');\n\t\t}else{\n\t\t\tvar sub = node.internalSubset;\n\t\t\tif(sub){\n\t\t\t\tbuf.push(\" [\",sub,\"]\");\n\t\t\t}\n\t\t\tbuf.push(\">\");\n\t\t}\n\t\treturn;\n\tcase PROCESSING_INSTRUCTION_NODE:\n\t\treturn buf.push( \"\");\n\tcase ENTITY_REFERENCE_NODE:\n\t\treturn buf.push( '&',node.nodeName,';');\n\t//case ENTITY_NODE:\n\t//case NOTATION_NODE:\n\tdefault:\n\t\tbuf.push('??',node.nodeName);\n\t}\n}\nfunction importNode(doc,node,deep){\n\tvar node2;\n\tswitch (node.nodeType) {\n\tcase ELEMENT_NODE:\n\t\tnode2 = node.cloneNode(false);\n\t\tnode2.ownerDocument = doc;\n\t\t//var attrs = node2.attributes;\n\t\t//var len = attrs.length;\n\t\t//for(var i=0;i',\n\tlt: '<',\n\tquot: '\"',\n});\n\n/**\n * A map of all entities that are detected in an HTML document.\n * They contain all entries from `XML_ENTITIES`.\n *\n * @see XML_ENTITIES\n * @see DOMParser.parseFromString\n * @see DOMImplementation.prototype.createHTMLDocument\n * @see https://html.spec.whatwg.org/#named-character-references WHATWG HTML(5) Spec\n * @see https://html.spec.whatwg.org/entities.json JSON\n * @see https://www.w3.org/TR/xml-entity-names/ W3C XML Entity Names\n * @see https://www.w3.org/TR/html4/sgml/entities.html W3C HTML4/SGML\n * @see https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references#Character_entity_references_in_HTML Wikipedia (HTML)\n * @see https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references#Entities_representing_special_characters_in_XHTML Wikpedia (XHTML)\n */\nexports.HTML_ENTITIES = freeze({\n\tAacute: '\\u00C1',\n\taacute: '\\u00E1',\n\tAbreve: '\\u0102',\n\tabreve: '\\u0103',\n\tac: '\\u223E',\n\tacd: '\\u223F',\n\tacE: '\\u223E\\u0333',\n\tAcirc: '\\u00C2',\n\tacirc: '\\u00E2',\n\tacute: '\\u00B4',\n\tAcy: '\\u0410',\n\tacy: '\\u0430',\n\tAElig: '\\u00C6',\n\taelig: '\\u00E6',\n\taf: '\\u2061',\n\tAfr: '\\uD835\\uDD04',\n\tafr: '\\uD835\\uDD1E',\n\tAgrave: '\\u00C0',\n\tagrave: '\\u00E0',\n\talefsym: '\\u2135',\n\taleph: '\\u2135',\n\tAlpha: '\\u0391',\n\talpha: '\\u03B1',\n\tAmacr: '\\u0100',\n\tamacr: '\\u0101',\n\tamalg: '\\u2A3F',\n\tAMP: '\\u0026',\n\tamp: '\\u0026',\n\tAnd: '\\u2A53',\n\tand: '\\u2227',\n\tandand: '\\u2A55',\n\tandd: '\\u2A5C',\n\tandslope: '\\u2A58',\n\tandv: '\\u2A5A',\n\tang: '\\u2220',\n\tange: '\\u29A4',\n\tangle: '\\u2220',\n\tangmsd: '\\u2221',\n\tangmsdaa: '\\u29A8',\n\tangmsdab: '\\u29A9',\n\tangmsdac: '\\u29AA',\n\tangmsdad: '\\u29AB',\n\tangmsdae: '\\u29AC',\n\tangmsdaf: '\\u29AD',\n\tangmsdag: '\\u29AE',\n\tangmsdah: '\\u29AF',\n\tangrt: '\\u221F',\n\tangrtvb: '\\u22BE',\n\tangrtvbd: '\\u299D',\n\tangsph: '\\u2222',\n\tangst: '\\u00C5',\n\tangzarr: '\\u237C',\n\tAogon: '\\u0104',\n\taogon: '\\u0105',\n\tAopf: '\\uD835\\uDD38',\n\taopf: '\\uD835\\uDD52',\n\tap: '\\u2248',\n\tapacir: '\\u2A6F',\n\tapE: '\\u2A70',\n\tape: '\\u224A',\n\tapid: '\\u224B',\n\tapos: '\\u0027',\n\tApplyFunction: '\\u2061',\n\tapprox: '\\u2248',\n\tapproxeq: '\\u224A',\n\tAring: '\\u00C5',\n\taring: '\\u00E5',\n\tAscr: '\\uD835\\uDC9C',\n\tascr: '\\uD835\\uDCB6',\n\tAssign: '\\u2254',\n\tast: '\\u002A',\n\tasymp: '\\u2248',\n\tasympeq: '\\u224D',\n\tAtilde: '\\u00C3',\n\tatilde: '\\u00E3',\n\tAuml: '\\u00C4',\n\tauml: '\\u00E4',\n\tawconint: '\\u2233',\n\tawint: '\\u2A11',\n\tbackcong: '\\u224C',\n\tbackepsilon: '\\u03F6',\n\tbackprime: '\\u2035',\n\tbacksim: '\\u223D',\n\tbacksimeq: '\\u22CD',\n\tBackslash: '\\u2216',\n\tBarv: '\\u2AE7',\n\tbarvee: '\\u22BD',\n\tBarwed: '\\u2306',\n\tbarwed: '\\u2305',\n\tbarwedge: '\\u2305',\n\tbbrk: '\\u23B5',\n\tbbrktbrk: '\\u23B6',\n\tbcong: '\\u224C',\n\tBcy: '\\u0411',\n\tbcy: '\\u0431',\n\tbdquo: '\\u201E',\n\tbecaus: '\\u2235',\n\tBecause: '\\u2235',\n\tbecause: '\\u2235',\n\tbemptyv: '\\u29B0',\n\tbepsi: '\\u03F6',\n\tbernou: '\\u212C',\n\tBernoullis: '\\u212C',\n\tBeta: '\\u0392',\n\tbeta: '\\u03B2',\n\tbeth: '\\u2136',\n\tbetween: '\\u226C',\n\tBfr: '\\uD835\\uDD05',\n\tbfr: '\\uD835\\uDD1F',\n\tbigcap: '\\u22C2',\n\tbigcirc: '\\u25EF',\n\tbigcup: '\\u22C3',\n\tbigodot: '\\u2A00',\n\tbigoplus: '\\u2A01',\n\tbigotimes: '\\u2A02',\n\tbigsqcup: '\\u2A06',\n\tbigstar: '\\u2605',\n\tbigtriangledown: '\\u25BD',\n\tbigtriangleup: '\\u25B3',\n\tbiguplus: '\\u2A04',\n\tbigvee: '\\u22C1',\n\tbigwedge: '\\u22C0',\n\tbkarow: '\\u290D',\n\tblacklozenge: '\\u29EB',\n\tblacksquare: '\\u25AA',\n\tblacktriangle: '\\u25B4',\n\tblacktriangledown: '\\u25BE',\n\tblacktriangleleft: '\\u25C2',\n\tblacktriangleright: '\\u25B8',\n\tblank: '\\u2423',\n\tblk12: '\\u2592',\n\tblk14: '\\u2591',\n\tblk34: '\\u2593',\n\tblock: '\\u2588',\n\tbne: '\\u003D\\u20E5',\n\tbnequiv: '\\u2261\\u20E5',\n\tbNot: '\\u2AED',\n\tbnot: '\\u2310',\n\tBopf: '\\uD835\\uDD39',\n\tbopf: '\\uD835\\uDD53',\n\tbot: '\\u22A5',\n\tbottom: '\\u22A5',\n\tbowtie: '\\u22C8',\n\tboxbox: '\\u29C9',\n\tboxDL: '\\u2557',\n\tboxDl: '\\u2556',\n\tboxdL: '\\u2555',\n\tboxdl: '\\u2510',\n\tboxDR: '\\u2554',\n\tboxDr: '\\u2553',\n\tboxdR: '\\u2552',\n\tboxdr: '\\u250C',\n\tboxH: '\\u2550',\n\tboxh: '\\u2500',\n\tboxHD: '\\u2566',\n\tboxHd: '\\u2564',\n\tboxhD: '\\u2565',\n\tboxhd: '\\u252C',\n\tboxHU: '\\u2569',\n\tboxHu: '\\u2567',\n\tboxhU: '\\u2568',\n\tboxhu: '\\u2534',\n\tboxminus: '\\u229F',\n\tboxplus: '\\u229E',\n\tboxtimes: '\\u22A0',\n\tboxUL: '\\u255D',\n\tboxUl: '\\u255C',\n\tboxuL: '\\u255B',\n\tboxul: '\\u2518',\n\tboxUR: '\\u255A',\n\tboxUr: '\\u2559',\n\tboxuR: '\\u2558',\n\tboxur: '\\u2514',\n\tboxV: '\\u2551',\n\tboxv: '\\u2502',\n\tboxVH: '\\u256C',\n\tboxVh: '\\u256B',\n\tboxvH: '\\u256A',\n\tboxvh: '\\u253C',\n\tboxVL: '\\u2563',\n\tboxVl: '\\u2562',\n\tboxvL: '\\u2561',\n\tboxvl: '\\u2524',\n\tboxVR: '\\u2560',\n\tboxVr: '\\u255F',\n\tboxvR: '\\u255E',\n\tboxvr: '\\u251C',\n\tbprime: '\\u2035',\n\tBreve: '\\u02D8',\n\tbreve: '\\u02D8',\n\tbrvbar: '\\u00A6',\n\tBscr: '\\u212C',\n\tbscr: '\\uD835\\uDCB7',\n\tbsemi: '\\u204F',\n\tbsim: '\\u223D',\n\tbsime: '\\u22CD',\n\tbsol: '\\u005C',\n\tbsolb: '\\u29C5',\n\tbsolhsub: '\\u27C8',\n\tbull: '\\u2022',\n\tbullet: '\\u2022',\n\tbump: '\\u224E',\n\tbumpE: '\\u2AAE',\n\tbumpe: '\\u224F',\n\tBumpeq: '\\u224E',\n\tbumpeq: '\\u224F',\n\tCacute: '\\u0106',\n\tcacute: '\\u0107',\n\tCap: '\\u22D2',\n\tcap: '\\u2229',\n\tcapand: '\\u2A44',\n\tcapbrcup: '\\u2A49',\n\tcapcap: '\\u2A4B',\n\tcapcup: '\\u2A47',\n\tcapdot: '\\u2A40',\n\tCapitalDifferentialD: '\\u2145',\n\tcaps: '\\u2229\\uFE00',\n\tcaret: '\\u2041',\n\tcaron: '\\u02C7',\n\tCayleys: '\\u212D',\n\tccaps: '\\u2A4D',\n\tCcaron: '\\u010C',\n\tccaron: '\\u010D',\n\tCcedil: '\\u00C7',\n\tccedil: '\\u00E7',\n\tCcirc: '\\u0108',\n\tccirc: '\\u0109',\n\tCconint: '\\u2230',\n\tccups: '\\u2A4C',\n\tccupssm: '\\u2A50',\n\tCdot: '\\u010A',\n\tcdot: '\\u010B',\n\tcedil: '\\u00B8',\n\tCedilla: '\\u00B8',\n\tcemptyv: '\\u29B2',\n\tcent: '\\u00A2',\n\tCenterDot: '\\u00B7',\n\tcenterdot: '\\u00B7',\n\tCfr: '\\u212D',\n\tcfr: '\\uD835\\uDD20',\n\tCHcy: '\\u0427',\n\tchcy: '\\u0447',\n\tcheck: '\\u2713',\n\tcheckmark: '\\u2713',\n\tChi: '\\u03A7',\n\tchi: '\\u03C7',\n\tcir: '\\u25CB',\n\tcirc: '\\u02C6',\n\tcirceq: '\\u2257',\n\tcirclearrowleft: '\\u21BA',\n\tcirclearrowright: '\\u21BB',\n\tcircledast: '\\u229B',\n\tcircledcirc: '\\u229A',\n\tcircleddash: '\\u229D',\n\tCircleDot: '\\u2299',\n\tcircledR: '\\u00AE',\n\tcircledS: '\\u24C8',\n\tCircleMinus: '\\u2296',\n\tCirclePlus: '\\u2295',\n\tCircleTimes: '\\u2297',\n\tcirE: '\\u29C3',\n\tcire: '\\u2257',\n\tcirfnint: '\\u2A10',\n\tcirmid: '\\u2AEF',\n\tcirscir: '\\u29C2',\n\tClockwiseContourIntegral: '\\u2232',\n\tCloseCurlyDoubleQuote: '\\u201D',\n\tCloseCurlyQuote: '\\u2019',\n\tclubs: '\\u2663',\n\tclubsuit: '\\u2663',\n\tColon: '\\u2237',\n\tcolon: '\\u003A',\n\tColone: '\\u2A74',\n\tcolone: '\\u2254',\n\tcoloneq: '\\u2254',\n\tcomma: '\\u002C',\n\tcommat: '\\u0040',\n\tcomp: '\\u2201',\n\tcompfn: '\\u2218',\n\tcomplement: '\\u2201',\n\tcomplexes: '\\u2102',\n\tcong: '\\u2245',\n\tcongdot: '\\u2A6D',\n\tCongruent: '\\u2261',\n\tConint: '\\u222F',\n\tconint: '\\u222E',\n\tContourIntegral: '\\u222E',\n\tCopf: '\\u2102',\n\tcopf: '\\uD835\\uDD54',\n\tcoprod: '\\u2210',\n\tCoproduct: '\\u2210',\n\tCOPY: '\\u00A9',\n\tcopy: '\\u00A9',\n\tcopysr: '\\u2117',\n\tCounterClockwiseContourIntegral: '\\u2233',\n\tcrarr: '\\u21B5',\n\tCross: '\\u2A2F',\n\tcross: '\\u2717',\n\tCscr: '\\uD835\\uDC9E',\n\tcscr: '\\uD835\\uDCB8',\n\tcsub: '\\u2ACF',\n\tcsube: '\\u2AD1',\n\tcsup: '\\u2AD0',\n\tcsupe: '\\u2AD2',\n\tctdot: '\\u22EF',\n\tcudarrl: '\\u2938',\n\tcudarrr: '\\u2935',\n\tcuepr: '\\u22DE',\n\tcuesc: '\\u22DF',\n\tcularr: '\\u21B6',\n\tcularrp: '\\u293D',\n\tCup: '\\u22D3',\n\tcup: '\\u222A',\n\tcupbrcap: '\\u2A48',\n\tCupCap: '\\u224D',\n\tcupcap: '\\u2A46',\n\tcupcup: '\\u2A4A',\n\tcupdot: '\\u228D',\n\tcupor: '\\u2A45',\n\tcups: '\\u222A\\uFE00',\n\tcurarr: '\\u21B7',\n\tcurarrm: '\\u293C',\n\tcurlyeqprec: '\\u22DE',\n\tcurlyeqsucc: '\\u22DF',\n\tcurlyvee: '\\u22CE',\n\tcurlywedge: '\\u22CF',\n\tcurren: '\\u00A4',\n\tcurvearrowleft: '\\u21B6',\n\tcurvearrowright: '\\u21B7',\n\tcuvee: '\\u22CE',\n\tcuwed: '\\u22CF',\n\tcwconint: '\\u2232',\n\tcwint: '\\u2231',\n\tcylcty: '\\u232D',\n\tDagger: '\\u2021',\n\tdagger: '\\u2020',\n\tdaleth: '\\u2138',\n\tDarr: '\\u21A1',\n\tdArr: '\\u21D3',\n\tdarr: '\\u2193',\n\tdash: '\\u2010',\n\tDashv: '\\u2AE4',\n\tdashv: '\\u22A3',\n\tdbkarow: '\\u290F',\n\tdblac: '\\u02DD',\n\tDcaron: '\\u010E',\n\tdcaron: '\\u010F',\n\tDcy: '\\u0414',\n\tdcy: '\\u0434',\n\tDD: '\\u2145',\n\tdd: '\\u2146',\n\tddagger: '\\u2021',\n\tddarr: '\\u21CA',\n\tDDotrahd: '\\u2911',\n\tddotseq: '\\u2A77',\n\tdeg: '\\u00B0',\n\tDel: '\\u2207',\n\tDelta: '\\u0394',\n\tdelta: '\\u03B4',\n\tdemptyv: '\\u29B1',\n\tdfisht: '\\u297F',\n\tDfr: '\\uD835\\uDD07',\n\tdfr: '\\uD835\\uDD21',\n\tdHar: '\\u2965',\n\tdharl: '\\u21C3',\n\tdharr: '\\u21C2',\n\tDiacriticalAcute: '\\u00B4',\n\tDiacriticalDot: '\\u02D9',\n\tDiacriticalDoubleAcute: '\\u02DD',\n\tDiacriticalGrave: '\\u0060',\n\tDiacriticalTilde: '\\u02DC',\n\tdiam: '\\u22C4',\n\tDiamond: '\\u22C4',\n\tdiamond: '\\u22C4',\n\tdiamondsuit: '\\u2666',\n\tdiams: '\\u2666',\n\tdie: '\\u00A8',\n\tDifferentialD: '\\u2146',\n\tdigamma: '\\u03DD',\n\tdisin: '\\u22F2',\n\tdiv: '\\u00F7',\n\tdivide: '\\u00F7',\n\tdivideontimes: '\\u22C7',\n\tdivonx: '\\u22C7',\n\tDJcy: '\\u0402',\n\tdjcy: '\\u0452',\n\tdlcorn: '\\u231E',\n\tdlcrop: '\\u230D',\n\tdollar: '\\u0024',\n\tDopf: '\\uD835\\uDD3B',\n\tdopf: '\\uD835\\uDD55',\n\tDot: '\\u00A8',\n\tdot: '\\u02D9',\n\tDotDot: '\\u20DC',\n\tdoteq: '\\u2250',\n\tdoteqdot: '\\u2251',\n\tDotEqual: '\\u2250',\n\tdotminus: '\\u2238',\n\tdotplus: '\\u2214',\n\tdotsquare: '\\u22A1',\n\tdoublebarwedge: '\\u2306',\n\tDoubleContourIntegral: '\\u222F',\n\tDoubleDot: '\\u00A8',\n\tDoubleDownArrow: '\\u21D3',\n\tDoubleLeftArrow: '\\u21D0',\n\tDoubleLeftRightArrow: '\\u21D4',\n\tDoubleLeftTee: '\\u2AE4',\n\tDoubleLongLeftArrow: '\\u27F8',\n\tDoubleLongLeftRightArrow: '\\u27FA',\n\tDoubleLongRightArrow: '\\u27F9',\n\tDoubleRightArrow: '\\u21D2',\n\tDoubleRightTee: '\\u22A8',\n\tDoubleUpArrow: '\\u21D1',\n\tDoubleUpDownArrow: '\\u21D5',\n\tDoubleVerticalBar: '\\u2225',\n\tDownArrow: '\\u2193',\n\tDownarrow: '\\u21D3',\n\tdownarrow: '\\u2193',\n\tDownArrowBar: '\\u2913',\n\tDownArrowUpArrow: '\\u21F5',\n\tDownBreve: '\\u0311',\n\tdowndownarrows: '\\u21CA',\n\tdownharpoonleft: '\\u21C3',\n\tdownharpoonright: '\\u21C2',\n\tDownLeftRightVector: '\\u2950',\n\tDownLeftTeeVector: '\\u295E',\n\tDownLeftVector: '\\u21BD',\n\tDownLeftVectorBar: '\\u2956',\n\tDownRightTeeVector: '\\u295F',\n\tDownRightVector: '\\u21C1',\n\tDownRightVectorBar: '\\u2957',\n\tDownTee: '\\u22A4',\n\tDownTeeArrow: '\\u21A7',\n\tdrbkarow: '\\u2910',\n\tdrcorn: '\\u231F',\n\tdrcrop: '\\u230C',\n\tDscr: '\\uD835\\uDC9F',\n\tdscr: '\\uD835\\uDCB9',\n\tDScy: '\\u0405',\n\tdscy: '\\u0455',\n\tdsol: '\\u29F6',\n\tDstrok: '\\u0110',\n\tdstrok: '\\u0111',\n\tdtdot: '\\u22F1',\n\tdtri: '\\u25BF',\n\tdtrif: '\\u25BE',\n\tduarr: '\\u21F5',\n\tduhar: '\\u296F',\n\tdwangle: '\\u29A6',\n\tDZcy: '\\u040F',\n\tdzcy: '\\u045F',\n\tdzigrarr: '\\u27FF',\n\tEacute: '\\u00C9',\n\teacute: '\\u00E9',\n\teaster: '\\u2A6E',\n\tEcaron: '\\u011A',\n\tecaron: '\\u011B',\n\tecir: '\\u2256',\n\tEcirc: '\\u00CA',\n\tecirc: '\\u00EA',\n\tecolon: '\\u2255',\n\tEcy: '\\u042D',\n\tecy: '\\u044D',\n\teDDot: '\\u2A77',\n\tEdot: '\\u0116',\n\teDot: '\\u2251',\n\tedot: '\\u0117',\n\tee: '\\u2147',\n\tefDot: '\\u2252',\n\tEfr: '\\uD835\\uDD08',\n\tefr: '\\uD835\\uDD22',\n\teg: '\\u2A9A',\n\tEgrave: '\\u00C8',\n\tegrave: '\\u00E8',\n\tegs: '\\u2A96',\n\tegsdot: '\\u2A98',\n\tel: '\\u2A99',\n\tElement: '\\u2208',\n\telinters: '\\u23E7',\n\tell: '\\u2113',\n\tels: '\\u2A95',\n\telsdot: '\\u2A97',\n\tEmacr: '\\u0112',\n\temacr: '\\u0113',\n\tempty: '\\u2205',\n\temptyset: '\\u2205',\n\tEmptySmallSquare: '\\u25FB',\n\temptyv: '\\u2205',\n\tEmptyVerySmallSquare: '\\u25AB',\n\temsp: '\\u2003',\n\temsp13: '\\u2004',\n\temsp14: '\\u2005',\n\tENG: '\\u014A',\n\teng: '\\u014B',\n\tensp: '\\u2002',\n\tEogon: '\\u0118',\n\teogon: '\\u0119',\n\tEopf: '\\uD835\\uDD3C',\n\teopf: '\\uD835\\uDD56',\n\tepar: '\\u22D5',\n\teparsl: '\\u29E3',\n\teplus: '\\u2A71',\n\tepsi: '\\u03B5',\n\tEpsilon: '\\u0395',\n\tepsilon: '\\u03B5',\n\tepsiv: '\\u03F5',\n\teqcirc: '\\u2256',\n\teqcolon: '\\u2255',\n\teqsim: '\\u2242',\n\teqslantgtr: '\\u2A96',\n\teqslantless: '\\u2A95',\n\tEqual: '\\u2A75',\n\tequals: '\\u003D',\n\tEqualTilde: '\\u2242',\n\tequest: '\\u225F',\n\tEquilibrium: '\\u21CC',\n\tequiv: '\\u2261',\n\tequivDD: '\\u2A78',\n\teqvparsl: '\\u29E5',\n\terarr: '\\u2971',\n\terDot: '\\u2253',\n\tEscr: '\\u2130',\n\tescr: '\\u212F',\n\tesdot: '\\u2250',\n\tEsim: '\\u2A73',\n\tesim: '\\u2242',\n\tEta: '\\u0397',\n\teta: '\\u03B7',\n\tETH: '\\u00D0',\n\teth: '\\u00F0',\n\tEuml: '\\u00CB',\n\teuml: '\\u00EB',\n\teuro: '\\u20AC',\n\texcl: '\\u0021',\n\texist: '\\u2203',\n\tExists: '\\u2203',\n\texpectation: '\\u2130',\n\tExponentialE: '\\u2147',\n\texponentiale: '\\u2147',\n\tfallingdotseq: '\\u2252',\n\tFcy: '\\u0424',\n\tfcy: '\\u0444',\n\tfemale: '\\u2640',\n\tffilig: '\\uFB03',\n\tfflig: '\\uFB00',\n\tffllig: '\\uFB04',\n\tFfr: '\\uD835\\uDD09',\n\tffr: '\\uD835\\uDD23',\n\tfilig: '\\uFB01',\n\tFilledSmallSquare: '\\u25FC',\n\tFilledVerySmallSquare: '\\u25AA',\n\tfjlig: '\\u0066\\u006A',\n\tflat: '\\u266D',\n\tfllig: '\\uFB02',\n\tfltns: '\\u25B1',\n\tfnof: '\\u0192',\n\tFopf: '\\uD835\\uDD3D',\n\tfopf: '\\uD835\\uDD57',\n\tForAll: '\\u2200',\n\tforall: '\\u2200',\n\tfork: '\\u22D4',\n\tforkv: '\\u2AD9',\n\tFouriertrf: '\\u2131',\n\tfpartint: '\\u2A0D',\n\tfrac12: '\\u00BD',\n\tfrac13: '\\u2153',\n\tfrac14: '\\u00BC',\n\tfrac15: '\\u2155',\n\tfrac16: '\\u2159',\n\tfrac18: '\\u215B',\n\tfrac23: '\\u2154',\n\tfrac25: '\\u2156',\n\tfrac34: '\\u00BE',\n\tfrac35: '\\u2157',\n\tfrac38: '\\u215C',\n\tfrac45: '\\u2158',\n\tfrac56: '\\u215A',\n\tfrac58: '\\u215D',\n\tfrac78: '\\u215E',\n\tfrasl: '\\u2044',\n\tfrown: '\\u2322',\n\tFscr: '\\u2131',\n\tfscr: '\\uD835\\uDCBB',\n\tgacute: '\\u01F5',\n\tGamma: '\\u0393',\n\tgamma: '\\u03B3',\n\tGammad: '\\u03DC',\n\tgammad: '\\u03DD',\n\tgap: '\\u2A86',\n\tGbreve: '\\u011E',\n\tgbreve: '\\u011F',\n\tGcedil: '\\u0122',\n\tGcirc: '\\u011C',\n\tgcirc: '\\u011D',\n\tGcy: '\\u0413',\n\tgcy: '\\u0433',\n\tGdot: '\\u0120',\n\tgdot: '\\u0121',\n\tgE: '\\u2267',\n\tge: '\\u2265',\n\tgEl: '\\u2A8C',\n\tgel: '\\u22DB',\n\tgeq: '\\u2265',\n\tgeqq: '\\u2267',\n\tgeqslant: '\\u2A7E',\n\tges: '\\u2A7E',\n\tgescc: '\\u2AA9',\n\tgesdot: '\\u2A80',\n\tgesdoto: '\\u2A82',\n\tgesdotol: '\\u2A84',\n\tgesl: '\\u22DB\\uFE00',\n\tgesles: '\\u2A94',\n\tGfr: '\\uD835\\uDD0A',\n\tgfr: '\\uD835\\uDD24',\n\tGg: '\\u22D9',\n\tgg: '\\u226B',\n\tggg: '\\u22D9',\n\tgimel: '\\u2137',\n\tGJcy: '\\u0403',\n\tgjcy: '\\u0453',\n\tgl: '\\u2277',\n\tgla: '\\u2AA5',\n\tglE: '\\u2A92',\n\tglj: '\\u2AA4',\n\tgnap: '\\u2A8A',\n\tgnapprox: '\\u2A8A',\n\tgnE: '\\u2269',\n\tgne: '\\u2A88',\n\tgneq: '\\u2A88',\n\tgneqq: '\\u2269',\n\tgnsim: '\\u22E7',\n\tGopf: '\\uD835\\uDD3E',\n\tgopf: '\\uD835\\uDD58',\n\tgrave: '\\u0060',\n\tGreaterEqual: '\\u2265',\n\tGreaterEqualLess: '\\u22DB',\n\tGreaterFullEqual: '\\u2267',\n\tGreaterGreater: '\\u2AA2',\n\tGreaterLess: '\\u2277',\n\tGreaterSlantEqual: '\\u2A7E',\n\tGreaterTilde: '\\u2273',\n\tGscr: '\\uD835\\uDCA2',\n\tgscr: '\\u210A',\n\tgsim: '\\u2273',\n\tgsime: '\\u2A8E',\n\tgsiml: '\\u2A90',\n\tGt: '\\u226B',\n\tGT: '\\u003E',\n\tgt: '\\u003E',\n\tgtcc: '\\u2AA7',\n\tgtcir: '\\u2A7A',\n\tgtdot: '\\u22D7',\n\tgtlPar: '\\u2995',\n\tgtquest: '\\u2A7C',\n\tgtrapprox: '\\u2A86',\n\tgtrarr: '\\u2978',\n\tgtrdot: '\\u22D7',\n\tgtreqless: '\\u22DB',\n\tgtreqqless: '\\u2A8C',\n\tgtrless: '\\u2277',\n\tgtrsim: '\\u2273',\n\tgvertneqq: '\\u2269\\uFE00',\n\tgvnE: '\\u2269\\uFE00',\n\tHacek: '\\u02C7',\n\thairsp: '\\u200A',\n\thalf: '\\u00BD',\n\thamilt: '\\u210B',\n\tHARDcy: '\\u042A',\n\thardcy: '\\u044A',\n\thArr: '\\u21D4',\n\tharr: '\\u2194',\n\tharrcir: '\\u2948',\n\tharrw: '\\u21AD',\n\tHat: '\\u005E',\n\thbar: '\\u210F',\n\tHcirc: '\\u0124',\n\thcirc: '\\u0125',\n\thearts: '\\u2665',\n\theartsuit: '\\u2665',\n\thellip: '\\u2026',\n\thercon: '\\u22B9',\n\tHfr: '\\u210C',\n\thfr: '\\uD835\\uDD25',\n\tHilbertSpace: '\\u210B',\n\thksearow: '\\u2925',\n\thkswarow: '\\u2926',\n\thoarr: '\\u21FF',\n\thomtht: '\\u223B',\n\thookleftarrow: '\\u21A9',\n\thookrightarrow: '\\u21AA',\n\tHopf: '\\u210D',\n\thopf: '\\uD835\\uDD59',\n\thorbar: '\\u2015',\n\tHorizontalLine: '\\u2500',\n\tHscr: '\\u210B',\n\thscr: '\\uD835\\uDCBD',\n\thslash: '\\u210F',\n\tHstrok: '\\u0126',\n\thstrok: '\\u0127',\n\tHumpDownHump: '\\u224E',\n\tHumpEqual: '\\u224F',\n\thybull: '\\u2043',\n\thyphen: '\\u2010',\n\tIacute: '\\u00CD',\n\tiacute: '\\u00ED',\n\tic: '\\u2063',\n\tIcirc: '\\u00CE',\n\ticirc: '\\u00EE',\n\tIcy: '\\u0418',\n\ticy: '\\u0438',\n\tIdot: '\\u0130',\n\tIEcy: '\\u0415',\n\tiecy: '\\u0435',\n\tiexcl: '\\u00A1',\n\tiff: '\\u21D4',\n\tIfr: '\\u2111',\n\tifr: '\\uD835\\uDD26',\n\tIgrave: '\\u00CC',\n\tigrave: '\\u00EC',\n\tii: '\\u2148',\n\tiiiint: '\\u2A0C',\n\tiiint: '\\u222D',\n\tiinfin: '\\u29DC',\n\tiiota: '\\u2129',\n\tIJlig: '\\u0132',\n\tijlig: '\\u0133',\n\tIm: '\\u2111',\n\tImacr: '\\u012A',\n\timacr: '\\u012B',\n\timage: '\\u2111',\n\tImaginaryI: '\\u2148',\n\timagline: '\\u2110',\n\timagpart: '\\u2111',\n\timath: '\\u0131',\n\timof: '\\u22B7',\n\timped: '\\u01B5',\n\tImplies: '\\u21D2',\n\tin: '\\u2208',\n\tincare: '\\u2105',\n\tinfin: '\\u221E',\n\tinfintie: '\\u29DD',\n\tinodot: '\\u0131',\n\tInt: '\\u222C',\n\tint: '\\u222B',\n\tintcal: '\\u22BA',\n\tintegers: '\\u2124',\n\tIntegral: '\\u222B',\n\tintercal: '\\u22BA',\n\tIntersection: '\\u22C2',\n\tintlarhk: '\\u2A17',\n\tintprod: '\\u2A3C',\n\tInvisibleComma: '\\u2063',\n\tInvisibleTimes: '\\u2062',\n\tIOcy: '\\u0401',\n\tiocy: '\\u0451',\n\tIogon: '\\u012E',\n\tiogon: '\\u012F',\n\tIopf: '\\uD835\\uDD40',\n\tiopf: '\\uD835\\uDD5A',\n\tIota: '\\u0399',\n\tiota: '\\u03B9',\n\tiprod: '\\u2A3C',\n\tiquest: '\\u00BF',\n\tIscr: '\\u2110',\n\tiscr: '\\uD835\\uDCBE',\n\tisin: '\\u2208',\n\tisindot: '\\u22F5',\n\tisinE: '\\u22F9',\n\tisins: '\\u22F4',\n\tisinsv: '\\u22F3',\n\tisinv: '\\u2208',\n\tit: '\\u2062',\n\tItilde: '\\u0128',\n\titilde: '\\u0129',\n\tIukcy: '\\u0406',\n\tiukcy: '\\u0456',\n\tIuml: '\\u00CF',\n\tiuml: '\\u00EF',\n\tJcirc: '\\u0134',\n\tjcirc: '\\u0135',\n\tJcy: '\\u0419',\n\tjcy: '\\u0439',\n\tJfr: '\\uD835\\uDD0D',\n\tjfr: '\\uD835\\uDD27',\n\tjmath: '\\u0237',\n\tJopf: '\\uD835\\uDD41',\n\tjopf: '\\uD835\\uDD5B',\n\tJscr: '\\uD835\\uDCA5',\n\tjscr: '\\uD835\\uDCBF',\n\tJsercy: '\\u0408',\n\tjsercy: '\\u0458',\n\tJukcy: '\\u0404',\n\tjukcy: '\\u0454',\n\tKappa: '\\u039A',\n\tkappa: '\\u03BA',\n\tkappav: '\\u03F0',\n\tKcedil: '\\u0136',\n\tkcedil: '\\u0137',\n\tKcy: '\\u041A',\n\tkcy: '\\u043A',\n\tKfr: '\\uD835\\uDD0E',\n\tkfr: '\\uD835\\uDD28',\n\tkgreen: '\\u0138',\n\tKHcy: '\\u0425',\n\tkhcy: '\\u0445',\n\tKJcy: '\\u040C',\n\tkjcy: '\\u045C',\n\tKopf: '\\uD835\\uDD42',\n\tkopf: '\\uD835\\uDD5C',\n\tKscr: '\\uD835\\uDCA6',\n\tkscr: '\\uD835\\uDCC0',\n\tlAarr: '\\u21DA',\n\tLacute: '\\u0139',\n\tlacute: '\\u013A',\n\tlaemptyv: '\\u29B4',\n\tlagran: '\\u2112',\n\tLambda: '\\u039B',\n\tlambda: '\\u03BB',\n\tLang: '\\u27EA',\n\tlang: '\\u27E8',\n\tlangd: '\\u2991',\n\tlangle: '\\u27E8',\n\tlap: '\\u2A85',\n\tLaplacetrf: '\\u2112',\n\tlaquo: '\\u00AB',\n\tLarr: '\\u219E',\n\tlArr: '\\u21D0',\n\tlarr: '\\u2190',\n\tlarrb: '\\u21E4',\n\tlarrbfs: '\\u291F',\n\tlarrfs: '\\u291D',\n\tlarrhk: '\\u21A9',\n\tlarrlp: '\\u21AB',\n\tlarrpl: '\\u2939',\n\tlarrsim: '\\u2973',\n\tlarrtl: '\\u21A2',\n\tlat: '\\u2AAB',\n\tlAtail: '\\u291B',\n\tlatail: '\\u2919',\n\tlate: '\\u2AAD',\n\tlates: '\\u2AAD\\uFE00',\n\tlBarr: '\\u290E',\n\tlbarr: '\\u290C',\n\tlbbrk: '\\u2772',\n\tlbrace: '\\u007B',\n\tlbrack: '\\u005B',\n\tlbrke: '\\u298B',\n\tlbrksld: '\\u298F',\n\tlbrkslu: '\\u298D',\n\tLcaron: '\\u013D',\n\tlcaron: '\\u013E',\n\tLcedil: '\\u013B',\n\tlcedil: '\\u013C',\n\tlceil: '\\u2308',\n\tlcub: '\\u007B',\n\tLcy: '\\u041B',\n\tlcy: '\\u043B',\n\tldca: '\\u2936',\n\tldquo: '\\u201C',\n\tldquor: '\\u201E',\n\tldrdhar: '\\u2967',\n\tldrushar: '\\u294B',\n\tldsh: '\\u21B2',\n\tlE: '\\u2266',\n\tle: '\\u2264',\n\tLeftAngleBracket: '\\u27E8',\n\tLeftArrow: '\\u2190',\n\tLeftarrow: '\\u21D0',\n\tleftarrow: '\\u2190',\n\tLeftArrowBar: '\\u21E4',\n\tLeftArrowRightArrow: '\\u21C6',\n\tleftarrowtail: '\\u21A2',\n\tLeftCeiling: '\\u2308',\n\tLeftDoubleBracket: '\\u27E6',\n\tLeftDownTeeVector: '\\u2961',\n\tLeftDownVector: '\\u21C3',\n\tLeftDownVectorBar: '\\u2959',\n\tLeftFloor: '\\u230A',\n\tleftharpoondown: '\\u21BD',\n\tleftharpoonup: '\\u21BC',\n\tleftleftarrows: '\\u21C7',\n\tLeftRightArrow: '\\u2194',\n\tLeftrightarrow: '\\u21D4',\n\tleftrightarrow: '\\u2194',\n\tleftrightarrows: '\\u21C6',\n\tleftrightharpoons: '\\u21CB',\n\tleftrightsquigarrow: '\\u21AD',\n\tLeftRightVector: '\\u294E',\n\tLeftTee: '\\u22A3',\n\tLeftTeeArrow: '\\u21A4',\n\tLeftTeeVector: '\\u295A',\n\tleftthreetimes: '\\u22CB',\n\tLeftTriangle: '\\u22B2',\n\tLeftTriangleBar: '\\u29CF',\n\tLeftTriangleEqual: '\\u22B4',\n\tLeftUpDownVector: '\\u2951',\n\tLeftUpTeeVector: '\\u2960',\n\tLeftUpVector: '\\u21BF',\n\tLeftUpVectorBar: '\\u2958',\n\tLeftVector: '\\u21BC',\n\tLeftVectorBar: '\\u2952',\n\tlEg: '\\u2A8B',\n\tleg: '\\u22DA',\n\tleq: '\\u2264',\n\tleqq: '\\u2266',\n\tleqslant: '\\u2A7D',\n\tles: '\\u2A7D',\n\tlescc: '\\u2AA8',\n\tlesdot: '\\u2A7F',\n\tlesdoto: '\\u2A81',\n\tlesdotor: '\\u2A83',\n\tlesg: '\\u22DA\\uFE00',\n\tlesges: '\\u2A93',\n\tlessapprox: '\\u2A85',\n\tlessdot: '\\u22D6',\n\tlesseqgtr: '\\u22DA',\n\tlesseqqgtr: '\\u2A8B',\n\tLessEqualGreater: '\\u22DA',\n\tLessFullEqual: '\\u2266',\n\tLessGreater: '\\u2276',\n\tlessgtr: '\\u2276',\n\tLessLess: '\\u2AA1',\n\tlesssim: '\\u2272',\n\tLessSlantEqual: '\\u2A7D',\n\tLessTilde: '\\u2272',\n\tlfisht: '\\u297C',\n\tlfloor: '\\u230A',\n\tLfr: '\\uD835\\uDD0F',\n\tlfr: '\\uD835\\uDD29',\n\tlg: '\\u2276',\n\tlgE: '\\u2A91',\n\tlHar: '\\u2962',\n\tlhard: '\\u21BD',\n\tlharu: '\\u21BC',\n\tlharul: '\\u296A',\n\tlhblk: '\\u2584',\n\tLJcy: '\\u0409',\n\tljcy: '\\u0459',\n\tLl: '\\u22D8',\n\tll: '\\u226A',\n\tllarr: '\\u21C7',\n\tllcorner: '\\u231E',\n\tLleftarrow: '\\u21DA',\n\tllhard: '\\u296B',\n\tlltri: '\\u25FA',\n\tLmidot: '\\u013F',\n\tlmidot: '\\u0140',\n\tlmoust: '\\u23B0',\n\tlmoustache: '\\u23B0',\n\tlnap: '\\u2A89',\n\tlnapprox: '\\u2A89',\n\tlnE: '\\u2268',\n\tlne: '\\u2A87',\n\tlneq: '\\u2A87',\n\tlneqq: '\\u2268',\n\tlnsim: '\\u22E6',\n\tloang: '\\u27EC',\n\tloarr: '\\u21FD',\n\tlobrk: '\\u27E6',\n\tLongLeftArrow: '\\u27F5',\n\tLongleftarrow: '\\u27F8',\n\tlongleftarrow: '\\u27F5',\n\tLongLeftRightArrow: '\\u27F7',\n\tLongleftrightarrow: '\\u27FA',\n\tlongleftrightarrow: '\\u27F7',\n\tlongmapsto: '\\u27FC',\n\tLongRightArrow: '\\u27F6',\n\tLongrightarrow: '\\u27F9',\n\tlongrightarrow: '\\u27F6',\n\tlooparrowleft: '\\u21AB',\n\tlooparrowright: '\\u21AC',\n\tlopar: '\\u2985',\n\tLopf: '\\uD835\\uDD43',\n\tlopf: '\\uD835\\uDD5D',\n\tloplus: '\\u2A2D',\n\tlotimes: '\\u2A34',\n\tlowast: '\\u2217',\n\tlowbar: '\\u005F',\n\tLowerLeftArrow: '\\u2199',\n\tLowerRightArrow: '\\u2198',\n\tloz: '\\u25CA',\n\tlozenge: '\\u25CA',\n\tlozf: '\\u29EB',\n\tlpar: '\\u0028',\n\tlparlt: '\\u2993',\n\tlrarr: '\\u21C6',\n\tlrcorner: '\\u231F',\n\tlrhar: '\\u21CB',\n\tlrhard: '\\u296D',\n\tlrm: '\\u200E',\n\tlrtri: '\\u22BF',\n\tlsaquo: '\\u2039',\n\tLscr: '\\u2112',\n\tlscr: '\\uD835\\uDCC1',\n\tLsh: '\\u21B0',\n\tlsh: '\\u21B0',\n\tlsim: '\\u2272',\n\tlsime: '\\u2A8D',\n\tlsimg: '\\u2A8F',\n\tlsqb: '\\u005B',\n\tlsquo: '\\u2018',\n\tlsquor: '\\u201A',\n\tLstrok: '\\u0141',\n\tlstrok: '\\u0142',\n\tLt: '\\u226A',\n\tLT: '\\u003C',\n\tlt: '\\u003C',\n\tltcc: '\\u2AA6',\n\tltcir: '\\u2A79',\n\tltdot: '\\u22D6',\n\tlthree: '\\u22CB',\n\tltimes: '\\u22C9',\n\tltlarr: '\\u2976',\n\tltquest: '\\u2A7B',\n\tltri: '\\u25C3',\n\tltrie: '\\u22B4',\n\tltrif: '\\u25C2',\n\tltrPar: '\\u2996',\n\tlurdshar: '\\u294A',\n\tluruhar: '\\u2966',\n\tlvertneqq: '\\u2268\\uFE00',\n\tlvnE: '\\u2268\\uFE00',\n\tmacr: '\\u00AF',\n\tmale: '\\u2642',\n\tmalt: '\\u2720',\n\tmaltese: '\\u2720',\n\tMap: '\\u2905',\n\tmap: '\\u21A6',\n\tmapsto: '\\u21A6',\n\tmapstodown: '\\u21A7',\n\tmapstoleft: '\\u21A4',\n\tmapstoup: '\\u21A5',\n\tmarker: '\\u25AE',\n\tmcomma: '\\u2A29',\n\tMcy: '\\u041C',\n\tmcy: '\\u043C',\n\tmdash: '\\u2014',\n\tmDDot: '\\u223A',\n\tmeasuredangle: '\\u2221',\n\tMediumSpace: '\\u205F',\n\tMellintrf: '\\u2133',\n\tMfr: '\\uD835\\uDD10',\n\tmfr: '\\uD835\\uDD2A',\n\tmho: '\\u2127',\n\tmicro: '\\u00B5',\n\tmid: '\\u2223',\n\tmidast: '\\u002A',\n\tmidcir: '\\u2AF0',\n\tmiddot: '\\u00B7',\n\tminus: '\\u2212',\n\tminusb: '\\u229F',\n\tminusd: '\\u2238',\n\tminusdu: '\\u2A2A',\n\tMinusPlus: '\\u2213',\n\tmlcp: '\\u2ADB',\n\tmldr: '\\u2026',\n\tmnplus: '\\u2213',\n\tmodels: '\\u22A7',\n\tMopf: '\\uD835\\uDD44',\n\tmopf: '\\uD835\\uDD5E',\n\tmp: '\\u2213',\n\tMscr: '\\u2133',\n\tmscr: '\\uD835\\uDCC2',\n\tmstpos: '\\u223E',\n\tMu: '\\u039C',\n\tmu: '\\u03BC',\n\tmultimap: '\\u22B8',\n\tmumap: '\\u22B8',\n\tnabla: '\\u2207',\n\tNacute: '\\u0143',\n\tnacute: '\\u0144',\n\tnang: '\\u2220\\u20D2',\n\tnap: '\\u2249',\n\tnapE: '\\u2A70\\u0338',\n\tnapid: '\\u224B\\u0338',\n\tnapos: '\\u0149',\n\tnapprox: '\\u2249',\n\tnatur: '\\u266E',\n\tnatural: '\\u266E',\n\tnaturals: '\\u2115',\n\tnbsp: '\\u00A0',\n\tnbump: '\\u224E\\u0338',\n\tnbumpe: '\\u224F\\u0338',\n\tncap: '\\u2A43',\n\tNcaron: '\\u0147',\n\tncaron: '\\u0148',\n\tNcedil: '\\u0145',\n\tncedil: '\\u0146',\n\tncong: '\\u2247',\n\tncongdot: '\\u2A6D\\u0338',\n\tncup: '\\u2A42',\n\tNcy: '\\u041D',\n\tncy: '\\u043D',\n\tndash: '\\u2013',\n\tne: '\\u2260',\n\tnearhk: '\\u2924',\n\tneArr: '\\u21D7',\n\tnearr: '\\u2197',\n\tnearrow: '\\u2197',\n\tnedot: '\\u2250\\u0338',\n\tNegativeMediumSpace: '\\u200B',\n\tNegativeThickSpace: '\\u200B',\n\tNegativeThinSpace: '\\u200B',\n\tNegativeVeryThinSpace: '\\u200B',\n\tnequiv: '\\u2262',\n\tnesear: '\\u2928',\n\tnesim: '\\u2242\\u0338',\n\tNestedGreaterGreater: '\\u226B',\n\tNestedLessLess: '\\u226A',\n\tNewLine: '\\u000A',\n\tnexist: '\\u2204',\n\tnexists: '\\u2204',\n\tNfr: '\\uD835\\uDD11',\n\tnfr: '\\uD835\\uDD2B',\n\tngE: '\\u2267\\u0338',\n\tnge: '\\u2271',\n\tngeq: '\\u2271',\n\tngeqq: '\\u2267\\u0338',\n\tngeqslant: '\\u2A7E\\u0338',\n\tnges: '\\u2A7E\\u0338',\n\tnGg: '\\u22D9\\u0338',\n\tngsim: '\\u2275',\n\tnGt: '\\u226B\\u20D2',\n\tngt: '\\u226F',\n\tngtr: '\\u226F',\n\tnGtv: '\\u226B\\u0338',\n\tnhArr: '\\u21CE',\n\tnharr: '\\u21AE',\n\tnhpar: '\\u2AF2',\n\tni: '\\u220B',\n\tnis: '\\u22FC',\n\tnisd: '\\u22FA',\n\tniv: '\\u220B',\n\tNJcy: '\\u040A',\n\tnjcy: '\\u045A',\n\tnlArr: '\\u21CD',\n\tnlarr: '\\u219A',\n\tnldr: '\\u2025',\n\tnlE: '\\u2266\\u0338',\n\tnle: '\\u2270',\n\tnLeftarrow: '\\u21CD',\n\tnleftarrow: '\\u219A',\n\tnLeftrightarrow: '\\u21CE',\n\tnleftrightarrow: '\\u21AE',\n\tnleq: '\\u2270',\n\tnleqq: '\\u2266\\u0338',\n\tnleqslant: '\\u2A7D\\u0338',\n\tnles: '\\u2A7D\\u0338',\n\tnless: '\\u226E',\n\tnLl: '\\u22D8\\u0338',\n\tnlsim: '\\u2274',\n\tnLt: '\\u226A\\u20D2',\n\tnlt: '\\u226E',\n\tnltri: '\\u22EA',\n\tnltrie: '\\u22EC',\n\tnLtv: '\\u226A\\u0338',\n\tnmid: '\\u2224',\n\tNoBreak: '\\u2060',\n\tNonBreakingSpace: '\\u00A0',\n\tNopf: '\\u2115',\n\tnopf: '\\uD835\\uDD5F',\n\tNot: '\\u2AEC',\n\tnot: '\\u00AC',\n\tNotCongruent: '\\u2262',\n\tNotCupCap: '\\u226D',\n\tNotDoubleVerticalBar: '\\u2226',\n\tNotElement: '\\u2209',\n\tNotEqual: '\\u2260',\n\tNotEqualTilde: '\\u2242\\u0338',\n\tNotExists: '\\u2204',\n\tNotGreater: '\\u226F',\n\tNotGreaterEqual: '\\u2271',\n\tNotGreaterFullEqual: '\\u2267\\u0338',\n\tNotGreaterGreater: '\\u226B\\u0338',\n\tNotGreaterLess: '\\u2279',\n\tNotGreaterSlantEqual: '\\u2A7E\\u0338',\n\tNotGreaterTilde: '\\u2275',\n\tNotHumpDownHump: '\\u224E\\u0338',\n\tNotHumpEqual: '\\u224F\\u0338',\n\tnotin: '\\u2209',\n\tnotindot: '\\u22F5\\u0338',\n\tnotinE: '\\u22F9\\u0338',\n\tnotinva: '\\u2209',\n\tnotinvb: '\\u22F7',\n\tnotinvc: '\\u22F6',\n\tNotLeftTriangle: '\\u22EA',\n\tNotLeftTriangleBar: '\\u29CF\\u0338',\n\tNotLeftTriangleEqual: '\\u22EC',\n\tNotLess: '\\u226E',\n\tNotLessEqual: '\\u2270',\n\tNotLessGreater: '\\u2278',\n\tNotLessLess: '\\u226A\\u0338',\n\tNotLessSlantEqual: '\\u2A7D\\u0338',\n\tNotLessTilde: '\\u2274',\n\tNotNestedGreaterGreater: '\\u2AA2\\u0338',\n\tNotNestedLessLess: '\\u2AA1\\u0338',\n\tnotni: '\\u220C',\n\tnotniva: '\\u220C',\n\tnotnivb: '\\u22FE',\n\tnotnivc: '\\u22FD',\n\tNotPrecedes: '\\u2280',\n\tNotPrecedesEqual: '\\u2AAF\\u0338',\n\tNotPrecedesSlantEqual: '\\u22E0',\n\tNotReverseElement: '\\u220C',\n\tNotRightTriangle: '\\u22EB',\n\tNotRightTriangleBar: '\\u29D0\\u0338',\n\tNotRightTriangleEqual: '\\u22ED',\n\tNotSquareSubset: '\\u228F\\u0338',\n\tNotSquareSubsetEqual: '\\u22E2',\n\tNotSquareSuperset: '\\u2290\\u0338',\n\tNotSquareSupersetEqual: '\\u22E3',\n\tNotSubset: '\\u2282\\u20D2',\n\tNotSubsetEqual: '\\u2288',\n\tNotSucceeds: '\\u2281',\n\tNotSucceedsEqual: '\\u2AB0\\u0338',\n\tNotSucceedsSlantEqual: '\\u22E1',\n\tNotSucceedsTilde: '\\u227F\\u0338',\n\tNotSuperset: '\\u2283\\u20D2',\n\tNotSupersetEqual: '\\u2289',\n\tNotTilde: '\\u2241',\n\tNotTildeEqual: '\\u2244',\n\tNotTildeFullEqual: '\\u2247',\n\tNotTildeTilde: '\\u2249',\n\tNotVerticalBar: '\\u2224',\n\tnpar: '\\u2226',\n\tnparallel: '\\u2226',\n\tnparsl: '\\u2AFD\\u20E5',\n\tnpart: '\\u2202\\u0338',\n\tnpolint: '\\u2A14',\n\tnpr: '\\u2280',\n\tnprcue: '\\u22E0',\n\tnpre: '\\u2AAF\\u0338',\n\tnprec: '\\u2280',\n\tnpreceq: '\\u2AAF\\u0338',\n\tnrArr: '\\u21CF',\n\tnrarr: '\\u219B',\n\tnrarrc: '\\u2933\\u0338',\n\tnrarrw: '\\u219D\\u0338',\n\tnRightarrow: '\\u21CF',\n\tnrightarrow: '\\u219B',\n\tnrtri: '\\u22EB',\n\tnrtrie: '\\u22ED',\n\tnsc: '\\u2281',\n\tnsccue: '\\u22E1',\n\tnsce: '\\u2AB0\\u0338',\n\tNscr: '\\uD835\\uDCA9',\n\tnscr: '\\uD835\\uDCC3',\n\tnshortmid: '\\u2224',\n\tnshortparallel: '\\u2226',\n\tnsim: '\\u2241',\n\tnsime: '\\u2244',\n\tnsimeq: '\\u2244',\n\tnsmid: '\\u2224',\n\tnspar: '\\u2226',\n\tnsqsube: '\\u22E2',\n\tnsqsupe: '\\u22E3',\n\tnsub: '\\u2284',\n\tnsubE: '\\u2AC5\\u0338',\n\tnsube: '\\u2288',\n\tnsubset: '\\u2282\\u20D2',\n\tnsubseteq: '\\u2288',\n\tnsubseteqq: '\\u2AC5\\u0338',\n\tnsucc: '\\u2281',\n\tnsucceq: '\\u2AB0\\u0338',\n\tnsup: '\\u2285',\n\tnsupE: '\\u2AC6\\u0338',\n\tnsupe: '\\u2289',\n\tnsupset: '\\u2283\\u20D2',\n\tnsupseteq: '\\u2289',\n\tnsupseteqq: '\\u2AC6\\u0338',\n\tntgl: '\\u2279',\n\tNtilde: '\\u00D1',\n\tntilde: '\\u00F1',\n\tntlg: '\\u2278',\n\tntriangleleft: '\\u22EA',\n\tntrianglelefteq: '\\u22EC',\n\tntriangleright: '\\u22EB',\n\tntrianglerighteq: '\\u22ED',\n\tNu: '\\u039D',\n\tnu: '\\u03BD',\n\tnum: '\\u0023',\n\tnumero: '\\u2116',\n\tnumsp: '\\u2007',\n\tnvap: '\\u224D\\u20D2',\n\tnVDash: '\\u22AF',\n\tnVdash: '\\u22AE',\n\tnvDash: '\\u22AD',\n\tnvdash: '\\u22AC',\n\tnvge: '\\u2265\\u20D2',\n\tnvgt: '\\u003E\\u20D2',\n\tnvHarr: '\\u2904',\n\tnvinfin: '\\u29DE',\n\tnvlArr: '\\u2902',\n\tnvle: '\\u2264\\u20D2',\n\tnvlt: '\\u003C\\u20D2',\n\tnvltrie: '\\u22B4\\u20D2',\n\tnvrArr: '\\u2903',\n\tnvrtrie: '\\u22B5\\u20D2',\n\tnvsim: '\\u223C\\u20D2',\n\tnwarhk: '\\u2923',\n\tnwArr: '\\u21D6',\n\tnwarr: '\\u2196',\n\tnwarrow: '\\u2196',\n\tnwnear: '\\u2927',\n\tOacute: '\\u00D3',\n\toacute: '\\u00F3',\n\toast: '\\u229B',\n\tocir: '\\u229A',\n\tOcirc: '\\u00D4',\n\tocirc: '\\u00F4',\n\tOcy: '\\u041E',\n\tocy: '\\u043E',\n\todash: '\\u229D',\n\tOdblac: '\\u0150',\n\todblac: '\\u0151',\n\todiv: '\\u2A38',\n\todot: '\\u2299',\n\todsold: '\\u29BC',\n\tOElig: '\\u0152',\n\toelig: '\\u0153',\n\tofcir: '\\u29BF',\n\tOfr: '\\uD835\\uDD12',\n\tofr: '\\uD835\\uDD2C',\n\togon: '\\u02DB',\n\tOgrave: '\\u00D2',\n\tograve: '\\u00F2',\n\togt: '\\u29C1',\n\tohbar: '\\u29B5',\n\tohm: '\\u03A9',\n\toint: '\\u222E',\n\tolarr: '\\u21BA',\n\tolcir: '\\u29BE',\n\tolcross: '\\u29BB',\n\toline: '\\u203E',\n\tolt: '\\u29C0',\n\tOmacr: '\\u014C',\n\tomacr: '\\u014D',\n\tOmega: '\\u03A9',\n\tomega: '\\u03C9',\n\tOmicron: '\\u039F',\n\tomicron: '\\u03BF',\n\tomid: '\\u29B6',\n\tominus: '\\u2296',\n\tOopf: '\\uD835\\uDD46',\n\toopf: '\\uD835\\uDD60',\n\topar: '\\u29B7',\n\tOpenCurlyDoubleQuote: '\\u201C',\n\tOpenCurlyQuote: '\\u2018',\n\toperp: '\\u29B9',\n\toplus: '\\u2295',\n\tOr: '\\u2A54',\n\tor: '\\u2228',\n\torarr: '\\u21BB',\n\tord: '\\u2A5D',\n\torder: '\\u2134',\n\torderof: '\\u2134',\n\tordf: '\\u00AA',\n\tordm: '\\u00BA',\n\torigof: '\\u22B6',\n\toror: '\\u2A56',\n\torslope: '\\u2A57',\n\torv: '\\u2A5B',\n\toS: '\\u24C8',\n\tOscr: '\\uD835\\uDCAA',\n\toscr: '\\u2134',\n\tOslash: '\\u00D8',\n\toslash: '\\u00F8',\n\tosol: '\\u2298',\n\tOtilde: '\\u00D5',\n\totilde: '\\u00F5',\n\tOtimes: '\\u2A37',\n\totimes: '\\u2297',\n\totimesas: '\\u2A36',\n\tOuml: '\\u00D6',\n\touml: '\\u00F6',\n\tovbar: '\\u233D',\n\tOverBar: '\\u203E',\n\tOverBrace: '\\u23DE',\n\tOverBracket: '\\u23B4',\n\tOverParenthesis: '\\u23DC',\n\tpar: '\\u2225',\n\tpara: '\\u00B6',\n\tparallel: '\\u2225',\n\tparsim: '\\u2AF3',\n\tparsl: '\\u2AFD',\n\tpart: '\\u2202',\n\tPartialD: '\\u2202',\n\tPcy: '\\u041F',\n\tpcy: '\\u043F',\n\tpercnt: '\\u0025',\n\tperiod: '\\u002E',\n\tpermil: '\\u2030',\n\tperp: '\\u22A5',\n\tpertenk: '\\u2031',\n\tPfr: '\\uD835\\uDD13',\n\tpfr: '\\uD835\\uDD2D',\n\tPhi: '\\u03A6',\n\tphi: '\\u03C6',\n\tphiv: '\\u03D5',\n\tphmmat: '\\u2133',\n\tphone: '\\u260E',\n\tPi: '\\u03A0',\n\tpi: '\\u03C0',\n\tpitchfork: '\\u22D4',\n\tpiv: '\\u03D6',\n\tplanck: '\\u210F',\n\tplanckh: '\\u210E',\n\tplankv: '\\u210F',\n\tplus: '\\u002B',\n\tplusacir: '\\u2A23',\n\tplusb: '\\u229E',\n\tpluscir: '\\u2A22',\n\tplusdo: '\\u2214',\n\tplusdu: '\\u2A25',\n\tpluse: '\\u2A72',\n\tPlusMinus: '\\u00B1',\n\tplusmn: '\\u00B1',\n\tplussim: '\\u2A26',\n\tplustwo: '\\u2A27',\n\tpm: '\\u00B1',\n\tPoincareplane: '\\u210C',\n\tpointint: '\\u2A15',\n\tPopf: '\\u2119',\n\tpopf: '\\uD835\\uDD61',\n\tpound: '\\u00A3',\n\tPr: '\\u2ABB',\n\tpr: '\\u227A',\n\tprap: '\\u2AB7',\n\tprcue: '\\u227C',\n\tprE: '\\u2AB3',\n\tpre: '\\u2AAF',\n\tprec: '\\u227A',\n\tprecapprox: '\\u2AB7',\n\tpreccurlyeq: '\\u227C',\n\tPrecedes: '\\u227A',\n\tPrecedesEqual: '\\u2AAF',\n\tPrecedesSlantEqual: '\\u227C',\n\tPrecedesTilde: '\\u227E',\n\tpreceq: '\\u2AAF',\n\tprecnapprox: '\\u2AB9',\n\tprecneqq: '\\u2AB5',\n\tprecnsim: '\\u22E8',\n\tprecsim: '\\u227E',\n\tPrime: '\\u2033',\n\tprime: '\\u2032',\n\tprimes: '\\u2119',\n\tprnap: '\\u2AB9',\n\tprnE: '\\u2AB5',\n\tprnsim: '\\u22E8',\n\tprod: '\\u220F',\n\tProduct: '\\u220F',\n\tprofalar: '\\u232E',\n\tprofline: '\\u2312',\n\tprofsurf: '\\u2313',\n\tprop: '\\u221D',\n\tProportion: '\\u2237',\n\tProportional: '\\u221D',\n\tpropto: '\\u221D',\n\tprsim: '\\u227E',\n\tprurel: '\\u22B0',\n\tPscr: '\\uD835\\uDCAB',\n\tpscr: '\\uD835\\uDCC5',\n\tPsi: '\\u03A8',\n\tpsi: '\\u03C8',\n\tpuncsp: '\\u2008',\n\tQfr: '\\uD835\\uDD14',\n\tqfr: '\\uD835\\uDD2E',\n\tqint: '\\u2A0C',\n\tQopf: '\\u211A',\n\tqopf: '\\uD835\\uDD62',\n\tqprime: '\\u2057',\n\tQscr: '\\uD835\\uDCAC',\n\tqscr: '\\uD835\\uDCC6',\n\tquaternions: '\\u210D',\n\tquatint: '\\u2A16',\n\tquest: '\\u003F',\n\tquesteq: '\\u225F',\n\tQUOT: '\\u0022',\n\tquot: '\\u0022',\n\trAarr: '\\u21DB',\n\trace: '\\u223D\\u0331',\n\tRacute: '\\u0154',\n\tracute: '\\u0155',\n\tradic: '\\u221A',\n\traemptyv: '\\u29B3',\n\tRang: '\\u27EB',\n\trang: '\\u27E9',\n\trangd: '\\u2992',\n\trange: '\\u29A5',\n\trangle: '\\u27E9',\n\traquo: '\\u00BB',\n\tRarr: '\\u21A0',\n\trArr: '\\u21D2',\n\trarr: '\\u2192',\n\trarrap: '\\u2975',\n\trarrb: '\\u21E5',\n\trarrbfs: '\\u2920',\n\trarrc: '\\u2933',\n\trarrfs: '\\u291E',\n\trarrhk: '\\u21AA',\n\trarrlp: '\\u21AC',\n\trarrpl: '\\u2945',\n\trarrsim: '\\u2974',\n\tRarrtl: '\\u2916',\n\trarrtl: '\\u21A3',\n\trarrw: '\\u219D',\n\trAtail: '\\u291C',\n\tratail: '\\u291A',\n\tratio: '\\u2236',\n\trationals: '\\u211A',\n\tRBarr: '\\u2910',\n\trBarr: '\\u290F',\n\trbarr: '\\u290D',\n\trbbrk: '\\u2773',\n\trbrace: '\\u007D',\n\trbrack: '\\u005D',\n\trbrke: '\\u298C',\n\trbrksld: '\\u298E',\n\trbrkslu: '\\u2990',\n\tRcaron: '\\u0158',\n\trcaron: '\\u0159',\n\tRcedil: '\\u0156',\n\trcedil: '\\u0157',\n\trceil: '\\u2309',\n\trcub: '\\u007D',\n\tRcy: '\\u0420',\n\trcy: '\\u0440',\n\trdca: '\\u2937',\n\trdldhar: '\\u2969',\n\trdquo: '\\u201D',\n\trdquor: '\\u201D',\n\trdsh: '\\u21B3',\n\tRe: '\\u211C',\n\treal: '\\u211C',\n\trealine: '\\u211B',\n\trealpart: '\\u211C',\n\treals: '\\u211D',\n\trect: '\\u25AD',\n\tREG: '\\u00AE',\n\treg: '\\u00AE',\n\tReverseElement: '\\u220B',\n\tReverseEquilibrium: '\\u21CB',\n\tReverseUpEquilibrium: '\\u296F',\n\trfisht: '\\u297D',\n\trfloor: '\\u230B',\n\tRfr: '\\u211C',\n\trfr: '\\uD835\\uDD2F',\n\trHar: '\\u2964',\n\trhard: '\\u21C1',\n\trharu: '\\u21C0',\n\trharul: '\\u296C',\n\tRho: '\\u03A1',\n\trho: '\\u03C1',\n\trhov: '\\u03F1',\n\tRightAngleBracket: '\\u27E9',\n\tRightArrow: '\\u2192',\n\tRightarrow: '\\u21D2',\n\trightarrow: '\\u2192',\n\tRightArrowBar: '\\u21E5',\n\tRightArrowLeftArrow: '\\u21C4',\n\trightarrowtail: '\\u21A3',\n\tRightCeiling: '\\u2309',\n\tRightDoubleBracket: '\\u27E7',\n\tRightDownTeeVector: '\\u295D',\n\tRightDownVector: '\\u21C2',\n\tRightDownVectorBar: '\\u2955',\n\tRightFloor: '\\u230B',\n\trightharpoondown: '\\u21C1',\n\trightharpoonup: '\\u21C0',\n\trightleftarrows: '\\u21C4',\n\trightleftharpoons: '\\u21CC',\n\trightrightarrows: '\\u21C9',\n\trightsquigarrow: '\\u219D',\n\tRightTee: '\\u22A2',\n\tRightTeeArrow: '\\u21A6',\n\tRightTeeVector: '\\u295B',\n\trightthreetimes: '\\u22CC',\n\tRightTriangle: '\\u22B3',\n\tRightTriangleBar: '\\u29D0',\n\tRightTriangleEqual: '\\u22B5',\n\tRightUpDownVector: '\\u294F',\n\tRightUpTeeVector: '\\u295C',\n\tRightUpVector: '\\u21BE',\n\tRightUpVectorBar: '\\u2954',\n\tRightVector: '\\u21C0',\n\tRightVectorBar: '\\u2953',\n\tring: '\\u02DA',\n\trisingdotseq: '\\u2253',\n\trlarr: '\\u21C4',\n\trlhar: '\\u21CC',\n\trlm: '\\u200F',\n\trmoust: '\\u23B1',\n\trmoustache: '\\u23B1',\n\trnmid: '\\u2AEE',\n\troang: '\\u27ED',\n\troarr: '\\u21FE',\n\trobrk: '\\u27E7',\n\tropar: '\\u2986',\n\tRopf: '\\u211D',\n\tropf: '\\uD835\\uDD63',\n\troplus: '\\u2A2E',\n\trotimes: '\\u2A35',\n\tRoundImplies: '\\u2970',\n\trpar: '\\u0029',\n\trpargt: '\\u2994',\n\trppolint: '\\u2A12',\n\trrarr: '\\u21C9',\n\tRrightarrow: '\\u21DB',\n\trsaquo: '\\u203A',\n\tRscr: '\\u211B',\n\trscr: '\\uD835\\uDCC7',\n\tRsh: '\\u21B1',\n\trsh: '\\u21B1',\n\trsqb: '\\u005D',\n\trsquo: '\\u2019',\n\trsquor: '\\u2019',\n\trthree: '\\u22CC',\n\trtimes: '\\u22CA',\n\trtri: '\\u25B9',\n\trtrie: '\\u22B5',\n\trtrif: '\\u25B8',\n\trtriltri: '\\u29CE',\n\tRuleDelayed: '\\u29F4',\n\truluhar: '\\u2968',\n\trx: '\\u211E',\n\tSacute: '\\u015A',\n\tsacute: '\\u015B',\n\tsbquo: '\\u201A',\n\tSc: '\\u2ABC',\n\tsc: '\\u227B',\n\tscap: '\\u2AB8',\n\tScaron: '\\u0160',\n\tscaron: '\\u0161',\n\tsccue: '\\u227D',\n\tscE: '\\u2AB4',\n\tsce: '\\u2AB0',\n\tScedil: '\\u015E',\n\tscedil: '\\u015F',\n\tScirc: '\\u015C',\n\tscirc: '\\u015D',\n\tscnap: '\\u2ABA',\n\tscnE: '\\u2AB6',\n\tscnsim: '\\u22E9',\n\tscpolint: '\\u2A13',\n\tscsim: '\\u227F',\n\tScy: '\\u0421',\n\tscy: '\\u0441',\n\tsdot: '\\u22C5',\n\tsdotb: '\\u22A1',\n\tsdote: '\\u2A66',\n\tsearhk: '\\u2925',\n\tseArr: '\\u21D8',\n\tsearr: '\\u2198',\n\tsearrow: '\\u2198',\n\tsect: '\\u00A7',\n\tsemi: '\\u003B',\n\tseswar: '\\u2929',\n\tsetminus: '\\u2216',\n\tsetmn: '\\u2216',\n\tsext: '\\u2736',\n\tSfr: '\\uD835\\uDD16',\n\tsfr: '\\uD835\\uDD30',\n\tsfrown: '\\u2322',\n\tsharp: '\\u266F',\n\tSHCHcy: '\\u0429',\n\tshchcy: '\\u0449',\n\tSHcy: '\\u0428',\n\tshcy: '\\u0448',\n\tShortDownArrow: '\\u2193',\n\tShortLeftArrow: '\\u2190',\n\tshortmid: '\\u2223',\n\tshortparallel: '\\u2225',\n\tShortRightArrow: '\\u2192',\n\tShortUpArrow: '\\u2191',\n\tshy: '\\u00AD',\n\tSigma: '\\u03A3',\n\tsigma: '\\u03C3',\n\tsigmaf: '\\u03C2',\n\tsigmav: '\\u03C2',\n\tsim: '\\u223C',\n\tsimdot: '\\u2A6A',\n\tsime: '\\u2243',\n\tsimeq: '\\u2243',\n\tsimg: '\\u2A9E',\n\tsimgE: '\\u2AA0',\n\tsiml: '\\u2A9D',\n\tsimlE: '\\u2A9F',\n\tsimne: '\\u2246',\n\tsimplus: '\\u2A24',\n\tsimrarr: '\\u2972',\n\tslarr: '\\u2190',\n\tSmallCircle: '\\u2218',\n\tsmallsetminus: '\\u2216',\n\tsmashp: '\\u2A33',\n\tsmeparsl: '\\u29E4',\n\tsmid: '\\u2223',\n\tsmile: '\\u2323',\n\tsmt: '\\u2AAA',\n\tsmte: '\\u2AAC',\n\tsmtes: '\\u2AAC\\uFE00',\n\tSOFTcy: '\\u042C',\n\tsoftcy: '\\u044C',\n\tsol: '\\u002F',\n\tsolb: '\\u29C4',\n\tsolbar: '\\u233F',\n\tSopf: '\\uD835\\uDD4A',\n\tsopf: '\\uD835\\uDD64',\n\tspades: '\\u2660',\n\tspadesuit: '\\u2660',\n\tspar: '\\u2225',\n\tsqcap: '\\u2293',\n\tsqcaps: '\\u2293\\uFE00',\n\tsqcup: '\\u2294',\n\tsqcups: '\\u2294\\uFE00',\n\tSqrt: '\\u221A',\n\tsqsub: '\\u228F',\n\tsqsube: '\\u2291',\n\tsqsubset: '\\u228F',\n\tsqsubseteq: '\\u2291',\n\tsqsup: '\\u2290',\n\tsqsupe: '\\u2292',\n\tsqsupset: '\\u2290',\n\tsqsupseteq: '\\u2292',\n\tsqu: '\\u25A1',\n\tSquare: '\\u25A1',\n\tsquare: '\\u25A1',\n\tSquareIntersection: '\\u2293',\n\tSquareSubset: '\\u228F',\n\tSquareSubsetEqual: '\\u2291',\n\tSquareSuperset: '\\u2290',\n\tSquareSupersetEqual: '\\u2292',\n\tSquareUnion: '\\u2294',\n\tsquarf: '\\u25AA',\n\tsquf: '\\u25AA',\n\tsrarr: '\\u2192',\n\tSscr: '\\uD835\\uDCAE',\n\tsscr: '\\uD835\\uDCC8',\n\tssetmn: '\\u2216',\n\tssmile: '\\u2323',\n\tsstarf: '\\u22C6',\n\tStar: '\\u22C6',\n\tstar: '\\u2606',\n\tstarf: '\\u2605',\n\tstraightepsilon: '\\u03F5',\n\tstraightphi: '\\u03D5',\n\tstrns: '\\u00AF',\n\tSub: '\\u22D0',\n\tsub: '\\u2282',\n\tsubdot: '\\u2ABD',\n\tsubE: '\\u2AC5',\n\tsube: '\\u2286',\n\tsubedot: '\\u2AC3',\n\tsubmult: '\\u2AC1',\n\tsubnE: '\\u2ACB',\n\tsubne: '\\u228A',\n\tsubplus: '\\u2ABF',\n\tsubrarr: '\\u2979',\n\tSubset: '\\u22D0',\n\tsubset: '\\u2282',\n\tsubseteq: '\\u2286',\n\tsubseteqq: '\\u2AC5',\n\tSubsetEqual: '\\u2286',\n\tsubsetneq: '\\u228A',\n\tsubsetneqq: '\\u2ACB',\n\tsubsim: '\\u2AC7',\n\tsubsub: '\\u2AD5',\n\tsubsup: '\\u2AD3',\n\tsucc: '\\u227B',\n\tsuccapprox: '\\u2AB8',\n\tsucccurlyeq: '\\u227D',\n\tSucceeds: '\\u227B',\n\tSucceedsEqual: '\\u2AB0',\n\tSucceedsSlantEqual: '\\u227D',\n\tSucceedsTilde: '\\u227F',\n\tsucceq: '\\u2AB0',\n\tsuccnapprox: '\\u2ABA',\n\tsuccneqq: '\\u2AB6',\n\tsuccnsim: '\\u22E9',\n\tsuccsim: '\\u227F',\n\tSuchThat: '\\u220B',\n\tSum: '\\u2211',\n\tsum: '\\u2211',\n\tsung: '\\u266A',\n\tSup: '\\u22D1',\n\tsup: '\\u2283',\n\tsup1: '\\u00B9',\n\tsup2: '\\u00B2',\n\tsup3: '\\u00B3',\n\tsupdot: '\\u2ABE',\n\tsupdsub: '\\u2AD8',\n\tsupE: '\\u2AC6',\n\tsupe: '\\u2287',\n\tsupedot: '\\u2AC4',\n\tSuperset: '\\u2283',\n\tSupersetEqual: '\\u2287',\n\tsuphsol: '\\u27C9',\n\tsuphsub: '\\u2AD7',\n\tsuplarr: '\\u297B',\n\tsupmult: '\\u2AC2',\n\tsupnE: '\\u2ACC',\n\tsupne: '\\u228B',\n\tsupplus: '\\u2AC0',\n\tSupset: '\\u22D1',\n\tsupset: '\\u2283',\n\tsupseteq: '\\u2287',\n\tsupseteqq: '\\u2AC6',\n\tsupsetneq: '\\u228B',\n\tsupsetneqq: '\\u2ACC',\n\tsupsim: '\\u2AC8',\n\tsupsub: '\\u2AD4',\n\tsupsup: '\\u2AD6',\n\tswarhk: '\\u2926',\n\tswArr: '\\u21D9',\n\tswarr: '\\u2199',\n\tswarrow: '\\u2199',\n\tswnwar: '\\u292A',\n\tszlig: '\\u00DF',\n\tTab: '\\u0009',\n\ttarget: '\\u2316',\n\tTau: '\\u03A4',\n\ttau: '\\u03C4',\n\ttbrk: '\\u23B4',\n\tTcaron: '\\u0164',\n\ttcaron: '\\u0165',\n\tTcedil: '\\u0162',\n\ttcedil: '\\u0163',\n\tTcy: '\\u0422',\n\ttcy: '\\u0442',\n\ttdot: '\\u20DB',\n\ttelrec: '\\u2315',\n\tTfr: '\\uD835\\uDD17',\n\ttfr: '\\uD835\\uDD31',\n\tthere4: '\\u2234',\n\tTherefore: '\\u2234',\n\ttherefore: '\\u2234',\n\tTheta: '\\u0398',\n\ttheta: '\\u03B8',\n\tthetasym: '\\u03D1',\n\tthetav: '\\u03D1',\n\tthickapprox: '\\u2248',\n\tthicksim: '\\u223C',\n\tThickSpace: '\\u205F\\u200A',\n\tthinsp: '\\u2009',\n\tThinSpace: '\\u2009',\n\tthkap: '\\u2248',\n\tthksim: '\\u223C',\n\tTHORN: '\\u00DE',\n\tthorn: '\\u00FE',\n\tTilde: '\\u223C',\n\ttilde: '\\u02DC',\n\tTildeEqual: '\\u2243',\n\tTildeFullEqual: '\\u2245',\n\tTildeTilde: '\\u2248',\n\ttimes: '\\u00D7',\n\ttimesb: '\\u22A0',\n\ttimesbar: '\\u2A31',\n\ttimesd: '\\u2A30',\n\ttint: '\\u222D',\n\ttoea: '\\u2928',\n\ttop: '\\u22A4',\n\ttopbot: '\\u2336',\n\ttopcir: '\\u2AF1',\n\tTopf: '\\uD835\\uDD4B',\n\ttopf: '\\uD835\\uDD65',\n\ttopfork: '\\u2ADA',\n\ttosa: '\\u2929',\n\ttprime: '\\u2034',\n\tTRADE: '\\u2122',\n\ttrade: '\\u2122',\n\ttriangle: '\\u25B5',\n\ttriangledown: '\\u25BF',\n\ttriangleleft: '\\u25C3',\n\ttrianglelefteq: '\\u22B4',\n\ttriangleq: '\\u225C',\n\ttriangleright: '\\u25B9',\n\ttrianglerighteq: '\\u22B5',\n\ttridot: '\\u25EC',\n\ttrie: '\\u225C',\n\ttriminus: '\\u2A3A',\n\tTripleDot: '\\u20DB',\n\ttriplus: '\\u2A39',\n\ttrisb: '\\u29CD',\n\ttritime: '\\u2A3B',\n\ttrpezium: '\\u23E2',\n\tTscr: '\\uD835\\uDCAF',\n\ttscr: '\\uD835\\uDCC9',\n\tTScy: '\\u0426',\n\ttscy: '\\u0446',\n\tTSHcy: '\\u040B',\n\ttshcy: '\\u045B',\n\tTstrok: '\\u0166',\n\ttstrok: '\\u0167',\n\ttwixt: '\\u226C',\n\ttwoheadleftarrow: '\\u219E',\n\ttwoheadrightarrow: '\\u21A0',\n\tUacute: '\\u00DA',\n\tuacute: '\\u00FA',\n\tUarr: '\\u219F',\n\tuArr: '\\u21D1',\n\tuarr: '\\u2191',\n\tUarrocir: '\\u2949',\n\tUbrcy: '\\u040E',\n\tubrcy: '\\u045E',\n\tUbreve: '\\u016C',\n\tubreve: '\\u016D',\n\tUcirc: '\\u00DB',\n\tucirc: '\\u00FB',\n\tUcy: '\\u0423',\n\tucy: '\\u0443',\n\tudarr: '\\u21C5',\n\tUdblac: '\\u0170',\n\tudblac: '\\u0171',\n\tudhar: '\\u296E',\n\tufisht: '\\u297E',\n\tUfr: '\\uD835\\uDD18',\n\tufr: '\\uD835\\uDD32',\n\tUgrave: '\\u00D9',\n\tugrave: '\\u00F9',\n\tuHar: '\\u2963',\n\tuharl: '\\u21BF',\n\tuharr: '\\u21BE',\n\tuhblk: '\\u2580',\n\tulcorn: '\\u231C',\n\tulcorner: '\\u231C',\n\tulcrop: '\\u230F',\n\tultri: '\\u25F8',\n\tUmacr: '\\u016A',\n\tumacr: '\\u016B',\n\tuml: '\\u00A8',\n\tUnderBar: '\\u005F',\n\tUnderBrace: '\\u23DF',\n\tUnderBracket: '\\u23B5',\n\tUnderParenthesis: '\\u23DD',\n\tUnion: '\\u22C3',\n\tUnionPlus: '\\u228E',\n\tUogon: '\\u0172',\n\tuogon: '\\u0173',\n\tUopf: '\\uD835\\uDD4C',\n\tuopf: '\\uD835\\uDD66',\n\tUpArrow: '\\u2191',\n\tUparrow: '\\u21D1',\n\tuparrow: '\\u2191',\n\tUpArrowBar: '\\u2912',\n\tUpArrowDownArrow: '\\u21C5',\n\tUpDownArrow: '\\u2195',\n\tUpdownarrow: '\\u21D5',\n\tupdownarrow: '\\u2195',\n\tUpEquilibrium: '\\u296E',\n\tupharpoonleft: '\\u21BF',\n\tupharpoonright: '\\u21BE',\n\tuplus: '\\u228E',\n\tUpperLeftArrow: '\\u2196',\n\tUpperRightArrow: '\\u2197',\n\tUpsi: '\\u03D2',\n\tupsi: '\\u03C5',\n\tupsih: '\\u03D2',\n\tUpsilon: '\\u03A5',\n\tupsilon: '\\u03C5',\n\tUpTee: '\\u22A5',\n\tUpTeeArrow: '\\u21A5',\n\tupuparrows: '\\u21C8',\n\turcorn: '\\u231D',\n\turcorner: '\\u231D',\n\turcrop: '\\u230E',\n\tUring: '\\u016E',\n\turing: '\\u016F',\n\turtri: '\\u25F9',\n\tUscr: '\\uD835\\uDCB0',\n\tuscr: '\\uD835\\uDCCA',\n\tutdot: '\\u22F0',\n\tUtilde: '\\u0168',\n\tutilde: '\\u0169',\n\tutri: '\\u25B5',\n\tutrif: '\\u25B4',\n\tuuarr: '\\u21C8',\n\tUuml: '\\u00DC',\n\tuuml: '\\u00FC',\n\tuwangle: '\\u29A7',\n\tvangrt: '\\u299C',\n\tvarepsilon: '\\u03F5',\n\tvarkappa: '\\u03F0',\n\tvarnothing: '\\u2205',\n\tvarphi: '\\u03D5',\n\tvarpi: '\\u03D6',\n\tvarpropto: '\\u221D',\n\tvArr: '\\u21D5',\n\tvarr: '\\u2195',\n\tvarrho: '\\u03F1',\n\tvarsigma: '\\u03C2',\n\tvarsubsetneq: '\\u228A\\uFE00',\n\tvarsubsetneqq: '\\u2ACB\\uFE00',\n\tvarsupsetneq: '\\u228B\\uFE00',\n\tvarsupsetneqq: '\\u2ACC\\uFE00',\n\tvartheta: '\\u03D1',\n\tvartriangleleft: '\\u22B2',\n\tvartriangleright: '\\u22B3',\n\tVbar: '\\u2AEB',\n\tvBar: '\\u2AE8',\n\tvBarv: '\\u2AE9',\n\tVcy: '\\u0412',\n\tvcy: '\\u0432',\n\tVDash: '\\u22AB',\n\tVdash: '\\u22A9',\n\tvDash: '\\u22A8',\n\tvdash: '\\u22A2',\n\tVdashl: '\\u2AE6',\n\tVee: '\\u22C1',\n\tvee: '\\u2228',\n\tveebar: '\\u22BB',\n\tveeeq: '\\u225A',\n\tvellip: '\\u22EE',\n\tVerbar: '\\u2016',\n\tverbar: '\\u007C',\n\tVert: '\\u2016',\n\tvert: '\\u007C',\n\tVerticalBar: '\\u2223',\n\tVerticalLine: '\\u007C',\n\tVerticalSeparator: '\\u2758',\n\tVerticalTilde: '\\u2240',\n\tVeryThinSpace: '\\u200A',\n\tVfr: '\\uD835\\uDD19',\n\tvfr: '\\uD835\\uDD33',\n\tvltri: '\\u22B2',\n\tvnsub: '\\u2282\\u20D2',\n\tvnsup: '\\u2283\\u20D2',\n\tVopf: '\\uD835\\uDD4D',\n\tvopf: '\\uD835\\uDD67',\n\tvprop: '\\u221D',\n\tvrtri: '\\u22B3',\n\tVscr: '\\uD835\\uDCB1',\n\tvscr: '\\uD835\\uDCCB',\n\tvsubnE: '\\u2ACB\\uFE00',\n\tvsubne: '\\u228A\\uFE00',\n\tvsupnE: '\\u2ACC\\uFE00',\n\tvsupne: '\\u228B\\uFE00',\n\tVvdash: '\\u22AA',\n\tvzigzag: '\\u299A',\n\tWcirc: '\\u0174',\n\twcirc: '\\u0175',\n\twedbar: '\\u2A5F',\n\tWedge: '\\u22C0',\n\twedge: '\\u2227',\n\twedgeq: '\\u2259',\n\tweierp: '\\u2118',\n\tWfr: '\\uD835\\uDD1A',\n\twfr: '\\uD835\\uDD34',\n\tWopf: '\\uD835\\uDD4E',\n\twopf: '\\uD835\\uDD68',\n\twp: '\\u2118',\n\twr: '\\u2240',\n\twreath: '\\u2240',\n\tWscr: '\\uD835\\uDCB2',\n\twscr: '\\uD835\\uDCCC',\n\txcap: '\\u22C2',\n\txcirc: '\\u25EF',\n\txcup: '\\u22C3',\n\txdtri: '\\u25BD',\n\tXfr: '\\uD835\\uDD1B',\n\txfr: '\\uD835\\uDD35',\n\txhArr: '\\u27FA',\n\txharr: '\\u27F7',\n\tXi: '\\u039E',\n\txi: '\\u03BE',\n\txlArr: '\\u27F8',\n\txlarr: '\\u27F5',\n\txmap: '\\u27FC',\n\txnis: '\\u22FB',\n\txodot: '\\u2A00',\n\tXopf: '\\uD835\\uDD4F',\n\txopf: '\\uD835\\uDD69',\n\txoplus: '\\u2A01',\n\txotime: '\\u2A02',\n\txrArr: '\\u27F9',\n\txrarr: '\\u27F6',\n\tXscr: '\\uD835\\uDCB3',\n\txscr: '\\uD835\\uDCCD',\n\txsqcup: '\\u2A06',\n\txuplus: '\\u2A04',\n\txutri: '\\u25B3',\n\txvee: '\\u22C1',\n\txwedge: '\\u22C0',\n\tYacute: '\\u00DD',\n\tyacute: '\\u00FD',\n\tYAcy: '\\u042F',\n\tyacy: '\\u044F',\n\tYcirc: '\\u0176',\n\tycirc: '\\u0177',\n\tYcy: '\\u042B',\n\tycy: '\\u044B',\n\tyen: '\\u00A5',\n\tYfr: '\\uD835\\uDD1C',\n\tyfr: '\\uD835\\uDD36',\n\tYIcy: '\\u0407',\n\tyicy: '\\u0457',\n\tYopf: '\\uD835\\uDD50',\n\tyopf: '\\uD835\\uDD6A',\n\tYscr: '\\uD835\\uDCB4',\n\tyscr: '\\uD835\\uDCCE',\n\tYUcy: '\\u042E',\n\tyucy: '\\u044E',\n\tYuml: '\\u0178',\n\tyuml: '\\u00FF',\n\tZacute: '\\u0179',\n\tzacute: '\\u017A',\n\tZcaron: '\\u017D',\n\tzcaron: '\\u017E',\n\tZcy: '\\u0417',\n\tzcy: '\\u0437',\n\tZdot: '\\u017B',\n\tzdot: '\\u017C',\n\tzeetrf: '\\u2128',\n\tZeroWidthSpace: '\\u200B',\n\tZeta: '\\u0396',\n\tzeta: '\\u03B6',\n\tZfr: '\\u2128',\n\tzfr: '\\uD835\\uDD37',\n\tZHcy: '\\u0416',\n\tzhcy: '\\u0436',\n\tzigrarr: '\\u21DD',\n\tZopf: '\\u2124',\n\tzopf: '\\uD835\\uDD6B',\n\tZscr: '\\uD835\\uDCB5',\n\tzscr: '\\uD835\\uDCCF',\n\tzwj: '\\u200D',\n\tzwnj: '\\u200C',\n});\n\n/**\n * @deprecated use `HTML_ENTITIES` instead\n * @see HTML_ENTITIES\n */\nexports.entityMap = exports.HTML_ENTITIES;\n","var NAMESPACE = require(\"./conventions\").NAMESPACE;\n\n//[4] \tNameStartChar\t ::= \t\":\" | [A-Z] | \"_\" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]\n//[4a] \tNameChar\t ::= \tNameStartChar | \"-\" | \".\" | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]\n//[5] \tName\t ::= \tNameStartChar (NameChar)*\nvar nameStartChar = /[A-Z_a-z\\xC0-\\xD6\\xD8-\\xF6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD]///\\u10000-\\uEFFFF\nvar nameChar = new RegExp(\"[\\\\-\\\\.0-9\"+nameStartChar.source.slice(1,-1)+\"\\\\u00B7\\\\u0300-\\\\u036F\\\\u203F-\\\\u2040]\");\nvar tagNamePattern = new RegExp('^'+nameStartChar.source+nameChar.source+'*(?:\\:'+nameStartChar.source+nameChar.source+'*)?$');\n//var tagNamePattern = /^[a-zA-Z_][\\w\\-\\.]*(?:\\:[a-zA-Z_][\\w\\-\\.]*)?$/\n//var handlers = 'resolveEntity,getExternalSubset,characters,endDocument,endElement,endPrefixMapping,ignorableWhitespace,processingInstruction,setDocumentLocator,skippedEntity,startDocument,startElement,startPrefixMapping,notationDecl,unparsedEntityDecl,error,fatalError,warning,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,comment,endCDATA,endDTD,endEntity,startCDATA,startDTD,startEntity'.split(',')\n\n//S_TAG,\tS_ATTR,\tS_EQ,\tS_ATTR_NOQUOT_VALUE\n//S_ATTR_SPACE,\tS_ATTR_END,\tS_TAG_SPACE, S_TAG_CLOSE\nvar S_TAG = 0;//tag name offerring\nvar S_ATTR = 1;//attr name offerring\nvar S_ATTR_SPACE=2;//attr name end and space offer\nvar S_EQ = 3;//=space?\nvar S_ATTR_NOQUOT_VALUE = 4;//attr value(no quot value only)\nvar S_ATTR_END = 5;//attr value end and no space(quot end)\nvar S_TAG_SPACE = 6;//(attr value end || tag end ) && (space offer)\nvar S_TAG_CLOSE = 7;//closed el\n\n/**\n * Creates an error that will not be caught by XMLReader aka the SAX parser.\n *\n * @param {string} message\n * @param {any?} locator Optional, can provide details about the location in the source\n * @constructor\n */\nfunction ParseError(message, locator) {\n\tthis.message = message\n\tthis.locator = locator\n\tif(Error.captureStackTrace) Error.captureStackTrace(this, ParseError);\n}\nParseError.prototype = new Error();\nParseError.prototype.name = ParseError.name\n\nfunction XMLReader(){\n\n}\n\nXMLReader.prototype = {\n\tparse:function(source,defaultNSMap,entityMap){\n\t\tvar domBuilder = this.domBuilder;\n\t\tdomBuilder.startDocument();\n\t\t_copy(defaultNSMap ,defaultNSMap = {})\n\t\tparse(source,defaultNSMap,entityMap,\n\t\t\t\tdomBuilder,this.errorHandler);\n\t\tdomBuilder.endDocument();\n\t}\n}\nfunction parse(source,defaultNSMapCopy,entityMap,domBuilder,errorHandler){\n\tfunction fixedFromCharCode(code) {\n\t\t// String.prototype.fromCharCode does not supports\n\t\t// > 2 bytes unicode chars directly\n\t\tif (code > 0xffff) {\n\t\t\tcode -= 0x10000;\n\t\t\tvar surrogate1 = 0xd800 + (code >> 10)\n\t\t\t\t, surrogate2 = 0xdc00 + (code & 0x3ff);\n\n\t\t\treturn String.fromCharCode(surrogate1, surrogate2);\n\t\t} else {\n\t\t\treturn String.fromCharCode(code);\n\t\t}\n\t}\n\tfunction entityReplacer(a){\n\t\tvar k = a.slice(1,-1);\n\t\tif (Object.hasOwnProperty.call(entityMap, k)) {\n\t\t\treturn entityMap[k];\n\t\t}else if(k.charAt(0) === '#'){\n\t\t\treturn fixedFromCharCode(parseInt(k.substr(1).replace('x','0x')))\n\t\t}else{\n\t\t\terrorHandler.error('entity not found:'+a);\n\t\t\treturn a;\n\t\t}\n\t}\n\tfunction appendText(end){//has some bugs\n\t\tif(end>start){\n\t\t\tvar xt = source.substring(start,end).replace(/&#?\\w+;/g,entityReplacer);\n\t\t\tlocator&&position(start);\n\t\t\tdomBuilder.characters(xt,0,end-start);\n\t\t\tstart = end\n\t\t}\n\t}\n\tfunction position(p,m){\n\t\twhile(p>=lineEnd && (m = linePattern.exec(source))){\n\t\t\tlineStart = m.index;\n\t\t\tlineEnd = lineStart + m[0].length;\n\t\t\tlocator.lineNumber++;\n\t\t\t//console.log('line++:',locator,startPos,endPos)\n\t\t}\n\t\tlocator.columnNumber = p-lineStart+1;\n\t}\n\tvar lineStart = 0;\n\tvar lineEnd = 0;\n\tvar linePattern = /.*(?:\\r\\n?|\\n)|.*$/g\n\tvar locator = domBuilder.locator;\n\n\tvar parseStack = [{currentNSMap:defaultNSMapCopy}]\n\tvar closeMap = {};\n\tvar start = 0;\n\twhile(true){\n\t\ttry{\n\t\t\tvar tagStart = source.indexOf('<',start);\n\t\t\tif(tagStart<0){\n\t\t\t\tif(!source.substr(start).match(/^\\s*$/)){\n\t\t\t\t\tvar doc = domBuilder.doc;\n\t \t\t\tvar text = doc.createTextNode(source.substr(start));\n\t \t\t\tdoc.appendChild(text);\n\t \t\t\tdomBuilder.currentElement = text;\n\t\t\t\t}\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif(tagStart>start){\n\t\t\t\tappendText(tagStart);\n\t\t\t}\n\t\t\tswitch(source.charAt(tagStart+1)){\n\t\t\tcase '/':\n\t\t\t\tvar end = source.indexOf('>',tagStart+3);\n\t\t\t\tvar tagName = source.substring(tagStart + 2, end).replace(/[ \\t\\n\\r]+$/g, '');\n\t\t\t\tvar config = parseStack.pop();\n\t\t\t\tif(end<0){\n\n\t \t\ttagName = source.substring(tagStart+2).replace(/[\\s<].*/,'');\n\t \t\terrorHandler.error(\"end tag name: \"+tagName+' is not complete:'+config.tagName);\n\t \t\tend = tagStart+1+tagName.length;\n\t \t}else if(tagName.match(/\\s\n\t\t\t\tlocator&&position(tagStart);\n\t\t\t\tend = parseInstruction(source,tagStart,domBuilder);\n\t\t\t\tbreak;\n\t\t\tcase '!':// start){\n\t\t\tstart = end;\n\t\t}else{\n\t\t\t//TODO: 这里有可能sax回退,有位置错误风险\n\t\t\tappendText(Math.max(tagStart,start)+1);\n\t\t}\n\t}\n}\nfunction copyLocator(f,t){\n\tt.lineNumber = f.lineNumber;\n\tt.columnNumber = f.columnNumber;\n\treturn t;\n}\n\n/**\n * @see #appendElement(source,elStartEnd,el,selfClosed,entityReplacer,domBuilder,parseStack);\n * @return end of the elementStartPart(end of elementEndPart for selfClosed el)\n */\nfunction parseElementStartPart(source,start,el,currentNSMap,entityReplacer,errorHandler){\n\n\t/**\n\t * @param {string} qname\n\t * @param {string} value\n\t * @param {number} startIndex\n\t */\n\tfunction addAttribute(qname, value, startIndex) {\n\t\tif (el.attributeNames.hasOwnProperty(qname)) {\n\t\t\terrorHandler.fatalError('Attribute ' + qname + ' redefined')\n\t\t}\n\t\tel.addValue(\n\t\t\tqname,\n\t\t\t// @see https://www.w3.org/TR/xml/#AVNormalize\n\t\t\t// since the xmldom sax parser does not \"interpret\" DTD the following is not implemented:\n\t\t\t// - recursive replacement of (DTD) entity references\n\t\t\t// - trimming and collapsing multiple spaces into a single one for attributes that are not of type CDATA\n\t\t\tvalue.replace(/[\\t\\n\\r]/g, ' ').replace(/&#?\\w+;/g, entityReplacer),\n\t\t\tstartIndex\n\t\t)\n\t}\n\tvar attrName;\n\tvar value;\n\tvar p = ++start;\n\tvar s = S_TAG;//status\n\twhile(true){\n\t\tvar c = source.charAt(p);\n\t\tswitch(c){\n\t\tcase '=':\n\t\t\tif(s === S_ATTR){//attrName\n\t\t\t\tattrName = source.slice(start,p);\n\t\t\t\ts = S_EQ;\n\t\t\t}else if(s === S_ATTR_SPACE){\n\t\t\t\ts = S_EQ;\n\t\t\t}else{\n\t\t\t\t//fatalError: equal must after attrName or space after attrName\n\t\t\t\tthrow new Error('attribute equal must after attrName'); // No known test case\n\t\t\t}\n\t\t\tbreak;\n\t\tcase '\\'':\n\t\tcase '\"':\n\t\t\tif(s === S_EQ || s === S_ATTR //|| s == S_ATTR_SPACE\n\t\t\t\t){//equal\n\t\t\t\tif(s === S_ATTR){\n\t\t\t\t\terrorHandler.warning('attribute value must after \"=\"')\n\t\t\t\t\tattrName = source.slice(start,p)\n\t\t\t\t}\n\t\t\t\tstart = p+1;\n\t\t\t\tp = source.indexOf(c,start)\n\t\t\t\tif(p>0){\n\t\t\t\t\tvalue = source.slice(start, p);\n\t\t\t\t\taddAttribute(attrName, value, start-1);\n\t\t\t\t\ts = S_ATTR_END;\n\t\t\t\t}else{\n\t\t\t\t\t//fatalError: no end quot match\n\t\t\t\t\tthrow new Error('attribute value no end \\''+c+'\\' match');\n\t\t\t\t}\n\t\t\t}else if(s == S_ATTR_NOQUOT_VALUE){\n\t\t\t\tvalue = source.slice(start, p);\n\t\t\t\taddAttribute(attrName, value, start);\n\t\t\t\terrorHandler.warning('attribute \"'+attrName+'\" missed start quot('+c+')!!');\n\t\t\t\tstart = p+1;\n\t\t\t\ts = S_ATTR_END\n\t\t\t}else{\n\t\t\t\t//fatalError: no equal before\n\t\t\t\tthrow new Error('attribute value must after \"=\"'); // No known test case\n\t\t\t}\n\t\t\tbreak;\n\t\tcase '/':\n\t\t\tswitch(s){\n\t\t\tcase S_TAG:\n\t\t\t\tel.setTagName(source.slice(start,p));\n\t\t\tcase S_ATTR_END:\n\t\t\tcase S_TAG_SPACE:\n\t\t\tcase S_TAG_CLOSE:\n\t\t\t\ts =S_TAG_CLOSE;\n\t\t\t\tel.closed = true;\n\t\t\tcase S_ATTR_NOQUOT_VALUE:\n\t\t\tcase S_ATTR:\n\t\t\t\tbreak;\n\t\t\t\tcase S_ATTR_SPACE:\n\t\t\t\t\tel.closed = true;\n\t\t\t\tbreak;\n\t\t\t//case S_EQ:\n\t\t\tdefault:\n\t\t\t\tthrow new Error(\"attribute invalid close char('/')\") // No known test case\n\t\t\t}\n\t\t\tbreak;\n\t\tcase ''://end document\n\t\t\terrorHandler.error('unexpected end of input');\n\t\t\tif(s == S_TAG){\n\t\t\t\tel.setTagName(source.slice(start,p));\n\t\t\t}\n\t\t\treturn p;\n\t\tcase '>':\n\t\t\tswitch(s){\n\t\t\tcase S_TAG:\n\t\t\t\tel.setTagName(source.slice(start,p));\n\t\t\tcase S_ATTR_END:\n\t\t\tcase S_TAG_SPACE:\n\t\t\tcase S_TAG_CLOSE:\n\t\t\t\tbreak;//normal\n\t\t\tcase S_ATTR_NOQUOT_VALUE://Compatible state\n\t\t\tcase S_ATTR:\n\t\t\t\tvalue = source.slice(start,p);\n\t\t\t\tif(value.slice(-1) === '/'){\n\t\t\t\t\tel.closed = true;\n\t\t\t\t\tvalue = value.slice(0,-1)\n\t\t\t\t}\n\t\t\tcase S_ATTR_SPACE:\n\t\t\t\tif(s === S_ATTR_SPACE){\n\t\t\t\t\tvalue = attrName;\n\t\t\t\t}\n\t\t\t\tif(s == S_ATTR_NOQUOT_VALUE){\n\t\t\t\t\terrorHandler.warning('attribute \"'+value+'\" missed quot(\")!');\n\t\t\t\t\taddAttribute(attrName, value, start)\n\t\t\t\t}else{\n\t\t\t\t\tif(!NAMESPACE.isHTML(currentNSMap['']) || !value.match(/^(?:disabled|checked|selected)$/i)){\n\t\t\t\t\t\terrorHandler.warning('attribute \"'+value+'\" missed value!! \"'+value+'\" instead!!')\n\t\t\t\t\t}\n\t\t\t\t\taddAttribute(value, value, start)\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase S_EQ:\n\t\t\t\tthrow new Error('attribute value missed!!');\n\t\t\t}\n//\t\t\tconsole.log(tagName,tagNamePattern,tagNamePattern.test(tagName))\n\t\t\treturn p;\n\t\t/*xml space '\\x20' | #x9 | #xD | #xA; */\n\t\tcase '\\u0080':\n\t\t\tc = ' ';\n\t\tdefault:\n\t\t\tif(c<= ' '){//space\n\t\t\t\tswitch(s){\n\t\t\t\tcase S_TAG:\n\t\t\t\t\tel.setTagName(source.slice(start,p));//tagName\n\t\t\t\t\ts = S_TAG_SPACE;\n\t\t\t\t\tbreak;\n\t\t\t\tcase S_ATTR:\n\t\t\t\t\tattrName = source.slice(start,p)\n\t\t\t\t\ts = S_ATTR_SPACE;\n\t\t\t\t\tbreak;\n\t\t\t\tcase S_ATTR_NOQUOT_VALUE:\n\t\t\t\t\tvar value = source.slice(start, p);\n\t\t\t\t\terrorHandler.warning('attribute \"'+value+'\" missed quot(\")!!');\n\t\t\t\t\taddAttribute(attrName, value, start)\n\t\t\t\tcase S_ATTR_END:\n\t\t\t\t\ts = S_TAG_SPACE;\n\t\t\t\t\tbreak;\n\t\t\t\t//case S_TAG_SPACE:\n\t\t\t\t//case S_EQ:\n\t\t\t\t//case S_ATTR_SPACE:\n\t\t\t\t//\tvoid();break;\n\t\t\t\t//case S_TAG_CLOSE:\n\t\t\t\t\t//ignore warning\n\t\t\t\t}\n\t\t\t}else{//not space\n//S_TAG,\tS_ATTR,\tS_EQ,\tS_ATTR_NOQUOT_VALUE\n//S_ATTR_SPACE,\tS_ATTR_END,\tS_TAG_SPACE, S_TAG_CLOSE\n\t\t\t\tswitch(s){\n\t\t\t\t//case S_TAG:void();break;\n\t\t\t\t//case S_ATTR:void();break;\n\t\t\t\t//case S_ATTR_NOQUOT_VALUE:void();break;\n\t\t\t\tcase S_ATTR_SPACE:\n\t\t\t\t\tvar tagName = el.tagName;\n\t\t\t\t\tif (!NAMESPACE.isHTML(currentNSMap['']) || !attrName.match(/^(?:disabled|checked|selected)$/i)) {\n\t\t\t\t\t\terrorHandler.warning('attribute \"'+attrName+'\" missed value!! \"'+attrName+'\" instead2!!')\n\t\t\t\t\t}\n\t\t\t\t\taddAttribute(attrName, attrName, start);\n\t\t\t\t\tstart = p;\n\t\t\t\t\ts = S_ATTR;\n\t\t\t\t\tbreak;\n\t\t\t\tcase S_ATTR_END:\n\t\t\t\t\terrorHandler.warning('attribute space is required\"'+attrName+'\"!!')\n\t\t\t\tcase S_TAG_SPACE:\n\t\t\t\t\ts = S_ATTR;\n\t\t\t\t\tstart = p;\n\t\t\t\t\tbreak;\n\t\t\t\tcase S_EQ:\n\t\t\t\t\ts = S_ATTR_NOQUOT_VALUE;\n\t\t\t\t\tstart = p;\n\t\t\t\t\tbreak;\n\t\t\t\tcase S_TAG_CLOSE:\n\t\t\t\t\tthrow new Error(\"elements closed character '/' and '>' must be connected to\");\n\t\t\t\t}\n\t\t\t}\n\t\t}//end outer switch\n\t\t//console.log('p++',p)\n\t\tp++;\n\t}\n}\n/**\n * @return true if has new namespace define\n */\nfunction appendElement(el,domBuilder,currentNSMap){\n\tvar tagName = el.tagName;\n\tvar localNSMap = null;\n\t//var currentNSMap = parseStack[parseStack.length-1].currentNSMap;\n\tvar i = el.length;\n\twhile(i--){\n\t\tvar a = el[i];\n\t\tvar qName = a.qName;\n\t\tvar value = a.value;\n\t\tvar nsp = qName.indexOf(':');\n\t\tif(nsp>0){\n\t\t\tvar prefix = a.prefix = qName.slice(0,nsp);\n\t\t\tvar localName = qName.slice(nsp+1);\n\t\t\tvar nsPrefix = prefix === 'xmlns' && localName\n\t\t}else{\n\t\t\tlocalName = qName;\n\t\t\tprefix = null\n\t\t\tnsPrefix = qName === 'xmlns' && ''\n\t\t}\n\t\t//can not set prefix,because prefix !== ''\n\t\ta.localName = localName ;\n\t\t//prefix == null for no ns prefix attribute\n\t\tif(nsPrefix !== false){//hack!!\n\t\t\tif(localNSMap == null){\n\t\t\t\tlocalNSMap = {}\n\t\t\t\t//console.log(currentNSMap,0)\n\t\t\t\t_copy(currentNSMap,currentNSMap={})\n\t\t\t\t//console.log(currentNSMap,1)\n\t\t\t}\n\t\t\tcurrentNSMap[nsPrefix] = localNSMap[nsPrefix] = value;\n\t\t\ta.uri = NAMESPACE.XMLNS\n\t\t\tdomBuilder.startPrefixMapping(nsPrefix, value)\n\t\t}\n\t}\n\tvar i = el.length;\n\twhile(i--){\n\t\ta = el[i];\n\t\tvar prefix = a.prefix;\n\t\tif(prefix){//no prefix attribute has no namespace\n\t\t\tif(prefix === 'xml'){\n\t\t\t\ta.uri = NAMESPACE.XML;\n\t\t\t}if(prefix !== 'xmlns'){\n\t\t\t\ta.uri = currentNSMap[prefix || '']\n\n\t\t\t\t//{console.log('###'+a.qName,domBuilder.locator.systemId+'',currentNSMap,a.uri)}\n\t\t\t}\n\t\t}\n\t}\n\tvar nsp = tagName.indexOf(':');\n\tif(nsp>0){\n\t\tprefix = el.prefix = tagName.slice(0,nsp);\n\t\tlocalName = el.localName = tagName.slice(nsp+1);\n\t}else{\n\t\tprefix = null;//important!!\n\t\tlocalName = el.localName = tagName;\n\t}\n\t//no prefix element has default namespace\n\tvar ns = el.uri = currentNSMap[prefix || ''];\n\tdomBuilder.startElement(ns,localName,tagName,el);\n\t//endPrefixMapping and startPrefixMapping have not any help for dom builder\n\t//localNSMap = null\n\tif(el.closed){\n\t\tdomBuilder.endElement(ns,localName,tagName);\n\t\tif(localNSMap){\n\t\t\tfor (prefix in localNSMap) {\n\t\t\t\tif (Object.prototype.hasOwnProperty.call(localNSMap, prefix)) {\n\t\t\t\t\tdomBuilder.endPrefixMapping(prefix);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}else{\n\t\tel.currentNSMap = currentNSMap;\n\t\tel.localNSMap = localNSMap;\n\t\t//parseStack.push(el);\n\t\treturn true;\n\t}\n}\nfunction parseHtmlSpecialContent(source,elStartEnd,tagName,entityReplacer,domBuilder){\n\tif(/^(?:script|textarea)$/i.test(tagName)){\n\t\tvar elEndStart = source.indexOf('',elStartEnd);\n\t\tvar text = source.substring(elStartEnd+1,elEndStart);\n\t\tif(/[&<]/.test(text)){\n\t\t\tif(/^script$/i.test(tagName)){\n\t\t\t\t//if(!/\\]\\]>/.test(text)){\n\t\t\t\t\t//lexHandler.startCDATA();\n\t\t\t\t\tdomBuilder.characters(text,0,text.length);\n\t\t\t\t\t//lexHandler.endCDATA();\n\t\t\t\t\treturn elEndStart;\n\t\t\t\t//}\n\t\t\t}//}else{//text area\n\t\t\t\ttext = text.replace(/&#?\\w+;/g,entityReplacer);\n\t\t\t\tdomBuilder.characters(text,0,text.length);\n\t\t\t\treturn elEndStart;\n\t\t\t//}\n\n\t\t}\n\t}\n\treturn elStartEnd+1;\n}\nfunction fixSelfClosed(source,elStartEnd,tagName,closeMap){\n\t//if(tagName in closeMap){\n\tvar pos = closeMap[tagName];\n\tif(pos == null){\n\t\t//console.log(tagName)\n\t\tpos = source.lastIndexOf('')\n\t\tif(pos',start+4);\n\t\t\t//append comment source.substring(4,end)//