{"version":3,"sources":["webpack:///./node_modules/remarkable/lib/configs/full.js","webpack:///./node_modules/remarkable/lib/helpers/parse_link_destination.js","webpack:///./node_modules/remarkable/lib/rules_core/smartquotes.js","webpack:///./node_modules/remarkable/lib/ruler.js","webpack:///./node_modules/remarkable/lib/rules_inline/emphasis.js","webpack:///./node_modules/remarkable/lib/helpers/normalize_reference.js","webpack:///./node_modules/remarkable/lib/rules_inline/del.js","webpack:///./node_modules/remarkable/lib/rules_block/state_block.js","webpack:///./node_modules/remarkable/lib/rules_block/hr.js","webpack:///./node_modules/remarkable/lib/rules_inline/newline.js","webpack:///./node_modules/isarray/index.js","webpack:///./node_modules/remarkable/lib/rules_inline/footnote_inline.js","webpack:///./node_modules/gatsby/node_modules/core-js/internals/string-trim-forced.js","webpack:///./src/utils/createCanonicalUrl.js","webpack:///./src/components/ButtonLink/ButtonLink.js","webpack:///./node_modules/remarkable/lib/rules_block/heading.js","webpack:///./node_modules/remarkable/lib/rules_inline/entity.js","webpack:///./node_modules/remarkable/lib/rules_inline/sub.js","webpack:///./node_modules/remarkable/lib/rules_inline/autolink.js","webpack:///./node_modules/remarkable/lib/rules_inline/links.js","webpack:///./node_modules/remarkable/lib/rules_inline/footnote_ref.js","webpack:///./node_modules/remarkable/lib/rules_inline/backticks.js","webpack:///./node_modules/base64-js/index.js","webpack:///./node_modules/node-libs-browser/node_modules/buffer/index.js","webpack:///./node_modules/remarkable/lib/rules_core/references.js","webpack:///./node_modules/remarkable/lib/common/html_re.js","webpack:///./node_modules/remarkable/lib/rules_block/table.js","webpack:///./node_modules/remarkable/lib/rules_block/blockquote.js","webpack:///./node_modules/remarkable/lib/configs/commonmark.js","webpack:///./node_modules/remarkable/lib/rules_inline/sup.js","webpack:///./src/components/CodeExample/index.js","webpack:///./node_modules/remarkable/lib/rules_block/paragraph.js","webpack:///./node_modules/remarkable/lib/rules_block/fences.js","webpack:///./src/pages/index.js","webpack:///./node_modules/remarkable/lib/index.js","webpack:///./node_modules/remarkable/lib/rules_inline/htmltag.js","webpack:///./node_modules/remarkable/lib/helpers/parse_link_label.js","webpack:///./node_modules/remarkable/lib/rules_core/inline.js","webpack:///./node_modules/remarkable/lib/helpers/parse_link_title.js","webpack:///./node_modules/remarkable/lib/common/html_blocks.js","webpack:///./node_modules/remarkable/lib/parser_inline.js","webpack:///./node_modules/remarkable/lib/rules_block/footnote.js","webpack:///./node_modules/remarkable/index.js","webpack:///./node_modules/remarkable/lib/parser_block.js","webpack:///./src/components/CodeExample/CodeExample.js","webpack:///./node_modules/remarkable/lib/common/entities.js","webpack:///./node_modules/remarkable/lib/rules_block/htmlblock.js","webpack:///./node_modules/remarkable/lib/rules_core/linkify.js","webpack:///./node_modules/autolinker/dist/Autolinker.js","webpack:///./src/components/CodeEditor/CodeEditor.js","webpack:///./node_modules/gatsby/node_modules/core-js/modules/es.string.trim-start.js","webpack:///./src/components/ButtonLink/index.js","webpack:///./node_modules/remarkable/lib/rules_inline/state_inline.js","webpack:///./node_modules/remarkable/lib/rules_core/abbr2.js","webpack:///./node_modules/remarkable/lib/common/utils.js","webpack:///./node_modules/remarkable/lib/parser_core.js","webpack:///./node_modules/remarkable/lib/rules_block/list.js","webpack:///./node_modules/remarkable/lib/rules.js","webpack:///./node_modules/remarkable/lib/rules_block/lheading.js","webpack:///./node_modules/remarkable/lib/rules_inline/escape.js","webpack:///./node_modules/remarkable/lib/rules_inline/mark.js","webpack:///./node_modules/remarkable/lib/configs/default.js","webpack:///./node_modules/remarkable/lib/rules_core/footnote_tail.js","webpack:///./node_modules/remarkable/lib/rules_block/code.js","webpack:///./node_modules/remarkable/lib/renderer.js","webpack:///./node_modules/remarkable/lib/rules_core/abbr.js","webpack:///./node_modules/ieee754/index.js","webpack:///./node_modules/remarkable/lib/rules_core/block.js","webpack:///./src/icons/logo-white.svg","webpack:///./node_modules/gatsby/node_modules/core-js/modules/es.string.trim-end.js","webpack:///./node_modules/remarkable/lib/helpers/normalize_link.js","webpack:///./node_modules/remarkable/lib/rules_inline/text.js","webpack:///./node_modules/remarkable/lib/rules_inline/ins.js","webpack:///./node_modules/remarkable/lib/rules_block/deflist.js","webpack:///./src/utils/loadScript.js","webpack:///./node_modules/remarkable/lib/common/url_schemas.js","webpack:///./node_modules/remarkable/lib/rules_core/replacements.js"],"names":["module","exports","options","html","xhtmlOut","breaks","langPrefix","linkify","linkTarget","typographer","quotes","highlight","maxNesting","components","core","block","inline","normalizeLink","unescapeMd","state","pos","code","level","link","start","max","posMax","src","charCodeAt","slice","parser","validateLink","linkContent","QUOTE_TEST_RE","QUOTE_RE","PUNCT_RE","isLetter","str","length","test","replaceAt","index","ch","substr","i","token","text","t","thisLevel","lastSpace","nextSpace","item","canOpen","canClose","j","isSingle","blkIdx","tokens","stack","type","children","content","OUTER","lastIndex","exec","single","push","Ruler","this","__rules__","__cache__","prototype","__find__","name","len","__compile__","self","chains","forEach","rule","enabled","alt","altName","indexOf","chain","fn","at","idx","opt","Error","before","beforeName","ruleName","splice","after","afterName","enable","list","strict","Array","isArray","disable","getRules","chainName","isAlphaNum","scanDelims","lastChar","nextChar","count","can_open","can_close","marker","delims","silent","startCount","found","oldCount","newCount","res","pending","skipToken","pop","tokenize","trim","replace","toUpperCase","StateBlock","env","s","indent","indent_found","bMarks","eMarks","tShift","blkIndent","line","lineMax","tight","parentType","ddIndent","result","isEmpty","skipEmptyLines","from","skipSpaces","skipChars","skipCharsBack","min","getLines","begin","end","keepLastLF","first","last","queue","shift","Math","join","startLine","endLine","cnt","lines","pmax","substring","toString","arr","call","parseLinkLabel","labelStart","labelEnd","footnoteId","oldLength","footnotes","id","linkLevel","fails","whitespaces","METHOD_NAME","slug","urlRoot","ArrowSvg","cssProps","css","height","xmlns","viewBox","d","fill","style","display","fontSize","media","greaterThan","primaryStyle","backgroundColor","colors","brand","color","black","padding","whiteSpace","transition","paddingTop","paddingBottom","white","secondaryStyle","ButtonLink","typeStyle","rest","marginLeft","tmp","hLevel","entities","has","isValidEntityCode","fromCodePoint","DIGITAL_RE","NAMED_RE","match","toLowerCase","parseInt","UNESCAPE_RE","url_schemas","EMAIL_RE","AUTOLINK_RE","tail","linkMatch","emailMatch","url","fullUrl","href","parseLinkDestination","parseLinkTitle","normalizeReference","label","title","ref","isImage","oldPos","references","footnoteSubId","refs","subId","matchStart","matchEnd","byteLength","b64","lens","getLens","validLen","placeHoldersLen","toByteArray","Arr","_byteLength","curByte","revLookup","fromByteArray","uint8","extraBytes","parts","len2","encodeChunk","lookup","Uint8Array","num","output","base64","ieee754","kMaxLength","Buffer","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","__proto__","arg","encodingOrOffset","allocUnsafe","value","TypeError","ArrayBuffer","array","byteOffset","undefined","fromArrayLike","fromArrayBuffer","string","encoding","isEncoding","actual","write","fromString","obj","isBuffer","checked","copy","buffer","val","data","fromObject","assertSize","size","isView","loweredCase","utf8ToBytes","base64ToBytes","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","b","n","m","bidirectionalIndexOf","dir","isNaN","arrayIndexOf","lastIndexOf","indexSize","arrLength","valLength","String","read","buf","readUInt16BE","foundIndex","hexWrite","offset","Number","remaining","strLen","parsed","utf8Write","blitBuffer","asciiWrite","byteArray","asciiToBytes","latin1Write","base64Write","ucs2Write","units","c","hi","lo","utf16leToBytes","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","codePoints","fromCharCode","apply","decodeCodePointsArray","SlowBuffer","alloc","INSPECT_MAX_BYTES","global","foo","subarray","e","typedArraySupport","poolSize","_augment","Symbol","species","Object","defineProperty","configurable","allocUnsafeSlow","_isBuffer","compare","a","x","y","concat","swap16","swap32","swap64","arguments","equals","inspect","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","_arr","ret","out","toHex","bytes","checkOffset","ext","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","writeUIntBE","writeUInt8","floor","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","set","INVALID_BASE64_RE","Infinity","leadSurrogate","stringtrim","base64clean","dst","StateInline","parseReference","l","inlineMode","regex","source","RegExp","attr_value","attribute","open_tag","HTML_TAG_RE","getLine","lineText","nextLine","rows","cell","aligns","tableLines","tbodyLines","split","align","lastLineEmpty","oldTShift","oldBMarks","oldIndent","oldParentType","terminatorRules","terminate","ruler","rules","CodeExample","params","mem","haveEndMarker","Home","babelLoaded","componentDidMount","loadScript","babelURL","then","setState","error","console","render","props","location","codeExamples","examples","marketing","edges","reduce","node","mdAbsolutePath","canonicalUrl","createCanonicalUrl","width","dark","maxWidth","marginRight","position","top","left","bottom","right","backgroundImage","logoWhiteSvg","backgroundRepeat","backgroundPosition","backgroundSize","opacity","textAlign","margin","letterSpacing","fontWeight","valign","halign","flexWrap","justifyContent","CtaItem","to","sharedStyles","markdown","sectionStyles","lessThan","marginTop","marginBottom","overflowX","WebkitOverflowScrolling","maskImage","flexDirection","map","column","key","flex","verticalAlign","headingStyles","subtle","frontmatter","dangerouslySetInnerHTML","__html","border","borderBottom","divider","snippet","fileAbsolutePath","containerNodeID","domid","loaded","background","Component","propTypes","PropTypes","shape","object","isRequired","primary","between","paddingLeft","paddingRight","pageQuery","assign","Renderer","ParserCore","ParserBlock","ParserInline","config","StateCore","instance","renderer","Remarkable","preset","configure","presets","keys","use","plugin","parse","process","parseInline","renderInline","utils","lc","oldFlag","isInLabel","labelUnmatchedScopes","tok","html_blocks","_rules","replaceEntities","cached_pos","cacheGet","cacheSet","ok","pushPending","outTokens","oldBMark","hasEmptyLines","TABS_SCAN_RE","NEWLINES_RE","SPACES_RE","lineStart","lastTabPos","lineHeight","block_names","HTML_TAG_OPEN_RE","HTML_TAG_CLOSE_RE","Autolinker","LINK_SCAN_RE","isLinkClose","createLinkifier","links","autolinker","stripPrefix","email","twitter","replaceFn","linker","getType","matchedText","getUrl","getEmail","nodes","ln","htmlLinkLevel","blockTokens","linkifier","alphaNumericChars","emailRegex","domainNameRegex","tldRegex","attrValueRegex","nameEqualsValueRegex","alphaNumericCharsStr","cfg","version","urls","normalizeUrlsCfg","phone","hashtag","newWindow","truncate","normalizeTruncateCfg","className","htmlParser","matchers","tagBuilder","textOrHtml","constructor","schemeMatches","wwwMatches","tldMatches","Util","defaults","POSITIVE_INFINITY","htmlNodes","getHtmlParser","anchorTagStackCount","matches","nodeType","getTagName","isClosing","textNodeMatches","parseText","getText","getOffset","compactMatches","removeUnwantedMatches","sort","endIdx","getMatchedText","remove","getUrlMatchType","getMatchers","numMatchers","textMatches","parseMatches","numTextMatches","setOffset","newHtml","createMatchReturnVal","replaceFnResult","HtmlTag","toAnchorString","buildTag","HtmlParser","matchersNs","matcher","getTagBuilder","Hashtag","serviceName","Email","Phone","Twitter","Url","AnchorTagBuilder","abstractMethod","trimRegex","dest","prop","hasOwnProperty","extend","superclass","protoProps","subclass","superclassProto","F","subclassProto","ellipsis","truncateLen","ellipsisChars","element","splitAndCapture","splitRegex","lastIdx","whitespaceRegex","innerHtml","innerHTML","setTagName","tagName","setAttr","attrName","attrValue","getAttrs","getAttr","setAttrs","attrs","tagAttrs","setClass","cssClass","addClass","newClass","classAttr","getClass","classes","newClasses","removeClass","removeClasses","hasClass","setInnerHtml","getInnerHtml","attrsStr","buildAttrsStr","attrsArr","RegexLib","alphaCharsStr","build","createAttrs","getAnchorHref","processAnchorText","getAnchorText","matchType","anchorHref","createCssClass","anchorText","doTruncate","truncateLength","truncateLocation","TruncateSmart","TruncateMiddle","TruncateEnd","htmlRegex","htmlCharacterEntitiesRegex","currentResult","textAndEntityNodes","tagText","commentText","isClosingTag","inBetweenTagsText","parseTextAndEntityNodes","createCommentNode","createElementNode","textAndEntityTokens","textToken","entityToken","createTextNode","createEntityNode","CommentNode","comment","ElementNode","closing","EntityNode","TextNode","HtmlNode","getComment","Match","getServiceName","getHashtag","number","plusSign","getNumber","twitterHandle","getTwitterHandle","urlMatchType","protocolUrlMatch","protocolRelativeMatch","urlPrefixRegex","protocolRelativeRegex","protocolPrepended","stripProtocolRelativePrefix","stripUrlPrefix","removeTrailingSlash","charAt","Matcher","matcherRegex","nonWordCharRegex","prevChar","cleanNumber","urlSuffixRegex","wordCharRegExp","openParensRe","closeParensRe","matchStr","schemeUrlMatch","wwwUrlMatch","wwwProtocolRelativeMatch","tldProtocolRelativeMatch","UrlMatchValidator","isValid","matchHasUnbalancedClosingParen","matchHasInvalidCharAfterTld","openParensMatch","closeParensMatch","urlMatch","hasFullProtocolRegex","uriSchemeRegex","hasWordCharAfterProtocolRegex","ipRegex","isValidUriScheme","urlMatchDoesNotHaveProtocolOrDot","urlMatchDoesNotHaveAtLeastOneWordChar","isValidIpAddress","uriSchemeMatch","newRegex","uriScheme","availableLength","ceil","buildUrl","urlObj","scheme","host","path","query","fragment","buildSegment","segment","remainingAvailableLength","remainingAvailableLengthHalf","startOffset","endOffset","urlSub","parse_url","matchQuery","pathAndQuery","compileES5","Babel","transform","CodeEditor","context","_onChange","_updateState","showJSX","_render","componentDidUpdate","prevProps","prevState","compiled","UNSAFE_componentWillReceiveProps","nextProps","errorMessage","compiledES6","showBabelErrorMessage","message","mountStylesheet","alignItems","overflow","borderRadius","darker","onDark","float","cursor","onChange","event","maxHeight","outline","ignoreTabKey","wordBreak","root","ReactDOM","document","getElementById","Function","React","newState","compileES6","_","p1","window","$","$trimStart","FORCED","forcedStringTrimMethod","trimStart","proto","forced","trimLeft","parserInline","pendingLevel","cache","regEscape","reg","regText","abbreviations","abbrRegExp","hasOwn","UNESCAPE_MD_RE","surrogate1","surrogate2","NAMED_ENTITY_RE","DIGITAL_ENTITY_TEST_RE","replaceEntityPattern","HTML_ESCAPE_TEST_RE","HTML_ESCAPE_REPLACE_RE","HTML_REPLACEMENTS","replaceUnsafeChar","sources","isString","typeOf","escapeHtml","Core","skipBulletListMarker","skipOrderedListMarker","oldTight","posAfterMarker","indentAfterMarker","markerValue","markerCharCode","isOrdered","contentStart","listTokIdx","prevEmptyEnd","listLines","itemLines","order","markTightParagraphs","blockquote_open","blockquote_close","getBreak","fence","fences","fenceName","langClass","fence_custom","heading_open","heading_close","hr","bullet_list_open","bullet_list_close","list_item_open","list_item_close","ordered_list_open","ordered_list_close","paragraph_open","paragraph_close","addBreak","link_open","link_close","image","table_open","table_close","thead_open","thead_close","tbody_open","tbody_close","tr_open","tr_close","th_open","th_close","td_open","td_close","strong_open","strong_close","em_open","em_close","del_open","del_close","ins_open","ins_close","mark_open","mark_close","sup","hardbreak","softbreak","htmlblock","htmltag","abbr_open","abbr_close","footnote_ref","footnote_block_open","footnote_block_close","footnote_open","footnote_close","footnote_anchor","dl_open","dt_open","dd_open","dl_close","dt_close","dd_close","nextToken","next","ESCAPED","lastParagraph","current","currentLabel","insideRef","refTokens","filter","parseAbbr","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","NaN","rt","abs","log","LN2","$trimEnd","trimEnd","trimRight","normalized","decodeURI","err","encodeURI","isTerminatorChar","skipMarker","ddLine","dtLine","oldDDIndent","Promise","resolve","reject","head","appendChild","createElement","async","onload","onerror","RARE_RE","SCOPED_ABBR_RE","SCOPED_ABBR","inlineTokens"],"mappings":"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","file":"component---src-pages-index-js-f48f64c9a56f53f635a0.js","sourcesContent":["// Remarkable default options\n'use strict';\n\nmodule.exports = {\n  options: {\n    html: false,\n    // Enable HTML tags in source\n    xhtmlOut: false,\n    // Use '/' to close single tags (<br />)\n    breaks: false,\n    // Convert '\\n' in paragraphs into <br>\n    langPrefix: 'language-',\n    // CSS language prefix for fenced blocks\n    linkify: false,\n    // autoconvert URL-like texts to links\n    linkTarget: '',\n    // set target to open link in\n    // Enable some language-neutral replacements + quotes beautification\n    typographer: false,\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Set doubles to '«»' for Russian, '„“' for German.\n    quotes: '“”‘’',\n    // Highlighter function. Should return escaped HTML,\n    // or '' if input not changed\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n    maxNesting: 20 // Internal protection, recursion limit\n\n  },\n  components: {\n    // Don't restrict core/block/inline rules\n    core: {},\n    block: {},\n    inline: {}\n  }\n};","'use strict';\n\nvar normalizeLink = require('./normalize_link');\n\nvar unescapeMd = require('../common/utils').unescapeMd;\n/**\n * Parse link destination\n *\n *   - on success it returns a string and updates state.pos;\n *   - on failure it returns null\n *\n * @param  {Object} state\n * @param  {Number} pos\n * @api private\n */\n\n\nmodule.exports = function parseLinkDestination(state, pos) {\n  var code,\n      level,\n      link,\n      start = pos,\n      max = state.posMax;\n\n  if (state.src.charCodeAt(pos) === 0x3C\n  /* < */\n  ) {\n      pos++;\n\n      while (pos < max) {\n        code = state.src.charCodeAt(pos);\n\n        if (code === 0x0A\n        /* \\n */\n        ) {\n            return false;\n          }\n\n        if (code === 0x3E\n        /* > */\n        ) {\n            link = normalizeLink(unescapeMd(state.src.slice(start + 1, pos)));\n\n            if (!state.parser.validateLink(link)) {\n              return false;\n            }\n\n            state.pos = pos + 1;\n            state.linkContent = link;\n            return true;\n          }\n\n        if (code === 0x5C\n        /* \\ */\n        && pos + 1 < max) {\n          pos += 2;\n          continue;\n        }\n\n        pos++;\n      } // no closing '>'\n\n\n      return false;\n    } // this should be ... } else { ... branch\n\n\n  level = 0;\n\n  while (pos < max) {\n    code = state.src.charCodeAt(pos);\n\n    if (code === 0x20) {\n      break;\n    } // ascii control chars\n\n\n    if (code < 0x20 || code === 0x7F) {\n      break;\n    }\n\n    if (code === 0x5C\n    /* \\ */\n    && pos + 1 < max) {\n      pos += 2;\n      continue;\n    }\n\n    if (code === 0x28\n    /* ( */\n    ) {\n        level++;\n\n        if (level > 1) {\n          break;\n        }\n      }\n\n    if (code === 0x29\n    /* ) */\n    ) {\n        level--;\n\n        if (level < 0) {\n          break;\n        }\n      }\n\n    pos++;\n  }\n\n  if (start === pos) {\n    return false;\n  }\n\n  link = unescapeMd(state.src.slice(start, pos));\n\n  if (!state.parser.validateLink(link)) {\n    return false;\n  }\n\n  state.linkContent = link;\n  state.pos = pos;\n  return true;\n};","// Convert straight quotation marks to typographic ones\n//\n'use strict';\n\nvar QUOTE_TEST_RE = /['\"]/;\nvar QUOTE_RE = /['\"]/g;\nvar PUNCT_RE = /[-\\s()\\[\\]]/;\nvar APOSTROPHE = '’'; // This function returns true if the character at `pos`\n// could be inside a word.\n\nfunction isLetter(str, pos) {\n  if (pos < 0 || pos >= str.length) {\n    return false;\n  }\n\n  return !PUNCT_RE.test(str[pos]);\n}\n\nfunction replaceAt(str, index, ch) {\n  return str.substr(0, index) + ch + str.substr(index + 1);\n}\n\nmodule.exports = function smartquotes(state) {\n  /*eslint max-depth:0*/\n  var i, token, text, t, pos, max, thisLevel, lastSpace, nextSpace, item, canOpen, canClose, j, isSingle, blkIdx, tokens, stack;\n\n  if (!state.options.typographer) {\n    return;\n  }\n\n  stack = [];\n\n  for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {\n    if (state.tokens[blkIdx].type !== 'inline') {\n      continue;\n    }\n\n    tokens = state.tokens[blkIdx].children;\n    stack.length = 0;\n\n    for (i = 0; i < tokens.length; i++) {\n      token = tokens[i];\n\n      if (token.type !== 'text' || QUOTE_TEST_RE.test(token.text)) {\n        continue;\n      }\n\n      thisLevel = tokens[i].level;\n\n      for (j = stack.length - 1; j >= 0; j--) {\n        if (stack[j].level <= thisLevel) {\n          break;\n        }\n      }\n\n      stack.length = j + 1;\n      text = token.content;\n      pos = 0;\n      max = text.length;\n      /*eslint no-labels:0,block-scoped-var:0*/\n\n      OUTER: while (pos < max) {\n        QUOTE_RE.lastIndex = pos;\n        t = QUOTE_RE.exec(text);\n\n        if (!t) {\n          break;\n        }\n\n        lastSpace = !isLetter(text, t.index - 1);\n        pos = t.index + 1;\n        isSingle = t[0] === \"'\";\n        nextSpace = !isLetter(text, pos);\n\n        if (!nextSpace && !lastSpace) {\n          // middle of word\n          if (isSingle) {\n            token.content = replaceAt(token.content, t.index, APOSTROPHE);\n          }\n\n          continue;\n        }\n\n        canOpen = !nextSpace;\n        canClose = !lastSpace;\n\n        if (canClose) {\n          // this could be a closing quote, rewind the stack to get a match\n          for (j = stack.length - 1; j >= 0; j--) {\n            item = stack[j];\n\n            if (stack[j].level < thisLevel) {\n              break;\n            }\n\n            if (item.single === isSingle && stack[j].level === thisLevel) {\n              item = stack[j];\n\n              if (isSingle) {\n                tokens[item.token].content = replaceAt(tokens[item.token].content, item.pos, state.options.quotes[2]);\n                token.content = replaceAt(token.content, t.index, state.options.quotes[3]);\n              } else {\n                tokens[item.token].content = replaceAt(tokens[item.token].content, item.pos, state.options.quotes[0]);\n                token.content = replaceAt(token.content, t.index, state.options.quotes[1]);\n              }\n\n              stack.length = j;\n              continue OUTER;\n            }\n          }\n        }\n\n        if (canOpen) {\n          stack.push({\n            token: i,\n            pos: t.index,\n            single: isSingle,\n            level: thisLevel\n          });\n        } else if (canClose && isSingle) {\n          token.content = replaceAt(token.content, t.index, APOSTROPHE);\n        }\n      }\n    }\n  }\n};","'use strict';\n/**\n * Ruler is a helper class for building responsibility chains from\n * parse rules. It allows:\n *\n *   - easy stack rules chains\n *   - getting main chain and named chains content (as arrays of functions)\n *\n * Helper methods, should not be used directly.\n * @api private\n */\n\nfunction Ruler() {\n  // List of added rules. Each element is:\n  //\n  // { name: XXX,\n  //   enabled: Boolean,\n  //   fn: Function(),\n  //   alt: [ name2, name3 ] }\n  //\n  this.__rules__ = []; // Cached rule chains.\n  //\n  // First level - chain name, '' for default.\n  // Second level - digital anchor for fast filtering by charcodes.\n  //\n\n  this.__cache__ = null;\n}\n/**\n * Find the index of a rule by `name`.\n *\n * @param  {String} `name`\n * @return {Number} Index of the given `name`\n * @api private\n */\n\n\nRuler.prototype.__find__ = function (name) {\n  var len = this.__rules__.length;\n  var i = -1;\n\n  while (len--) {\n    if (this.__rules__[++i].name === name) {\n      return i;\n    }\n  }\n\n  return -1;\n};\n/**\n * Build the rules lookup cache\n *\n * @api private\n */\n\n\nRuler.prototype.__compile__ = function () {\n  var self = this;\n  var chains = ['']; // collect unique names\n\n  self.__rules__.forEach(function (rule) {\n    if (!rule.enabled) {\n      return;\n    }\n\n    rule.alt.forEach(function (altName) {\n      if (chains.indexOf(altName) < 0) {\n        chains.push(altName);\n      }\n    });\n  });\n\n  self.__cache__ = {};\n  chains.forEach(function (chain) {\n    self.__cache__[chain] = [];\n\n    self.__rules__.forEach(function (rule) {\n      if (!rule.enabled) {\n        return;\n      }\n\n      if (chain && rule.alt.indexOf(chain) < 0) {\n        return;\n      }\n\n      self.__cache__[chain].push(rule.fn);\n    });\n  });\n};\n/**\n * Ruler public methods\n * ------------------------------------------------\n */\n\n/**\n * Replace rule function\n *\n * @param  {String} `name` Rule name\n * @param  {Function `fn`\n * @param  {Object} `options`\n * @api private\n */\n\n\nRuler.prototype.at = function (name, fn, options) {\n  var idx = this.__find__(name);\n\n  var opt = options || {};\n\n  if (idx === -1) {\n    throw new Error('Parser rule not found: ' + name);\n  }\n\n  this.__rules__[idx].fn = fn;\n  this.__rules__[idx].alt = opt.alt || [];\n  this.__cache__ = null;\n};\n/**\n * Add a rule to the chain before given the `ruleName`.\n *\n * @param  {String}   `beforeName`\n * @param  {String}   `ruleName`\n * @param  {Function} `fn`\n * @param  {Object}   `options`\n * @api private\n */\n\n\nRuler.prototype.before = function (beforeName, ruleName, fn, options) {\n  var idx = this.__find__(beforeName);\n\n  var opt = options || {};\n\n  if (idx === -1) {\n    throw new Error('Parser rule not found: ' + beforeName);\n  }\n\n  this.__rules__.splice(idx, 0, {\n    name: ruleName,\n    enabled: true,\n    fn: fn,\n    alt: opt.alt || []\n  });\n\n  this.__cache__ = null;\n};\n/**\n * Add a rule to the chain after the given `ruleName`.\n *\n * @param  {String}   `afterName`\n * @param  {String}   `ruleName`\n * @param  {Function} `fn`\n * @param  {Object}   `options`\n * @api private\n */\n\n\nRuler.prototype.after = function (afterName, ruleName, fn, options) {\n  var idx = this.__find__(afterName);\n\n  var opt = options || {};\n\n  if (idx === -1) {\n    throw new Error('Parser rule not found: ' + afterName);\n  }\n\n  this.__rules__.splice(idx + 1, 0, {\n    name: ruleName,\n    enabled: true,\n    fn: fn,\n    alt: opt.alt || []\n  });\n\n  this.__cache__ = null;\n};\n/**\n * Add a rule to the end of chain.\n *\n * @param  {String}   `ruleName`\n * @param  {Function} `fn`\n * @param  {Object}   `options`\n * @return {String}\n */\n\n\nRuler.prototype.push = function (ruleName, fn, options) {\n  var opt = options || {};\n\n  this.__rules__.push({\n    name: ruleName,\n    enabled: true,\n    fn: fn,\n    alt: opt.alt || []\n  });\n\n  this.__cache__ = null;\n};\n/**\n * Enable a rule or list of rules.\n *\n * @param  {String|Array} `list` Name or array of rule names to enable\n * @param  {Boolean} `strict` If `true`, all non listed rules will be disabled.\n * @api private\n */\n\n\nRuler.prototype.enable = function (list, strict) {\n  list = !Array.isArray(list) ? [list] : list; // In strict mode disable all existing rules first\n\n  if (strict) {\n    this.__rules__.forEach(function (rule) {\n      rule.enabled = false;\n    });\n  } // Search by name and enable\n\n\n  list.forEach(function (name) {\n    var idx = this.__find__(name);\n\n    if (idx < 0) {\n      throw new Error('Rules manager: invalid rule name ' + name);\n    }\n\n    this.__rules__[idx].enabled = true;\n  }, this);\n  this.__cache__ = null;\n};\n/**\n * Disable a rule or list of rules.\n *\n * @param  {String|Array} `list` Name or array of rule names to disable\n * @api private\n */\n\n\nRuler.prototype.disable = function (list) {\n  list = !Array.isArray(list) ? [list] : list; // Search by name and disable\n\n  list.forEach(function (name) {\n    var idx = this.__find__(name);\n\n    if (idx < 0) {\n      throw new Error('Rules manager: invalid rule name ' + name);\n    }\n\n    this.__rules__[idx].enabled = false;\n  }, this);\n  this.__cache__ = null;\n};\n/**\n * Get a rules list as an array of functions.\n *\n * @param  {String} `chainName`\n * @return {Object}\n * @api private\n */\n\n\nRuler.prototype.getRules = function (chainName) {\n  if (this.__cache__ === null) {\n    this.__compile__();\n  }\n\n  return this.__cache__[chainName] || [];\n};\n/**\n * Expose `Ruler`\n */\n\n\nmodule.exports = Ruler;","// Process *this* and _that_\n'use strict';\n\nfunction isAlphaNum(code) {\n  return code >= 0x30\n  /* 0 */\n  && code <= 0x39\n  /* 9 */\n  || code >= 0x41\n  /* A */\n  && code <= 0x5A\n  /* Z */\n  || code >= 0x61\n  /* a */\n  && code <= 0x7A\n  /* z */\n  ;\n} // parse sequence of emphasis markers,\n// \"start\" should point at a valid marker\n\n\nfunction scanDelims(state, start) {\n  var pos = start,\n      lastChar,\n      nextChar,\n      count,\n      can_open = true,\n      can_close = true,\n      max = state.posMax,\n      marker = state.src.charCodeAt(start);\n  lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1;\n\n  while (pos < max && state.src.charCodeAt(pos) === marker) {\n    pos++;\n  }\n\n  if (pos >= max) {\n    can_open = false;\n  }\n\n  count = pos - start;\n\n  if (count >= 4) {\n    // sequence of four or more unescaped markers can't start/end an emphasis\n    can_open = can_close = false;\n  } else {\n    nextChar = pos < max ? state.src.charCodeAt(pos) : -1; // check whitespace conditions\n\n    if (nextChar === 0x20 || nextChar === 0x0A) {\n      can_open = false;\n    }\n\n    if (lastChar === 0x20 || lastChar === 0x0A) {\n      can_close = false;\n    }\n\n    if (marker === 0x5F\n    /* _ */\n    ) {\n        // check if we aren't inside the word\n        if (isAlphaNum(lastChar)) {\n          can_open = false;\n        }\n\n        if (isAlphaNum(nextChar)) {\n          can_close = false;\n        }\n      }\n  }\n\n  return {\n    can_open: can_open,\n    can_close: can_close,\n    delims: count\n  };\n}\n\nmodule.exports = function emphasis(state, silent) {\n  var startCount,\n      count,\n      found,\n      oldCount,\n      newCount,\n      stack,\n      res,\n      max = state.posMax,\n      start = state.pos,\n      marker = state.src.charCodeAt(start);\n\n  if (marker !== 0x5F\n  /* _ */\n  && marker !== 0x2A\n  /* * */\n  ) {\n      return false;\n    }\n\n  if (silent) {\n    return false;\n  } // don't run any pairs in validation mode\n\n\n  res = scanDelims(state, start);\n  startCount = res.delims;\n\n  if (!res.can_open) {\n    state.pos += startCount;\n\n    if (!silent) {\n      state.pending += state.src.slice(start, state.pos);\n    }\n\n    return true;\n  }\n\n  if (state.level >= state.options.maxNesting) {\n    return false;\n  }\n\n  state.pos = start + startCount;\n  stack = [startCount];\n\n  while (state.pos < max) {\n    if (state.src.charCodeAt(state.pos) === marker) {\n      res = scanDelims(state, state.pos);\n      count = res.delims;\n\n      if (res.can_close) {\n        oldCount = stack.pop();\n        newCount = count;\n\n        while (oldCount !== newCount) {\n          if (newCount < oldCount) {\n            stack.push(oldCount - newCount);\n            break;\n          } // assert(newCount > oldCount)\n\n\n          newCount -= oldCount;\n\n          if (stack.length === 0) {\n            break;\n          }\n\n          state.pos += oldCount;\n          oldCount = stack.pop();\n        }\n\n        if (stack.length === 0) {\n          startCount = oldCount;\n          found = true;\n          break;\n        }\n\n        state.pos += count;\n        continue;\n      }\n\n      if (res.can_open) {\n        stack.push(count);\n      }\n\n      state.pos += count;\n      continue;\n    }\n\n    state.parser.skipToken(state);\n  }\n\n  if (!found) {\n    // parser failed to find ending tag, so it's not valid emphasis\n    state.pos = start;\n    return false;\n  } // found!\n\n\n  state.posMax = state.pos;\n  state.pos = start + startCount;\n\n  if (!silent) {\n    if (startCount === 2 || startCount === 3) {\n      state.push({\n        type: 'strong_open',\n        level: state.level++\n      });\n    }\n\n    if (startCount === 1 || startCount === 3) {\n      state.push({\n        type: 'em_open',\n        level: state.level++\n      });\n    }\n\n    state.parser.tokenize(state);\n\n    if (startCount === 1 || startCount === 3) {\n      state.push({\n        type: 'em_close',\n        level: --state.level\n      });\n    }\n\n    if (startCount === 2 || startCount === 3) {\n      state.push({\n        type: 'strong_close',\n        level: --state.level\n      });\n    }\n  }\n\n  state.pos = state.posMax + startCount;\n  state.posMax = max;\n  return true;\n};","'use strict';\n\nmodule.exports = function normalizeReference(str) {\n  // use .toUpperCase() instead of .toLowerCase()\n  // here to avoid a conflict with Object.prototype\n  // members (most notably, `__proto__`)\n  return str.trim().replace(/\\s+/g, ' ').toUpperCase();\n};","// Process ~~deleted text~~\n'use strict';\n\nmodule.exports = function del(state, silent) {\n  var found,\n      pos,\n      stack,\n      max = state.posMax,\n      start = state.pos,\n      lastChar,\n      nextChar;\n\n  if (state.src.charCodeAt(start) !== 0x7E\n  /* ~ */\n  ) {\n      return false;\n    }\n\n  if (silent) {\n    return false;\n  } // don't run any pairs in validation mode\n\n\n  if (start + 4 >= max) {\n    return false;\n  }\n\n  if (state.src.charCodeAt(start + 1) !== 0x7E\n  /* ~ */\n  ) {\n      return false;\n    }\n\n  if (state.level >= state.options.maxNesting) {\n    return false;\n  }\n\n  lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1;\n  nextChar = state.src.charCodeAt(start + 2);\n\n  if (lastChar === 0x7E\n  /* ~ */\n  ) {\n      return false;\n    }\n\n  if (nextChar === 0x7E\n  /* ~ */\n  ) {\n      return false;\n    }\n\n  if (nextChar === 0x20 || nextChar === 0x0A) {\n    return false;\n  }\n\n  pos = start + 2;\n\n  while (pos < max && state.src.charCodeAt(pos) === 0x7E\n  /* ~ */\n  ) {\n    pos++;\n  }\n\n  if (pos > start + 3) {\n    // sequence of 4+ markers taking as literal, same as in a emphasis\n    state.pos += pos - start;\n\n    if (!silent) {\n      state.pending += state.src.slice(start, pos);\n    }\n\n    return true;\n  }\n\n  state.pos = start + 2;\n  stack = 1;\n\n  while (state.pos + 1 < max) {\n    if (state.src.charCodeAt(state.pos) === 0x7E\n    /* ~ */\n    ) {\n        if (state.src.charCodeAt(state.pos + 1) === 0x7E\n        /* ~ */\n        ) {\n            lastChar = state.src.charCodeAt(state.pos - 1);\n            nextChar = state.pos + 2 < max ? state.src.charCodeAt(state.pos + 2) : -1;\n\n            if (nextChar !== 0x7E\n            /* ~ */\n            && lastChar !== 0x7E\n            /* ~ */\n            ) {\n                if (lastChar !== 0x20 && lastChar !== 0x0A) {\n                  // closing '~~'\n                  stack--;\n                } else if (nextChar !== 0x20 && nextChar !== 0x0A) {\n                  // opening '~~'\n                  stack++;\n                } // else {\n                //  // standalone ' ~~ ' indented with spaces\n                // }\n\n\n                if (stack <= 0) {\n                  found = true;\n                  break;\n                }\n              }\n          }\n      }\n\n    state.parser.skipToken(state);\n  }\n\n  if (!found) {\n    // parser failed to find ending tag, so it's not valid emphasis\n    state.pos = start;\n    return false;\n  } // found!\n\n\n  state.posMax = state.pos;\n  state.pos = start + 2;\n\n  if (!silent) {\n    state.push({\n      type: 'del_open',\n      level: state.level++\n    });\n    state.parser.tokenize(state);\n    state.push({\n      type: 'del_close',\n      level: --state.level\n    });\n  }\n\n  state.pos = state.posMax + 2;\n  state.posMax = max;\n  return true;\n};","// Parser state class\n'use strict';\n\nfunction StateBlock(src, parser, options, env, tokens) {\n  var ch, s, start, pos, len, indent, indent_found;\n  this.src = src; // Shortcuts to simplify nested calls\n\n  this.parser = parser;\n  this.options = options;\n  this.env = env; //\n  // Internal state vartiables\n  //\n\n  this.tokens = tokens;\n  this.bMarks = []; // line begin offsets for fast jumps\n\n  this.eMarks = []; // line end offsets for fast jumps\n\n  this.tShift = []; // indent for each line\n  // block parser variables\n\n  this.blkIndent = 0; // required block content indent\n  // (for example, if we are in list)\n\n  this.line = 0; // line index in src\n\n  this.lineMax = 0; // lines count\n\n  this.tight = false; // loose/tight mode for lists\n\n  this.parentType = 'root'; // if `list`, block parser stops on two newlines\n\n  this.ddIndent = -1; // indent of the current dd block (-1 if there isn't any)\n\n  this.level = 0; // renderer\n\n  this.result = ''; // Create caches\n  // Generate markers.\n\n  s = this.src;\n  indent = 0;\n  indent_found = false;\n\n  for (start = pos = indent = 0, len = s.length; pos < len; pos++) {\n    ch = s.charCodeAt(pos);\n\n    if (!indent_found) {\n      if (ch === 0x20\n      /* space */\n      ) {\n          indent++;\n          continue;\n        } else {\n        indent_found = true;\n      }\n    }\n\n    if (ch === 0x0A || pos === len - 1) {\n      if (ch !== 0x0A) {\n        pos++;\n      }\n\n      this.bMarks.push(start);\n      this.eMarks.push(pos);\n      this.tShift.push(indent);\n      indent_found = false;\n      indent = 0;\n      start = pos + 1;\n    }\n  } // Push fake entry to simplify cache bounds checks\n\n\n  this.bMarks.push(s.length);\n  this.eMarks.push(s.length);\n  this.tShift.push(0);\n  this.lineMax = this.bMarks.length - 1; // don't count last fake line\n}\n\nStateBlock.prototype.isEmpty = function isEmpty(line) {\n  return this.bMarks[line] + this.tShift[line] >= this.eMarks[line];\n};\n\nStateBlock.prototype.skipEmptyLines = function skipEmptyLines(from) {\n  for (var max = this.lineMax; from < max; from++) {\n    if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) {\n      break;\n    }\n  }\n\n  return from;\n}; // Skip spaces from given position.\n\n\nStateBlock.prototype.skipSpaces = function skipSpaces(pos) {\n  for (var max = this.src.length; pos < max; pos++) {\n    if (this.src.charCodeAt(pos) !== 0x20\n    /* space */\n    ) {\n        break;\n      }\n  }\n\n  return pos;\n}; // Skip char codes from given position\n\n\nStateBlock.prototype.skipChars = function skipChars(pos, code) {\n  for (var max = this.src.length; pos < max; pos++) {\n    if (this.src.charCodeAt(pos) !== code) {\n      break;\n    }\n  }\n\n  return pos;\n}; // Skip char codes reverse from given position - 1\n\n\nStateBlock.prototype.skipCharsBack = function skipCharsBack(pos, code, min) {\n  if (pos <= min) {\n    return pos;\n  }\n\n  while (pos > min) {\n    if (code !== this.src.charCodeAt(--pos)) {\n      return pos + 1;\n    }\n  }\n\n  return pos;\n}; // cut lines range from source.\n\n\nStateBlock.prototype.getLines = function getLines(begin, end, indent, keepLastLF) {\n  var i,\n      first,\n      last,\n      queue,\n      shift,\n      line = begin;\n\n  if (begin >= end) {\n    return '';\n  } // Opt: don't use push queue for single line;\n\n\n  if (line + 1 === end) {\n    first = this.bMarks[line] + Math.min(this.tShift[line], indent);\n    last = keepLastLF ? this.eMarks[line] + 1 : this.eMarks[line];\n    return this.src.slice(first, last);\n  }\n\n  queue = new Array(end - begin);\n\n  for (i = 0; line < end; line++, i++) {\n    shift = this.tShift[line];\n\n    if (shift > indent) {\n      shift = indent;\n    }\n\n    if (shift < 0) {\n      shift = 0;\n    }\n\n    first = this.bMarks[line] + shift;\n\n    if (line + 1 < end || keepLastLF) {\n      // No need for bounds check because we have fake entry on tail.\n      last = this.eMarks[line] + 1;\n    } else {\n      last = this.eMarks[line];\n    }\n\n    queue[i] = this.src.slice(first, last);\n  }\n\n  return queue.join('');\n};\n\nmodule.exports = StateBlock;","// Horizontal rule\n'use strict';\n\nmodule.exports = function hr(state, startLine, endLine, silent) {\n  var marker,\n      cnt,\n      ch,\n      pos = state.bMarks[startLine],\n      max = state.eMarks[startLine];\n  pos += state.tShift[startLine];\n\n  if (pos > max) {\n    return false;\n  }\n\n  marker = state.src.charCodeAt(pos++); // Check hr marker\n\n  if (marker !== 0x2A\n  /* * */\n  && marker !== 0x2D\n  /* - */\n  && marker !== 0x5F\n  /* _ */\n  ) {\n      return false;\n    } // markers can be mixed with spaces, but there should be at least 3 one\n\n\n  cnt = 1;\n\n  while (pos < max) {\n    ch = state.src.charCodeAt(pos++);\n\n    if (ch !== marker && ch !== 0x20\n    /* space */\n    ) {\n        return false;\n      }\n\n    if (ch === marker) {\n      cnt++;\n    }\n  }\n\n  if (cnt < 3) {\n    return false;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  state.line = startLine + 1;\n  state.tokens.push({\n    type: 'hr',\n    lines: [startLine, state.line],\n    level: state.level\n  });\n  return true;\n};","// Proceess '\\n'\n'use strict';\n\nmodule.exports = function newline(state, silent) {\n  var pmax,\n      max,\n      pos = state.pos;\n\n  if (state.src.charCodeAt(pos) !== 0x0A\n  /* \\n */\n  ) {\n      return false;\n    }\n\n  pmax = state.pending.length - 1;\n  max = state.posMax; // '  \\n' -> hardbreak\n  // Lookup in pending chars is bad practice! Don't copy to other rules!\n  // Pending string is stored in concat mode, indexed lookups will cause\n  // convertion to flat mode.\n\n  if (!silent) {\n    if (pmax >= 0 && state.pending.charCodeAt(pmax) === 0x20) {\n      if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 0x20) {\n        // Strip out all trailing spaces on this line.\n        for (var i = pmax - 2; i >= 0; i--) {\n          if (state.pending.charCodeAt(i) !== 0x20) {\n            state.pending = state.pending.substring(0, i + 1);\n            break;\n          }\n        }\n\n        state.push({\n          type: 'hardbreak',\n          level: state.level\n        });\n      } else {\n        state.pending = state.pending.slice(0, -1);\n        state.push({\n          type: 'softbreak',\n          level: state.level\n        });\n      }\n    } else {\n      state.push({\n        type: 'softbreak',\n        level: state.level\n      });\n    }\n  }\n\n  pos++; // skip heading spaces for next line\n\n  while (pos < max && state.src.charCodeAt(pos) === 0x20) {\n    pos++;\n  }\n\n  state.pos = pos;\n  return true;\n};","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};","// Process inline footnotes (^[...])\n'use strict';\n\nvar parseLinkLabel = require('../helpers/parse_link_label');\n\nmodule.exports = function footnote_inline(state, silent) {\n  var labelStart,\n      labelEnd,\n      footnoteId,\n      oldLength,\n      max = state.posMax,\n      start = state.pos;\n\n  if (start + 2 >= max) {\n    return false;\n  }\n\n  if (state.src.charCodeAt(start) !== 0x5E\n  /* ^ */\n  ) {\n      return false;\n    }\n\n  if (state.src.charCodeAt(start + 1) !== 0x5B\n  /* [ */\n  ) {\n      return false;\n    }\n\n  if (state.level >= state.options.maxNesting) {\n    return false;\n  }\n\n  labelStart = start + 2;\n  labelEnd = parseLinkLabel(state, start + 1); // parser failed to find ']', so it's not a valid note\n\n  if (labelEnd < 0) {\n    return false;\n  } // We found the end of the link, and know for a fact it's a valid link;\n  // so all that's left to do is to call tokenizer.\n  //\n\n\n  if (!silent) {\n    if (!state.env.footnotes) {\n      state.env.footnotes = {};\n    }\n\n    if (!state.env.footnotes.list) {\n      state.env.footnotes.list = [];\n    }\n\n    footnoteId = state.env.footnotes.list.length;\n    state.pos = labelStart;\n    state.posMax = labelEnd;\n    state.push({\n      type: 'footnote_ref',\n      id: footnoteId,\n      level: state.level\n    });\n    state.linkLevel++;\n    oldLength = state.tokens.length;\n    state.parser.tokenize(state);\n    state.env.footnotes.list[footnoteId] = {\n      tokens: state.tokens.splice(oldLength)\n    };\n    state.linkLevel--;\n  }\n\n  state.pos = labelEnd + 1;\n  state.posMax = max;\n  return true;\n};","var fails = require('../internals/fails');\nvar whitespaces = require('../internals/whitespaces');\n\nvar non = '\\u200B\\u0085\\u180E';\n\n// check that a method works with the correct list\n// of whitespaces and has a correct name\nmodule.exports = function (METHOD_NAME) {\n  return fails(function () {\n    return !!whitespaces[METHOD_NAME]() || non[METHOD_NAME]() != non || whitespaces[METHOD_NAME].name !== METHOD_NAME;\n  });\n};\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * @emails react-core\n * @flow\n */\n\nimport {urlRoot} from 'site-constants';\n\nexport default (slug: string): string | null =>\n  slug == null ? null : `${urlRoot}/${slug.replace(/^\\//, '')}`;\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * @emails react-core\n */\n\nimport {Link} from 'gatsby';\nimport React from 'react';\nimport {colors, media} from 'theme';\n\nconst ArrowSvg = ({cssProps = {}}) => (\n  <svg\n    css={cssProps}\n    height=\"12\"\n    xmlns=\"http://www.w3.org/2000/svg\"\n    viewBox=\"0 0 4.53657 8.69699\">\n    <path\n      d={`\n        M.18254,8.697a.18149.18149,0,0,1-.12886-.31034L4.09723,4.34126.05369.29954a.18149.18149,\n        0,0,1,.2559-.2559L4.4838,4.21785a.18149.18149,0,0,1,0,.2559L.30958,8.648A.18149.18149,\n        0,0,1,.18254,8.697Z\n      `}\n      fill=\"currentColor\"\n    />\n  </svg>\n);\n\nconst ButtonLink = ({children, type, ...rest}) => {\n  let typeStyle;\n  switch (type) {\n    case 'primary':\n      typeStyle = primaryStyle;\n      break;\n    case 'secondary':\n      typeStyle = secondaryStyle;\n      break;\n  }\n\n  return (\n    <Link {...rest} css={[style, typeStyle]}>\n      {children}\n      {type === 'secondary' && <ArrowSvg cssProps={{marginLeft: 10}} />}\n    </Link>\n  );\n};\n\nconst style = {\n  display: 'inline-block',\n  fontSize: 16,\n\n  [media.greaterThan('xlarge')]: {\n    fontSize: 20,\n  },\n};\n\nconst primaryStyle = {\n  backgroundColor: colors.brand,\n  color: colors.black,\n  padding: '10px 25px',\n  whiteSpace: 'nowrap',\n  transition: 'background-color 0.2s ease-out',\n\n  [media.greaterThan('xlarge')]: {\n    paddingTop: 15,\n    paddingBottom: 15,\n  },\n\n  ':hover': {\n    backgroundColor: colors.white,\n  },\n};\n\nconst secondaryStyle = {\n  color: colors.brand,\n  transition: 'color 0.2s ease-out',\n\n  ':hover': {\n    color: colors.white,\n  },\n};\n\nexport default ButtonLink;\n","// heading (#, ##, ...)\n'use strict';\n\nmodule.exports = function heading(state, startLine, endLine, silent) {\n  var ch,\n      level,\n      tmp,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  if (pos >= max) {\n    return false;\n  }\n\n  ch = state.src.charCodeAt(pos);\n\n  if (ch !== 0x23\n  /* # */\n  || pos >= max) {\n    return false;\n  } // count heading level\n\n\n  level = 1;\n  ch = state.src.charCodeAt(++pos);\n\n  while (ch === 0x23\n  /* # */\n  && pos < max && level <= 6) {\n    level++;\n    ch = state.src.charCodeAt(++pos);\n  }\n\n  if (level > 6 || pos < max && ch !== 0x20\n  /* space */\n  ) {\n    return false;\n  }\n\n  if (silent) {\n    return true;\n  } // Let's cut tails like '    ###  ' from the end of string\n\n\n  max = state.skipCharsBack(max, 0x20, pos); // space\n\n  tmp = state.skipCharsBack(max, 0x23, pos); // #\n\n  if (tmp > pos && state.src.charCodeAt(tmp - 1) === 0x20\n  /* space */\n  ) {\n      max = tmp;\n    }\n\n  state.line = startLine + 1;\n  state.tokens.push({\n    type: 'heading_open',\n    hLevel: level,\n    lines: [startLine, state.line],\n    level: state.level\n  }); // only if header is not empty\n\n  if (pos < max) {\n    state.tokens.push({\n      type: 'inline',\n      content: state.src.slice(pos, max).trim(),\n      level: state.level + 1,\n      lines: [startLine, state.line],\n      children: []\n    });\n  }\n\n  state.tokens.push({\n    type: 'heading_close',\n    hLevel: level,\n    level: state.level\n  });\n  return true;\n};","// Process html entity - &#123;, &#xAF;, &quot;, ...\n'use strict';\n\nvar entities = require('../common/entities');\n\nvar has = require('../common/utils').has;\n\nvar isValidEntityCode = require('../common/utils').isValidEntityCode;\n\nvar fromCodePoint = require('../common/utils').fromCodePoint;\n\nvar DIGITAL_RE = /^&#((?:x[a-f0-9]{1,8}|[0-9]{1,8}));/i;\nvar NAMED_RE = /^&([a-z][a-z0-9]{1,31});/i;\n\nmodule.exports = function entity(state, silent) {\n  var ch,\n      code,\n      match,\n      pos = state.pos,\n      max = state.posMax;\n\n  if (state.src.charCodeAt(pos) !== 0x26\n  /* & */\n  ) {\n      return false;\n    }\n\n  if (pos + 1 < max) {\n    ch = state.src.charCodeAt(pos + 1);\n\n    if (ch === 0x23\n    /* # */\n    ) {\n        match = state.src.slice(pos).match(DIGITAL_RE);\n\n        if (match) {\n          if (!silent) {\n            code = match[1][0].toLowerCase() === 'x' ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10);\n            state.pending += isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(0xFFFD);\n          }\n\n          state.pos += match[0].length;\n          return true;\n        }\n      } else {\n      match = state.src.slice(pos).match(NAMED_RE);\n\n      if (match) {\n        if (has(entities, match[1])) {\n          if (!silent) {\n            state.pending += entities[match[1]];\n          }\n\n          state.pos += match[0].length;\n          return true;\n        }\n      }\n    }\n  }\n\n  if (!silent) {\n    state.pending += '&';\n  }\n\n  state.pos++;\n  return true;\n};","// Process ~subscript~\n'use strict'; // same as UNESCAPE_MD_RE plus a space\n\nvar UNESCAPE_RE = /\\\\([ \\\\!\"#$%&'()*+,.\\/:;<=>?@[\\]^_`{|}~-])/g;\n\nmodule.exports = function sub(state, silent) {\n  var found,\n      content,\n      max = state.posMax,\n      start = state.pos;\n\n  if (state.src.charCodeAt(start) !== 0x7E\n  /* ~ */\n  ) {\n      return false;\n    }\n\n  if (silent) {\n    return false;\n  } // don't run any pairs in validation mode\n\n\n  if (start + 2 >= max) {\n    return false;\n  }\n\n  if (state.level >= state.options.maxNesting) {\n    return false;\n  }\n\n  state.pos = start + 1;\n\n  while (state.pos < max) {\n    if (state.src.charCodeAt(state.pos) === 0x7E\n    /* ~ */\n    ) {\n        found = true;\n        break;\n      }\n\n    state.parser.skipToken(state);\n  }\n\n  if (!found || start + 1 === state.pos) {\n    state.pos = start;\n    return false;\n  }\n\n  content = state.src.slice(start + 1, state.pos); // don't allow unescaped spaces/newlines inside\n\n  if (content.match(/(^|[^\\\\])(\\\\\\\\)*\\s/)) {\n    state.pos = start;\n    return false;\n  } // found!\n\n\n  state.posMax = state.pos;\n  state.pos = start + 1;\n\n  if (!silent) {\n    state.push({\n      type: 'sub',\n      level: state.level,\n      content: content.replace(UNESCAPE_RE, '$1')\n    });\n  }\n\n  state.pos = state.posMax + 1;\n  state.posMax = max;\n  return true;\n};","// Process autolinks '<protocol:...>'\n'use strict';\n\nvar url_schemas = require('../common/url_schemas');\n\nvar normalizeLink = require('../helpers/normalize_link');\n/*eslint max-len:0*/\n\n\nvar EMAIL_RE = /^<([a-zA-Z0-9.!#$%&'*+\\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>/;\nvar AUTOLINK_RE = /^<([a-zA-Z.\\-]{1,25}):([^<>\\x00-\\x20]*)>/;\n\nmodule.exports = function autolink(state, silent) {\n  var tail,\n      linkMatch,\n      emailMatch,\n      url,\n      fullUrl,\n      pos = state.pos;\n\n  if (state.src.charCodeAt(pos) !== 0x3C\n  /* < */\n  ) {\n      return false;\n    }\n\n  tail = state.src.slice(pos);\n\n  if (tail.indexOf('>') < 0) {\n    return false;\n  }\n\n  linkMatch = tail.match(AUTOLINK_RE);\n\n  if (linkMatch) {\n    if (url_schemas.indexOf(linkMatch[1].toLowerCase()) < 0) {\n      return false;\n    }\n\n    url = linkMatch[0].slice(1, -1);\n    fullUrl = normalizeLink(url);\n\n    if (!state.parser.validateLink(url)) {\n      return false;\n    }\n\n    if (!silent) {\n      state.push({\n        type: 'link_open',\n        href: fullUrl,\n        level: state.level\n      });\n      state.push({\n        type: 'text',\n        content: url,\n        level: state.level + 1\n      });\n      state.push({\n        type: 'link_close',\n        level: state.level\n      });\n    }\n\n    state.pos += linkMatch[0].length;\n    return true;\n  }\n\n  emailMatch = tail.match(EMAIL_RE);\n\n  if (emailMatch) {\n    url = emailMatch[0].slice(1, -1);\n    fullUrl = normalizeLink('mailto:' + url);\n\n    if (!state.parser.validateLink(fullUrl)) {\n      return false;\n    }\n\n    if (!silent) {\n      state.push({\n        type: 'link_open',\n        href: fullUrl,\n        level: state.level\n      });\n      state.push({\n        type: 'text',\n        content: url,\n        level: state.level + 1\n      });\n      state.push({\n        type: 'link_close',\n        level: state.level\n      });\n    }\n\n    state.pos += emailMatch[0].length;\n    return true;\n  }\n\n  return false;\n};","// Process [links](<to> \"stuff\")\n'use strict';\n\nvar parseLinkLabel = require('../helpers/parse_link_label');\n\nvar parseLinkDestination = require('../helpers/parse_link_destination');\n\nvar parseLinkTitle = require('../helpers/parse_link_title');\n\nvar normalizeReference = require('../helpers/normalize_reference');\n\nmodule.exports = function links(state, silent) {\n  var labelStart,\n      labelEnd,\n      label,\n      href,\n      title,\n      pos,\n      ref,\n      code,\n      isImage = false,\n      oldPos = state.pos,\n      max = state.posMax,\n      start = state.pos,\n      marker = state.src.charCodeAt(start);\n\n  if (marker === 0x21\n  /* ! */\n  ) {\n      isImage = true;\n      marker = state.src.charCodeAt(++start);\n    }\n\n  if (marker !== 0x5B\n  /* [ */\n  ) {\n      return false;\n    }\n\n  if (state.level >= state.options.maxNesting) {\n    return false;\n  }\n\n  labelStart = start + 1;\n  labelEnd = parseLinkLabel(state, start); // parser failed to find ']', so it's not a valid link\n\n  if (labelEnd < 0) {\n    return false;\n  }\n\n  pos = labelEnd + 1;\n\n  if (pos < max && state.src.charCodeAt(pos) === 0x28\n  /* ( */\n  ) {\n      //\n      // Inline link\n      //\n      // [link](  <href>  \"title\"  )\n      //        ^^ skipping these spaces\n      pos++;\n\n      for (; pos < max; pos++) {\n        code = state.src.charCodeAt(pos);\n\n        if (code !== 0x20 && code !== 0x0A) {\n          break;\n        }\n      }\n\n      if (pos >= max) {\n        return false;\n      } // [link](  <href>  \"title\"  )\n      //          ^^^^^^ parsing link destination\n\n\n      start = pos;\n\n      if (parseLinkDestination(state, pos)) {\n        href = state.linkContent;\n        pos = state.pos;\n      } else {\n        href = '';\n      } // [link](  <href>  \"title\"  )\n      //                ^^ skipping these spaces\n\n\n      start = pos;\n\n      for (; pos < max; pos++) {\n        code = state.src.charCodeAt(pos);\n\n        if (code !== 0x20 && code !== 0x0A) {\n          break;\n        }\n      } // [link](  <href>  \"title\"  )\n      //                  ^^^^^^^ parsing link title\n\n\n      if (pos < max && start !== pos && parseLinkTitle(state, pos)) {\n        title = state.linkContent;\n        pos = state.pos; // [link](  <href>  \"title\"  )\n        //                         ^^ skipping these spaces\n\n        for (; pos < max; pos++) {\n          code = state.src.charCodeAt(pos);\n\n          if (code !== 0x20 && code !== 0x0A) {\n            break;\n          }\n        }\n      } else {\n        title = '';\n      }\n\n      if (pos >= max || state.src.charCodeAt(pos) !== 0x29\n      /* ) */\n      ) {\n          state.pos = oldPos;\n          return false;\n        }\n\n      pos++;\n    } else {\n    //\n    // Link reference\n    //\n    // do not allow nested reference links\n    if (state.linkLevel > 0) {\n      return false;\n    } // [foo]  [bar]\n    //      ^^ optional whitespace (can include newlines)\n\n\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n\n      if (code !== 0x20 && code !== 0x0A) {\n        break;\n      }\n    }\n\n    if (pos < max && state.src.charCodeAt(pos) === 0x5B\n    /* [ */\n    ) {\n        start = pos + 1;\n        pos = parseLinkLabel(state, pos);\n\n        if (pos >= 0) {\n          label = state.src.slice(start, pos++);\n        } else {\n          pos = start - 1;\n        }\n      } // covers label === '' and label === undefined\n    // (collapsed reference link and shortcut reference link respectively)\n\n\n    if (!label) {\n      if (typeof label === 'undefined') {\n        pos = labelEnd + 1;\n      }\n\n      label = state.src.slice(labelStart, labelEnd);\n    }\n\n    ref = state.env.references[normalizeReference(label)];\n\n    if (!ref) {\n      state.pos = oldPos;\n      return false;\n    }\n\n    href = ref.href;\n    title = ref.title;\n  } //\n  // We found the end of the link, and know for a fact it's a valid link;\n  // so all that's left to do is to call tokenizer.\n  //\n\n\n  if (!silent) {\n    state.pos = labelStart;\n    state.posMax = labelEnd;\n\n    if (isImage) {\n      state.push({\n        type: 'image',\n        src: href,\n        title: title,\n        alt: state.src.substr(labelStart, labelEnd - labelStart),\n        level: state.level\n      });\n    } else {\n      state.push({\n        type: 'link_open',\n        href: href,\n        title: title,\n        level: state.level++\n      });\n      state.linkLevel++;\n      state.parser.tokenize(state);\n      state.linkLevel--;\n      state.push({\n        type: 'link_close',\n        level: --state.level\n      });\n    }\n  }\n\n  state.pos = pos;\n  state.posMax = max;\n  return true;\n};","// Process footnote references ([^...])\n'use strict';\n\nmodule.exports = function footnote_ref(state, silent) {\n  var label,\n      pos,\n      footnoteId,\n      footnoteSubId,\n      max = state.posMax,\n      start = state.pos; // should be at least 4 chars - \"[^x]\"\n\n  if (start + 3 > max) {\n    return false;\n  }\n\n  if (!state.env.footnotes || !state.env.footnotes.refs) {\n    return false;\n  }\n\n  if (state.src.charCodeAt(start) !== 0x5B\n  /* [ */\n  ) {\n      return false;\n    }\n\n  if (state.src.charCodeAt(start + 1) !== 0x5E\n  /* ^ */\n  ) {\n      return false;\n    }\n\n  if (state.level >= state.options.maxNesting) {\n    return false;\n  }\n\n  for (pos = start + 2; pos < max; pos++) {\n    if (state.src.charCodeAt(pos) === 0x20) {\n      return false;\n    }\n\n    if (state.src.charCodeAt(pos) === 0x0A) {\n      return false;\n    }\n\n    if (state.src.charCodeAt(pos) === 0x5D\n    /* ] */\n    ) {\n        break;\n      }\n  }\n\n  if (pos === start + 2) {\n    return false;\n  } // no empty footnote labels\n\n\n  if (pos >= max) {\n    return false;\n  }\n\n  pos++;\n  label = state.src.slice(start + 2, pos - 1);\n\n  if (typeof state.env.footnotes.refs[':' + label] === 'undefined') {\n    return false;\n  }\n\n  if (!silent) {\n    if (!state.env.footnotes.list) {\n      state.env.footnotes.list = [];\n    }\n\n    if (state.env.footnotes.refs[':' + label] < 0) {\n      footnoteId = state.env.footnotes.list.length;\n      state.env.footnotes.list[footnoteId] = {\n        label: label,\n        count: 0\n      };\n      state.env.footnotes.refs[':' + label] = footnoteId;\n    } else {\n      footnoteId = state.env.footnotes.refs[':' + label];\n    }\n\n    footnoteSubId = state.env.footnotes.list[footnoteId].count;\n    state.env.footnotes.list[footnoteId].count++;\n    state.push({\n      type: 'footnote_ref',\n      id: footnoteId,\n      subId: footnoteSubId,\n      level: state.level\n    });\n  }\n\n  state.pos = pos;\n  state.posMax = max;\n  return true;\n};","// Parse backticks\n'use strict';\n\nmodule.exports = function backticks(state, silent) {\n  var start,\n      max,\n      marker,\n      matchStart,\n      matchEnd,\n      pos = state.pos,\n      ch = state.src.charCodeAt(pos);\n\n  if (ch !== 0x60\n  /* ` */\n  ) {\n      return false;\n    }\n\n  start = pos;\n  pos++;\n  max = state.posMax;\n\n  while (pos < max && state.src.charCodeAt(pos) === 0x60\n  /* ` */\n  ) {\n    pos++;\n  }\n\n  marker = state.src.slice(start, pos);\n  matchStart = matchEnd = pos;\n\n  while ((matchStart = state.src.indexOf('`', matchEnd)) !== -1) {\n    matchEnd = matchStart + 1;\n\n    while (matchEnd < max && state.src.charCodeAt(matchEnd) === 0x60\n    /* ` */\n    ) {\n      matchEnd++;\n    }\n\n    if (matchEnd - matchStart === marker.length) {\n      if (!silent) {\n        state.push({\n          type: 'code',\n          content: state.src.slice(pos, matchStart).replace(/[ \\n]+/g, ' ').trim(),\n          block: false,\n          level: state.level\n        });\n      }\n\n      state.pos = matchEnd;\n      return true;\n    }\n  }\n\n  if (!silent) {\n    state.pending += marker;\n  }\n\n  state.pos += marker.length;\n  return true;\n};","'use strict';\n\nexports.byteLength = byteLength;\nexports.toByteArray = toByteArray;\nexports.fromByteArray = fromByteArray;\nvar lookup = [];\nvar revLookup = [];\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i];\n  revLookup[code.charCodeAt(i)] = i;\n} // Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\n\n\nrevLookup['-'.charCodeAt(0)] = 62;\nrevLookup['_'.charCodeAt(0)] = 63;\n\nfunction getLens(b64) {\n  var len = b64.length;\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4');\n  } // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n\n\n  var validLen = b64.indexOf('=');\n  if (validLen === -1) validLen = len;\n  var placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;\n  return [validLen, placeHoldersLen];\n} // base64 is 4/3 + up to two characters of the original data\n\n\nfunction byteLength(b64) {\n  var lens = getLens(b64);\n  var validLen = lens[0];\n  var placeHoldersLen = lens[1];\n  return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;\n}\n\nfunction _byteLength(b64, validLen, placeHoldersLen) {\n  return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;\n}\n\nfunction toByteArray(b64) {\n  var tmp;\n  var lens = getLens(b64);\n  var validLen = lens[0];\n  var placeHoldersLen = lens[1];\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));\n  var curByte = 0; // if there are placeholders, only get up to the last complete 4 chars\n\n  var len = placeHoldersLen > 0 ? validLen - 4 : validLen;\n  var i;\n\n  for (i = 0; i < len; i += 4) {\n    tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];\n    arr[curByte++] = tmp >> 16 & 0xFF;\n    arr[curByte++] = tmp >> 8 & 0xFF;\n    arr[curByte++] = tmp & 0xFF;\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;\n    arr[curByte++] = tmp & 0xFF;\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;\n    arr[curByte++] = tmp >> 8 & 0xFF;\n    arr[curByte++] = tmp & 0xFF;\n  }\n\n  return arr;\n}\n\nfunction tripletToBase64(num) {\n  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F];\n}\n\nfunction encodeChunk(uint8, start, end) {\n  var tmp;\n  var output = [];\n\n  for (var i = start; i < end; i += 3) {\n    tmp = (uint8[i] << 16 & 0xFF0000) + (uint8[i + 1] << 8 & 0xFF00) + (uint8[i + 2] & 0xFF);\n    output.push(tripletToBase64(tmp));\n  }\n\n  return output.join('');\n}\n\nfunction fromByteArray(uint8) {\n  var tmp;\n  var len = uint8.length;\n  var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes\n\n  var parts = [];\n  var maxChunkLength = 16383; // must be multiple of 3\n  // go through the array every three bytes, we'll deal with trailing stuff later\n\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));\n  } // pad the end with zeros, but make sure to not forget the extra bytes\n\n\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1];\n    parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 0x3F] + '==');\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1];\n    parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 0x3F] + lookup[tmp << 2 & 0x3F] + '=');\n  }\n\n  return parts.join('');\n}","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <http://feross.org>\n * @license  MIT\n */\n\n/* eslint-disable no-proto */\n'use strict';\n\nvar base64 = require('base64-js');\n\nvar ieee754 = require('ieee754');\n\nvar isArray = require('isarray');\n\nexports.Buffer = Buffer;\nexports.SlowBuffer = SlowBuffer;\nexports.INSPECT_MAX_BYTES = 50;\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\n\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined ? global.TYPED_ARRAY_SUPPORT : typedArraySupport();\n/*\n * Export kMaxLength after typed array support is determined.\n */\n\nexports.kMaxLength = kMaxLength();\n\nfunction typedArraySupport() {\n  try {\n    var arr = new Uint8Array(1);\n    arr.__proto__ = {\n      __proto__: Uint8Array.prototype,\n      foo: function foo() {\n        return 42;\n      }\n    };\n    return arr.foo() === 42 && // typed array instances can be augmented\n    typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n    arr.subarray(1, 1).byteLength === 0; // ie10 has broken `subarray`\n  } catch (e) {\n    return false;\n  }\n}\n\nfunction kMaxLength() {\n  return Buffer.TYPED_ARRAY_SUPPORT ? 0x7fffffff : 0x3fffffff;\n}\n\nfunction createBuffer(that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length');\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length);\n    that.__proto__ = Buffer.prototype;\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length);\n    }\n\n    that.length = length;\n  }\n\n  return that;\n}\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\n\nfunction Buffer(arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length);\n  } // Common case.\n\n\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error('If encoding is specified then the first argument must be a string');\n    }\n\n    return allocUnsafe(this, arg);\n  }\n\n  return from(this, arg, encodingOrOffset, length);\n}\n\nBuffer.poolSize = 8192; // not used by this implementation\n// TODO: Legacy, not needed anymore. Remove in next major version.\n\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype;\n  return arr;\n};\n\nfunction from(that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number');\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length);\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset);\n  }\n\n  return fromObject(that, value);\n}\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\n\n\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length);\n};\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype;\n  Buffer.__proto__ = Uint8Array;\n\n  if (typeof Symbol !== 'undefined' && Symbol.species && Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    });\n  }\n}\n\nfunction assertSize(size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number');\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative');\n  }\n}\n\nfunction alloc(that, size, fill, encoding) {\n  assertSize(size);\n\n  if (size <= 0) {\n    return createBuffer(that, size);\n  }\n\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string' ? createBuffer(that, size).fill(fill, encoding) : createBuffer(that, size).fill(fill);\n  }\n\n  return createBuffer(that, size);\n}\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\n\n\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding);\n};\n\nfunction allocUnsafe(that, size) {\n  assertSize(size);\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0);\n\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0;\n    }\n  }\n\n  return that;\n}\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\n\n\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size);\n};\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\n\n\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size);\n};\n\nfunction fromString(that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8';\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding');\n  }\n\n  var length = byteLength(string, encoding) | 0;\n  that = createBuffer(that, length);\n  var actual = that.write(string, encoding);\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual);\n  }\n\n  return that;\n}\n\nfunction fromArrayLike(that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0;\n  that = createBuffer(that, length);\n\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255;\n  }\n\n  return that;\n}\n\nfunction fromArrayBuffer(that, array, byteOffset, length) {\n  array.byteLength; // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds');\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds');\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array);\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset);\n  } else {\n    array = new Uint8Array(array, byteOffset, length);\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array;\n    that.__proto__ = Buffer.prototype;\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array);\n  }\n\n  return that;\n}\n\nfunction fromObject(that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0;\n    that = createBuffer(that, len);\n\n    if (that.length === 0) {\n      return that;\n    }\n\n    obj.copy(that, 0, 0, len);\n    return that;\n  }\n\n  if (obj) {\n    if (typeof ArrayBuffer !== 'undefined' && obj.buffer instanceof ArrayBuffer || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0);\n      }\n\n      return fromArrayLike(that, obj);\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data);\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.');\n}\n\nfunction checked(length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' + 'size: 0x' + kMaxLength().toString(16) + ' bytes');\n  }\n\n  return length | 0;\n}\n\nfunction SlowBuffer(length) {\n  if (+length != length) {\n    // eslint-disable-line eqeqeq\n    length = 0;\n  }\n\n  return Buffer.alloc(+length);\n}\n\nBuffer.isBuffer = function isBuffer(b) {\n  return !!(b != null && b._isBuffer);\n};\n\nBuffer.compare = function compare(a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers');\n  }\n\n  if (a === b) return 0;\n  var x = a.length;\n  var y = b.length;\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i];\n      y = b[i];\n      break;\n    }\n  }\n\n  if (x < y) return -1;\n  if (y < x) return 1;\n  return 0;\n};\n\nBuffer.isEncoding = function isEncoding(encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true;\n\n    default:\n      return false;\n  }\n};\n\nBuffer.concat = function concat(list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers');\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0);\n  }\n\n  var i;\n\n  if (length === undefined) {\n    length = 0;\n\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length;\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length);\n  var pos = 0;\n\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i];\n\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers');\n    }\n\n    buf.copy(buffer, pos);\n    pos += buf.length;\n  }\n\n  return buffer;\n};\n\nfunction byteLength(string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length;\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength;\n  }\n\n  if (typeof string !== 'string') {\n    string = '' + string;\n  }\n\n  var len = string.length;\n  if (len === 0) return 0; // Use a for loop to avoid recursion\n\n  var loweredCase = false;\n\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len;\n\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length;\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2;\n\n      case 'hex':\n        return len >>> 1;\n\n      case 'base64':\n        return base64ToBytes(string).length;\n\n      default:\n        if (loweredCase) return utf8ToBytes(string).length; // assume utf8\n\n        encoding = ('' + encoding).toLowerCase();\n        loweredCase = true;\n    }\n  }\n}\n\nBuffer.byteLength = byteLength;\n\nfunction slowToString(encoding, start, end) {\n  var loweredCase = false; // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n\n  if (start === undefined || start < 0) {\n    start = 0;\n  } // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n\n\n  if (start > this.length) {\n    return '';\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length;\n  }\n\n  if (end <= 0) {\n    return '';\n  } // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n\n\n  end >>>= 0;\n  start >>>= 0;\n\n  if (end <= start) {\n    return '';\n  }\n\n  if (!encoding) encoding = 'utf8';\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end);\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end);\n\n      case 'ascii':\n        return asciiSlice(this, start, end);\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end);\n\n      case 'base64':\n        return base64Slice(this, start, end);\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end);\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding);\n        encoding = (encoding + '').toLowerCase();\n        loweredCase = true;\n    }\n  }\n} // The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\n\n\nBuffer.prototype._isBuffer = true;\n\nfunction swap(b, n, m) {\n  var i = b[n];\n  b[n] = b[m];\n  b[m] = i;\n}\n\nBuffer.prototype.swap16 = function swap16() {\n  var len = this.length;\n\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits');\n  }\n\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1);\n  }\n\n  return this;\n};\n\nBuffer.prototype.swap32 = function swap32() {\n  var len = this.length;\n\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits');\n  }\n\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3);\n    swap(this, i + 1, i + 2);\n  }\n\n  return this;\n};\n\nBuffer.prototype.swap64 = function swap64() {\n  var len = this.length;\n\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits');\n  }\n\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7);\n    swap(this, i + 1, i + 6);\n    swap(this, i + 2, i + 5);\n    swap(this, i + 3, i + 4);\n  }\n\n  return this;\n};\n\nBuffer.prototype.toString = function toString() {\n  var length = this.length | 0;\n  if (length === 0) return '';\n  if (arguments.length === 0) return utf8Slice(this, 0, length);\n  return slowToString.apply(this, arguments);\n};\n\nBuffer.prototype.equals = function equals(b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer');\n  if (this === b) return true;\n  return Buffer.compare(this, b) === 0;\n};\n\nBuffer.prototype.inspect = function inspect() {\n  var str = '';\n  var max = exports.INSPECT_MAX_BYTES;\n\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ');\n    if (this.length > max) str += ' ... ';\n  }\n\n  return '<Buffer ' + str + '>';\n};\n\nBuffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer');\n  }\n\n  if (start === undefined) {\n    start = 0;\n  }\n\n  if (end === undefined) {\n    end = target ? target.length : 0;\n  }\n\n  if (thisStart === undefined) {\n    thisStart = 0;\n  }\n\n  if (thisEnd === undefined) {\n    thisEnd = this.length;\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index');\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0;\n  }\n\n  if (thisStart >= thisEnd) {\n    return -1;\n  }\n\n  if (start >= end) {\n    return 1;\n  }\n\n  start >>>= 0;\n  end >>>= 0;\n  thisStart >>>= 0;\n  thisEnd >>>= 0;\n  if (this === target) return 0;\n  var x = thisEnd - thisStart;\n  var y = end - start;\n  var len = Math.min(x, y);\n  var thisCopy = this.slice(thisStart, thisEnd);\n  var targetCopy = target.slice(start, end);\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i];\n      y = targetCopy[i];\n      break;\n    }\n  }\n\n  if (x < y) return -1;\n  if (y < x) return 1;\n  return 0;\n}; // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\n\n\nfunction bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1; // Normalize byteOffset\n\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset;\n    byteOffset = 0;\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff;\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000;\n  }\n\n  byteOffset = +byteOffset; // Coerce to Number.\n\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : buffer.length - 1;\n  } // Normalize byteOffset: negative offsets start from the end of the buffer\n\n\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset;\n\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1;else byteOffset = buffer.length - 1;\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0;else return -1;\n  } // Normalize val\n\n\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding);\n  } // Finally, search either indexOf (if dir is true) or lastIndexOf\n\n\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1;\n    }\n\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir);\n  } else if (typeof val === 'number') {\n    val = val & 0xFF; // Search for a byte value [0-255]\n\n    if (Buffer.TYPED_ARRAY_SUPPORT && typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);\n      }\n    }\n\n    return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);\n  }\n\n  throw new TypeError('val must be string, number or Buffer');\n}\n\nfunction arrayIndexOf(arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1;\n  var arrLength = arr.length;\n  var valLength = val.length;\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase();\n\n    if (encoding === 'ucs2' || encoding === 'ucs-2' || encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1;\n      }\n\n      indexSize = 2;\n      arrLength /= 2;\n      valLength /= 2;\n      byteOffset /= 2;\n    }\n  }\n\n  function read(buf, i) {\n    if (indexSize === 1) {\n      return buf[i];\n    } else {\n      return buf.readUInt16BE(i * indexSize);\n    }\n  }\n\n  var i;\n\n  if (dir) {\n    var foundIndex = -1;\n\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i;\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex;\n        foundIndex = -1;\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;\n\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true;\n\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false;\n          break;\n        }\n      }\n\n      if (found) return i;\n    }\n  }\n\n  return -1;\n}\n\nBuffer.prototype.includes = function includes(val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1;\n};\n\nBuffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true);\n};\n\nBuffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false);\n};\n\nfunction hexWrite(buf, string, offset, length) {\n  offset = Number(offset) || 0;\n  var remaining = buf.length - offset;\n\n  if (!length) {\n    length = remaining;\n  } else {\n    length = Number(length);\n\n    if (length > remaining) {\n      length = remaining;\n    }\n  } // must be an even number of digits\n\n\n  var strLen = string.length;\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string');\n\n  if (length > strLen / 2) {\n    length = strLen / 2;\n  }\n\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16);\n    if (isNaN(parsed)) return i;\n    buf[offset + i] = parsed;\n  }\n\n  return i;\n}\n\nfunction utf8Write(buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);\n}\n\nfunction asciiWrite(buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length);\n}\n\nfunction latin1Write(buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length);\n}\n\nfunction base64Write(buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length);\n}\n\nfunction ucs2Write(buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);\n}\n\nBuffer.prototype.write = function write(string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8';\n    length = this.length;\n    offset = 0; // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset;\n    length = this.length;\n    offset = 0; // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0;\n\n    if (isFinite(length)) {\n      length = length | 0;\n      if (encoding === undefined) encoding = 'utf8';\n    } else {\n      encoding = length;\n      length = undefined;\n    } // legacy write(string, encoding, offset, length) - remove in v0.13\n\n  } else {\n    throw new Error('Buffer.write(string, encoding, offset[, length]) is no longer supported');\n  }\n\n  var remaining = this.length - offset;\n  if (length === undefined || length > remaining) length = remaining;\n\n  if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds');\n  }\n\n  if (!encoding) encoding = 'utf8';\n  var loweredCase = false;\n\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length);\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length);\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length);\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length);\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length);\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length);\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding);\n        encoding = ('' + encoding).toLowerCase();\n        loweredCase = true;\n    }\n  }\n};\n\nBuffer.prototype.toJSON = function toJSON() {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  };\n};\n\nfunction base64Slice(buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf);\n  } else {\n    return base64.fromByteArray(buf.slice(start, end));\n  }\n}\n\nfunction utf8Slice(buf, start, end) {\n  end = Math.min(buf.length, end);\n  var res = [];\n  var i = start;\n\n  while (i < end) {\n    var firstByte = buf[i];\n    var codePoint = null;\n    var bytesPerSequence = firstByte > 0xEF ? 4 : firstByte > 0xDF ? 3 : firstByte > 0xBF ? 2 : 1;\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint;\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte;\n          }\n\n          break;\n\n        case 2:\n          secondByte = buf[i + 1];\n\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | secondByte & 0x3F;\n\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint;\n            }\n          }\n\n          break;\n\n        case 3:\n          secondByte = buf[i + 1];\n          thirdByte = buf[i + 2];\n\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | thirdByte & 0x3F;\n\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint;\n            }\n          }\n\n          break;\n\n        case 4:\n          secondByte = buf[i + 1];\n          thirdByte = buf[i + 2];\n          fourthByte = buf[i + 3];\n\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | fourthByte & 0x3F;\n\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint;\n            }\n          }\n\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD;\n      bytesPerSequence = 1;\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000;\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800);\n      codePoint = 0xDC00 | codePoint & 0x3FF;\n    }\n\n    res.push(codePoint);\n    i += bytesPerSequence;\n  }\n\n  return decodeCodePointsArray(res);\n} // Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\n\n\nvar MAX_ARGUMENTS_LENGTH = 0x1000;\n\nfunction decodeCodePointsArray(codePoints) {\n  var len = codePoints.length;\n\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints); // avoid extra slice()\n  } // Decode in chunks to avoid \"call stack size exceeded\".\n\n\n  var res = '';\n  var i = 0;\n\n  while (i < len) {\n    res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));\n  }\n\n  return res;\n}\n\nfunction asciiSlice(buf, start, end) {\n  var ret = '';\n  end = Math.min(buf.length, end);\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F);\n  }\n\n  return ret;\n}\n\nfunction latin1Slice(buf, start, end) {\n  var ret = '';\n  end = Math.min(buf.length, end);\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i]);\n  }\n\n  return ret;\n}\n\nfunction hexSlice(buf, start, end) {\n  var len = buf.length;\n  if (!start || start < 0) start = 0;\n  if (!end || end < 0 || end > len) end = len;\n  var out = '';\n\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i]);\n  }\n\n  return out;\n}\n\nfunction utf16leSlice(buf, start, end) {\n  var bytes = buf.slice(start, end);\n  var res = '';\n\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);\n  }\n\n  return res;\n}\n\nBuffer.prototype.slice = function slice(start, end) {\n  var len = this.length;\n  start = ~~start;\n  end = end === undefined ? len : ~~end;\n\n  if (start < 0) {\n    start += len;\n    if (start < 0) start = 0;\n  } else if (start > len) {\n    start = len;\n  }\n\n  if (end < 0) {\n    end += len;\n    if (end < 0) end = 0;\n  } else if (end > len) {\n    end = len;\n  }\n\n  if (end < start) end = start;\n  var newBuf;\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end);\n    newBuf.__proto__ = Buffer.prototype;\n  } else {\n    var sliceLen = end - start;\n    newBuf = new Buffer(sliceLen, undefined);\n\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start];\n    }\n  }\n\n  return newBuf;\n};\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\n\n\nfunction checkOffset(offset, ext, length) {\n  if (offset % 1 !== 0 || offset < 0) throw new RangeError('offset is not uint');\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length');\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n  if (!noAssert) checkOffset(offset, byteLength, this.length);\n  var val = this[offset];\n  var mul = 1;\n  var i = 0;\n\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul;\n  }\n\n  return val;\n};\n\nBuffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length);\n  }\n\n  var val = this[offset + --byteLength];\n  var mul = 1;\n\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul;\n  }\n\n  return val;\n};\n\nBuffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length);\n  return this[offset];\n};\n\nBuffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length);\n  return this[offset] | this[offset + 1] << 8;\n};\n\nBuffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length);\n  return this[offset] << 8 | this[offset + 1];\n};\n\nBuffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 0x1000000;\n};\n\nBuffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return this[offset] * 0x1000000 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);\n};\n\nBuffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n  if (!noAssert) checkOffset(offset, byteLength, this.length);\n  var val = this[offset];\n  var mul = 1;\n  var i = 0;\n\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul;\n  }\n\n  mul *= 0x80;\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength);\n  return val;\n};\n\nBuffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n  if (!noAssert) checkOffset(offset, byteLength, this.length);\n  var i = byteLength;\n  var mul = 1;\n  var val = this[offset + --i];\n\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul;\n  }\n\n  mul *= 0x80;\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength);\n  return val;\n};\n\nBuffer.prototype.readInt8 = function readInt8(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length);\n  if (!(this[offset] & 0x80)) return this[offset];\n  return (0xff - this[offset] + 1) * -1;\n};\n\nBuffer.prototype.readInt16LE = function readInt16LE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length);\n  var val = this[offset] | this[offset + 1] << 8;\n  return val & 0x8000 ? val | 0xFFFF0000 : val;\n};\n\nBuffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length);\n  var val = this[offset + 1] | this[offset] << 8;\n  return val & 0x8000 ? val | 0xFFFF0000 : val;\n};\n\nBuffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;\n};\n\nBuffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];\n};\n\nBuffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return ieee754.read(this, offset, true, 23, 4);\n};\n\nBuffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return ieee754.read(this, offset, false, 23, 4);\n};\n\nBuffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length);\n  return ieee754.read(this, offset, true, 52, 8);\n};\n\nBuffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length);\n  return ieee754.read(this, offset, false, 52, 8);\n};\n\nfunction checkInt(buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance');\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds');\n  if (offset + ext > buf.length) throw new RangeError('Index out of range');\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1;\n    checkInt(this, value, offset, byteLength, maxBytes, 0);\n  }\n\n  var mul = 1;\n  var i = 0;\n  this[offset] = value & 0xFF;\n\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = value / mul & 0xFF;\n  }\n\n  return offset + byteLength;\n};\n\nBuffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  byteLength = byteLength | 0;\n\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1;\n    checkInt(this, value, offset, byteLength, maxBytes, 0);\n  }\n\n  var i = byteLength - 1;\n  var mul = 1;\n  this[offset + i] = value & 0xFF;\n\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = value / mul & 0xFF;\n  }\n\n  return offset + byteLength;\n};\n\nBuffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);\n  this[offset] = value & 0xff;\n  return offset + 1;\n};\n\nfunction objectWriteUInt16(buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1;\n\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & 0xff << 8 * (littleEndian ? i : 1 - i)) >>> (littleEndian ? i : 1 - i) * 8;\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value & 0xff;\n    this[offset + 1] = value >>> 8;\n  } else {\n    objectWriteUInt16(this, value, offset, true);\n  }\n\n  return offset + 2;\n};\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value >>> 8;\n    this[offset + 1] = value & 0xff;\n  } else {\n    objectWriteUInt16(this, value, offset, false);\n  }\n\n  return offset + 2;\n};\n\nfunction objectWriteUInt32(buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1;\n\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = value >>> (littleEndian ? i : 3 - i) * 8 & 0xff;\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = value >>> 24;\n    this[offset + 2] = value >>> 16;\n    this[offset + 1] = value >>> 8;\n    this[offset] = value & 0xff;\n  } else {\n    objectWriteUInt32(this, value, offset, true);\n  }\n\n  return offset + 4;\n};\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value >>> 24;\n    this[offset + 1] = value >>> 16;\n    this[offset + 2] = value >>> 8;\n    this[offset + 3] = value & 0xff;\n  } else {\n    objectWriteUInt32(this, value, offset, false);\n  }\n\n  return offset + 4;\n};\n\nBuffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {\n  value = +value;\n  offset = offset | 0;\n\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1);\n    checkInt(this, value, offset, byteLength, limit - 1, -limit);\n  }\n\n  var i = 0;\n  var mul = 1;\n  var sub = 0;\n  this[offset] = value & 0xFF;\n\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1;\n    }\n\n    this[offset + i] = (value / mul >> 0) - sub & 0xFF;\n  }\n\n  return offset + byteLength;\n};\n\nBuffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {\n  value = +value;\n  offset = offset | 0;\n\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1);\n    checkInt(this, value, offset, byteLength, limit - 1, -limit);\n  }\n\n  var i = byteLength - 1;\n  var mul = 1;\n  var sub = 0;\n  this[offset + i] = value & 0xFF;\n\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1;\n    }\n\n    this[offset + i] = (value / mul >> 0) - sub & 0xFF;\n  }\n\n  return offset + byteLength;\n};\n\nBuffer.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80);\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);\n  if (value < 0) value = 0xff + value + 1;\n  this[offset] = value & 0xff;\n  return offset + 1;\n};\n\nBuffer.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value & 0xff;\n    this[offset + 1] = value >>> 8;\n  } else {\n    objectWriteUInt16(this, value, offset, true);\n  }\n\n  return offset + 2;\n};\n\nBuffer.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value >>> 8;\n    this[offset + 1] = value & 0xff;\n  } else {\n    objectWriteUInt16(this, value, offset, false);\n  }\n\n  return offset + 2;\n};\n\nBuffer.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value & 0xff;\n    this[offset + 1] = value >>> 8;\n    this[offset + 2] = value >>> 16;\n    this[offset + 3] = value >>> 24;\n  } else {\n    objectWriteUInt32(this, value, offset, true);\n  }\n\n  return offset + 4;\n};\n\nBuffer.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {\n  value = +value;\n  offset = offset | 0;\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);\n  if (value < 0) value = 0xffffffff + value + 1;\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value >>> 24;\n    this[offset + 1] = value >>> 16;\n    this[offset + 2] = value >>> 8;\n    this[offset + 3] = value & 0xff;\n  } else {\n    objectWriteUInt32(this, value, offset, false);\n  }\n\n  return offset + 4;\n};\n\nfunction checkIEEE754(buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range');\n  if (offset < 0) throw new RangeError('Index out of range');\n}\n\nfunction writeFloat(buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38);\n  }\n\n  ieee754.write(buf, value, offset, littleEndian, 23, 4);\n  return offset + 4;\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert);\n};\n\nBuffer.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert);\n};\n\nfunction writeDouble(buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308);\n  }\n\n  ieee754.write(buf, value, offset, littleEndian, 52, 8);\n  return offset + 8;\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert);\n};\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert);\n}; // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\n\n\nBuffer.prototype.copy = function copy(target, targetStart, start, end) {\n  if (!start) start = 0;\n  if (!end && end !== 0) end = this.length;\n  if (targetStart >= target.length) targetStart = target.length;\n  if (!targetStart) targetStart = 0;\n  if (end > 0 && end < start) end = start; // Copy 0 bytes; we're done\n\n  if (end === start) return 0;\n  if (target.length === 0 || this.length === 0) return 0; // Fatal error conditions\n\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds');\n  }\n\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds');\n  if (end < 0) throw new RangeError('sourceEnd out of bounds'); // Are we oob?\n\n  if (end > this.length) end = this.length;\n\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start;\n  }\n\n  var len = end - start;\n  var i;\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start];\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start];\n    }\n  } else {\n    Uint8Array.prototype.set.call(target, this.subarray(start, start + len), targetStart);\n  }\n\n  return len;\n}; // Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\n\n\nBuffer.prototype.fill = function fill(val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start;\n      start = 0;\n      end = this.length;\n    } else if (typeof end === 'string') {\n      encoding = end;\n      end = this.length;\n    }\n\n    if (val.length === 1) {\n      var code = val.charCodeAt(0);\n\n      if (code < 256) {\n        val = code;\n      }\n    }\n\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string');\n    }\n\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding);\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255;\n  } // Invalid ranges are not set to a default, so can range check early.\n\n\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index');\n  }\n\n  if (end <= start) {\n    return this;\n  }\n\n  start = start >>> 0;\n  end = end === undefined ? this.length : end >>> 0;\n  if (!val) val = 0;\n  var i;\n\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val;\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val) ? val : utf8ToBytes(new Buffer(val, encoding).toString());\n    var len = bytes.length;\n\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len];\n    }\n  }\n\n  return this;\n}; // HELPER FUNCTIONS\n// ================\n\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g;\n\nfunction base64clean(str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, ''); // Node converts strings with length < 2 to ''\n\n  if (str.length < 2) return ''; // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n\n  while (str.length % 4 !== 0) {\n    str = str + '=';\n  }\n\n  return str;\n}\n\nfunction stringtrim(str) {\n  if (str.trim) return str.trim();\n  return str.replace(/^\\s+|\\s+$/g, '');\n}\n\nfunction toHex(n) {\n  if (n < 16) return '0' + n.toString(16);\n  return n.toString(16);\n}\n\nfunction utf8ToBytes(string, units) {\n  units = units || Infinity;\n  var codePoint;\n  var length = string.length;\n  var leadSurrogate = null;\n  var bytes = [];\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i); // is surrogate component\n\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n          continue;\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n          continue;\n        } // valid lead\n\n\n        leadSurrogate = codePoint;\n        continue;\n      } // 2 leads in a row\n\n\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n        leadSurrogate = codePoint;\n        continue;\n      } // valid surrogate pair\n\n\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000;\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n    }\n\n    leadSurrogate = null; // encode utf8\n\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break;\n      bytes.push(codePoint);\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break;\n      bytes.push(codePoint >> 0x6 | 0xC0, codePoint & 0x3F | 0x80);\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break;\n      bytes.push(codePoint >> 0xC | 0xE0, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break;\n      bytes.push(codePoint >> 0x12 | 0xF0, codePoint >> 0xC & 0x3F | 0x80, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);\n    } else {\n      throw new Error('Invalid code point');\n    }\n  }\n\n  return bytes;\n}\n\nfunction asciiToBytes(str) {\n  var byteArray = [];\n\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF);\n  }\n\n  return byteArray;\n}\n\nfunction utf16leToBytes(str, units) {\n  var c, hi, lo;\n  var byteArray = [];\n\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break;\n    c = str.charCodeAt(i);\n    hi = c >> 8;\n    lo = c % 256;\n    byteArray.push(lo);\n    byteArray.push(hi);\n  }\n\n  return byteArray;\n}\n\nfunction base64ToBytes(str) {\n  return base64.toByteArray(base64clean(str));\n}\n\nfunction blitBuffer(src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if (i + offset >= dst.length || i >= src.length) break;\n    dst[i + offset] = src[i];\n  }\n\n  return i;\n}\n\nfunction isnan(val) {\n  return val !== val; // eslint-disable-line no-self-compare\n}","'use strict';\n\nvar StateInline = require('../rules_inline/state_inline');\n\nvar parseLinkLabel = require('../helpers/parse_link_label');\n\nvar parseLinkDestination = require('../helpers/parse_link_destination');\n\nvar parseLinkTitle = require('../helpers/parse_link_title');\n\nvar normalizeReference = require('../helpers/normalize_reference');\n\nfunction parseReference(str, parser, options, env) {\n  var state, labelEnd, pos, max, code, start, href, title, label;\n\n  if (str.charCodeAt(0) !== 0x5B\n  /* [ */\n  ) {\n      return -1;\n    }\n\n  if (str.indexOf(']:') === -1) {\n    return -1;\n  }\n\n  state = new StateInline(str, parser, options, env, []);\n  labelEnd = parseLinkLabel(state, 0);\n\n  if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A\n  /* : */\n  ) {\n      return -1;\n    }\n\n  max = state.posMax; // [label]:   destination   'title'\n  //         ^^^ skip optional whitespace here\n\n  for (pos = labelEnd + 2; pos < max; pos++) {\n    code = state.src.charCodeAt(pos);\n\n    if (code !== 0x20 && code !== 0x0A) {\n      break;\n    }\n  } // [label]:   destination   'title'\n  //            ^^^^^^^^^^^ parse this\n\n\n  if (!parseLinkDestination(state, pos)) {\n    return -1;\n  }\n\n  href = state.linkContent;\n  pos = state.pos; // [label]:   destination   'title'\n  //                       ^^^ skipping those spaces\n\n  start = pos;\n\n  for (pos = pos + 1; pos < max; pos++) {\n    code = state.src.charCodeAt(pos);\n\n    if (code !== 0x20 && code !== 0x0A) {\n      break;\n    }\n  } // [label]:   destination   'title'\n  //                          ^^^^^^^ parse this\n\n\n  if (pos < max && start !== pos && parseLinkTitle(state, pos)) {\n    title = state.linkContent;\n    pos = state.pos;\n  } else {\n    title = '';\n    pos = start;\n  } // ensure that the end of the line is empty\n\n\n  while (pos < max && state.src.charCodeAt(pos) === 0x20\n  /* space */\n  ) {\n    pos++;\n  }\n\n  if (pos < max && state.src.charCodeAt(pos) !== 0x0A) {\n    return -1;\n  }\n\n  label = normalizeReference(str.slice(1, labelEnd));\n\n  if (typeof env.references[label] === 'undefined') {\n    env.references[label] = {\n      title: title,\n      href: href\n    };\n  }\n\n  return pos;\n}\n\nmodule.exports = function references(state) {\n  var tokens = state.tokens,\n      i,\n      l,\n      content,\n      pos;\n  state.env.references = state.env.references || {};\n\n  if (state.inlineMode) {\n    return;\n  } // Scan definitions in paragraph inlines\n\n\n  for (i = 1, l = tokens.length - 1; i < l; i++) {\n    if (tokens[i].type === 'inline' && tokens[i - 1].type === 'paragraph_open' && tokens[i + 1].type === 'paragraph_close') {\n      content = tokens[i].content;\n\n      while (content.length) {\n        pos = parseReference(content, state.inline, state.options, state.env);\n\n        if (pos < 0) {\n          break;\n        }\n\n        content = content.slice(pos).trim();\n      }\n\n      tokens[i].content = content;\n\n      if (!content.length) {\n        tokens[i - 1].tight = true;\n        tokens[i + 1].tight = true;\n      }\n    }\n  }\n};","// Regexps to match html elements\n'use strict';\n\nfunction replace(regex, options) {\n  regex = regex.source;\n  options = options || '';\n  return function self(name, val) {\n    if (!name) {\n      return new RegExp(regex, options);\n    }\n\n    val = val.source || val;\n    regex = regex.replace(name, val);\n    return self;\n  };\n}\n\nvar attr_name = /[a-zA-Z_:][a-zA-Z0-9:._-]*/;\nvar unquoted = /[^\"'=<>`\\x00-\\x20]+/;\nvar single_quoted = /'[^']*'/;\nvar double_quoted = /\"[^\"]*\"/;\n/*eslint no-spaced-func:0*/\n\nvar attr_value = replace(/(?:unquoted|single_quoted|double_quoted)/)('unquoted', unquoted)('single_quoted', single_quoted)('double_quoted', double_quoted)();\nvar attribute = replace(/(?:\\s+attr_name(?:\\s*=\\s*attr_value)?)/)('attr_name', attr_name)('attr_value', attr_value)();\nvar open_tag = replace(/<[A-Za-z][A-Za-z0-9]*attribute*\\s*\\/?>/)('attribute', attribute)();\nvar close_tag = /<\\/[A-Za-z][A-Za-z0-9]*\\s*>/;\nvar comment = /<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->/;\nvar processing = /<[?].*?[?]>/;\nvar declaration = /<![A-Z]+\\s+[^>]*>/;\nvar cdata = /<!\\[CDATA\\[[\\s\\S]*?\\]\\]>/;\nvar HTML_TAG_RE = replace(/^(?:open_tag|close_tag|comment|processing|declaration|cdata)/)('open_tag', open_tag)('close_tag', close_tag)('comment', comment)('processing', processing)('declaration', declaration)('cdata', cdata)();\nmodule.exports.HTML_TAG_RE = HTML_TAG_RE;","// GFM table, non-standard\n'use strict';\n\nfunction getLine(state, line) {\n  var pos = state.bMarks[line] + state.blkIndent,\n      max = state.eMarks[line];\n  return state.src.substr(pos, max - pos);\n}\n\nmodule.exports = function table(state, startLine, endLine, silent) {\n  var ch, lineText, pos, i, nextLine, rows, cell, aligns, t, tableLines, tbodyLines; // should have at least three lines\n\n  if (startLine + 2 > endLine) {\n    return false;\n  }\n\n  nextLine = startLine + 1;\n\n  if (state.tShift[nextLine] < state.blkIndent) {\n    return false;\n  } // first character of the second line should be '|' or '-'\n\n\n  pos = state.bMarks[nextLine] + state.tShift[nextLine];\n\n  if (pos >= state.eMarks[nextLine]) {\n    return false;\n  }\n\n  ch = state.src.charCodeAt(pos);\n\n  if (ch !== 0x7C\n  /* | */\n  && ch !== 0x2D\n  /* - */\n  && ch !== 0x3A\n  /* : */\n  ) {\n      return false;\n    }\n\n  lineText = getLine(state, startLine + 1);\n\n  if (!/^[-:| ]+$/.test(lineText)) {\n    return false;\n  }\n\n  rows = lineText.split('|');\n\n  if (rows <= 2) {\n    return false;\n  }\n\n  aligns = [];\n\n  for (i = 0; i < rows.length; i++) {\n    t = rows[i].trim();\n\n    if (!t) {\n      // allow empty columns before and after table, but not in between columns;\n      // e.g. allow ` |---| `, disallow ` ---||--- `\n      if (i === 0 || i === rows.length - 1) {\n        continue;\n      } else {\n        return false;\n      }\n    }\n\n    if (!/^:?-+:?$/.test(t)) {\n      return false;\n    }\n\n    if (t.charCodeAt(t.length - 1) === 0x3A\n    /* : */\n    ) {\n        aligns.push(t.charCodeAt(0) === 0x3A\n        /* : */\n        ? 'center' : 'right');\n      } else if (t.charCodeAt(0) === 0x3A\n    /* : */\n    ) {\n        aligns.push('left');\n      } else {\n      aligns.push('');\n    }\n  }\n\n  lineText = getLine(state, startLine).trim();\n\n  if (lineText.indexOf('|') === -1) {\n    return false;\n  }\n\n  rows = lineText.replace(/^\\||\\|$/g, '').split('|');\n\n  if (aligns.length !== rows.length) {\n    return false;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  state.tokens.push({\n    type: 'table_open',\n    lines: tableLines = [startLine, 0],\n    level: state.level++\n  });\n  state.tokens.push({\n    type: 'thead_open',\n    lines: [startLine, startLine + 1],\n    level: state.level++\n  });\n  state.tokens.push({\n    type: 'tr_open',\n    lines: [startLine, startLine + 1],\n    level: state.level++\n  });\n\n  for (i = 0; i < rows.length; i++) {\n    state.tokens.push({\n      type: 'th_open',\n      align: aligns[i],\n      lines: [startLine, startLine + 1],\n      level: state.level++\n    });\n    state.tokens.push({\n      type: 'inline',\n      content: rows[i].trim(),\n      lines: [startLine, startLine + 1],\n      level: state.level,\n      children: []\n    });\n    state.tokens.push({\n      type: 'th_close',\n      level: --state.level\n    });\n  }\n\n  state.tokens.push({\n    type: 'tr_close',\n    level: --state.level\n  });\n  state.tokens.push({\n    type: 'thead_close',\n    level: --state.level\n  });\n  state.tokens.push({\n    type: 'tbody_open',\n    lines: tbodyLines = [startLine + 2, 0],\n    level: state.level++\n  });\n\n  for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {\n    if (state.tShift[nextLine] < state.blkIndent) {\n      break;\n    }\n\n    lineText = getLine(state, nextLine).trim();\n\n    if (lineText.indexOf('|') === -1) {\n      break;\n    }\n\n    rows = lineText.replace(/^\\||\\|$/g, '').split('|');\n    state.tokens.push({\n      type: 'tr_open',\n      level: state.level++\n    });\n\n    for (i = 0; i < rows.length; i++) {\n      state.tokens.push({\n        type: 'td_open',\n        align: aligns[i],\n        level: state.level++\n      }); // 0x7c === '|'\n\n      cell = rows[i].substring(rows[i].charCodeAt(0) === 0x7c ? 1 : 0, rows[i].charCodeAt(rows[i].length - 1) === 0x7c ? rows[i].length - 1 : rows[i].length).trim();\n      state.tokens.push({\n        type: 'inline',\n        content: cell,\n        level: state.level,\n        children: []\n      });\n      state.tokens.push({\n        type: 'td_close',\n        level: --state.level\n      });\n    }\n\n    state.tokens.push({\n      type: 'tr_close',\n      level: --state.level\n    });\n  }\n\n  state.tokens.push({\n    type: 'tbody_close',\n    level: --state.level\n  });\n  state.tokens.push({\n    type: 'table_close',\n    level: --state.level\n  });\n  tableLines[1] = tbodyLines[1] = nextLine;\n  state.line = nextLine;\n  return true;\n};","// Block quotes\n'use strict';\n\nmodule.exports = function blockquote(state, startLine, endLine, silent) {\n  var nextLine,\n      lastLineEmpty,\n      oldTShift,\n      oldBMarks,\n      oldIndent,\n      oldParentType,\n      lines,\n      terminatorRules,\n      i,\n      l,\n      terminate,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  if (pos > max) {\n    return false;\n  } // check the block quote marker\n\n\n  if (state.src.charCodeAt(pos++) !== 0x3E\n  /* > */\n  ) {\n      return false;\n    }\n\n  if (state.level >= state.options.maxNesting) {\n    return false;\n  } // we know that it's going to be a valid blockquote,\n  // so no point trying to find the end of it in silent mode\n\n\n  if (silent) {\n    return true;\n  } // skip one optional space after '>'\n\n\n  if (state.src.charCodeAt(pos) === 0x20) {\n    pos++;\n  }\n\n  oldIndent = state.blkIndent;\n  state.blkIndent = 0;\n  oldBMarks = [state.bMarks[startLine]];\n  state.bMarks[startLine] = pos; // check if we have an empty blockquote\n\n  pos = pos < max ? state.skipSpaces(pos) : pos;\n  lastLineEmpty = pos >= max;\n  oldTShift = [state.tShift[startLine]];\n  state.tShift[startLine] = pos - state.bMarks[startLine];\n  terminatorRules = state.parser.ruler.getRules('blockquote'); // Search the end of the block\n  //\n  // Block ends with either:\n  //  1. an empty line outside:\n  //     ```\n  //     > test\n  //\n  //     ```\n  //  2. an empty line inside:\n  //     ```\n  //     >\n  //     test\n  //     ```\n  //  3. another tag\n  //     ```\n  //     > test\n  //      - - -\n  //     ```\n\n  for (nextLine = startLine + 1; nextLine < endLine; nextLine++) {\n    pos = state.bMarks[nextLine] + state.tShift[nextLine];\n    max = state.eMarks[nextLine];\n\n    if (pos >= max) {\n      // Case 1: line is not inside the blockquote, and this line is empty.\n      break;\n    }\n\n    if (state.src.charCodeAt(pos++) === 0x3E\n    /* > */\n    ) {\n        // This line is inside the blockquote.\n        // skip one optional space after '>'\n        if (state.src.charCodeAt(pos) === 0x20) {\n          pos++;\n        }\n\n        oldBMarks.push(state.bMarks[nextLine]);\n        state.bMarks[nextLine] = pos;\n        pos = pos < max ? state.skipSpaces(pos) : pos;\n        lastLineEmpty = pos >= max;\n        oldTShift.push(state.tShift[nextLine]);\n        state.tShift[nextLine] = pos - state.bMarks[nextLine];\n        continue;\n      } // Case 2: line is not inside the blockquote, and the last line was empty.\n\n\n    if (lastLineEmpty) {\n      break;\n    } // Case 3: another tag found.\n\n\n    terminate = false;\n\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n\n    if (terminate) {\n      break;\n    }\n\n    oldBMarks.push(state.bMarks[nextLine]);\n    oldTShift.push(state.tShift[nextLine]); // A negative number means that this is a paragraph continuation;\n    //\n    // Any negative number will do the job here, but it's better for it\n    // to be large enough to make any bugs obvious.\n\n    state.tShift[nextLine] = -1337;\n  }\n\n  oldParentType = state.parentType;\n  state.parentType = 'blockquote';\n  state.tokens.push({\n    type: 'blockquote_open',\n    lines: lines = [startLine, 0],\n    level: state.level++\n  });\n  state.parser.tokenize(state, startLine, nextLine);\n  state.tokens.push({\n    type: 'blockquote_close',\n    level: --state.level\n  });\n  state.parentType = oldParentType;\n  lines[1] = state.line; // Restore original tShift; this might not be necessary since the parser\n  // has already been here, but just to make sure we can do that.\n\n  for (i = 0; i < oldTShift.length; i++) {\n    state.bMarks[i + startLine] = oldBMarks[i];\n    state.tShift[i + startLine] = oldTShift[i];\n  }\n\n  state.blkIndent = oldIndent;\n  return true;\n};","// Commonmark default options\n'use strict';\n\nmodule.exports = {\n  options: {\n    html: true,\n    // Enable HTML tags in source\n    xhtmlOut: true,\n    // Use '/' to close single tags (<br />)\n    breaks: false,\n    // Convert '\\n' in paragraphs into <br>\n    langPrefix: 'language-',\n    // CSS language prefix for fenced blocks\n    linkify: false,\n    // autoconvert URL-like texts to links\n    linkTarget: '',\n    // set target to open link in\n    // Enable some language-neutral replacements + quotes beautification\n    typographer: false,\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Set doubles to '«»' for Russian, '„“' for German.\n    quotes: '“”‘’',\n    // Highlighter function. Should return escaped HTML,\n    // or '' if input not changed\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n    maxNesting: 20 // Internal protection, recursion limit\n\n  },\n  components: {\n    core: {\n      rules: ['block', 'inline', 'references', 'abbr2']\n    },\n    block: {\n      rules: ['blockquote', 'code', 'fences', 'heading', 'hr', 'htmlblock', 'lheading', 'list', 'paragraph']\n    },\n    inline: {\n      rules: ['autolink', 'backticks', 'emphasis', 'entity', 'escape', 'htmltag', 'links', 'newline', 'text']\n    }\n  }\n};","// Process ^superscript^\n'use strict'; // same as UNESCAPE_MD_RE plus a space\n\nvar UNESCAPE_RE = /\\\\([ \\\\!\"#$%&'()*+,.\\/:;<=>?@[\\]^_`{|}~-])/g;\n\nmodule.exports = function sup(state, silent) {\n  var found,\n      content,\n      max = state.posMax,\n      start = state.pos;\n\n  if (state.src.charCodeAt(start) !== 0x5E\n  /* ^ */\n  ) {\n      return false;\n    }\n\n  if (silent) {\n    return false;\n  } // don't run any pairs in validation mode\n\n\n  if (start + 2 >= max) {\n    return false;\n  }\n\n  if (state.level >= state.options.maxNesting) {\n    return false;\n  }\n\n  state.pos = start + 1;\n\n  while (state.pos < max) {\n    if (state.src.charCodeAt(state.pos) === 0x5E\n    /* ^ */\n    ) {\n        found = true;\n        break;\n      }\n\n    state.parser.skipToken(state);\n  }\n\n  if (!found || start + 1 === state.pos) {\n    state.pos = start;\n    return false;\n  }\n\n  content = state.src.slice(start + 1, state.pos); // don't allow unescaped spaces/newlines inside\n\n  if (content.match(/(^|[^\\\\])(\\\\\\\\)*\\s/)) {\n    state.pos = start;\n    return false;\n  } // found!\n\n\n  state.posMax = state.pos;\n  state.pos = start + 1;\n\n  if (!silent) {\n    state.push({\n      type: 'sup',\n      level: state.level,\n      content: content.replace(UNESCAPE_RE, '$1')\n    });\n  }\n\n  state.pos = state.posMax + 1;\n  state.posMax = max;\n  return true;\n};","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * @flow\n */\n\nimport CodeExample from './CodeExample';\n\nexport default CodeExample;\n","// Paragraph\n'use strict';\n\nmodule.exports = function paragraph(state, startLine\n/*, endLine*/\n) {\n  var endLine,\n      content,\n      terminate,\n      i,\n      l,\n      nextLine = startLine + 1,\n      terminatorRules;\n  endLine = state.lineMax; // jump line-by-line until empty one or EOF\n\n  if (nextLine < endLine && !state.isEmpty(nextLine)) {\n    terminatorRules = state.parser.ruler.getRules('paragraph');\n\n    for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {\n      // this would be a code block normally, but after paragraph\n      // it's considered a lazy continuation regardless of what's there\n      if (state.tShift[nextLine] - state.blkIndent > 3) {\n        continue;\n      } // Some tags can terminate paragraph without empty line.\n\n\n      terminate = false;\n\n      for (i = 0, l = terminatorRules.length; i < l; i++) {\n        if (terminatorRules[i](state, nextLine, endLine, true)) {\n          terminate = true;\n          break;\n        }\n      }\n\n      if (terminate) {\n        break;\n      }\n    }\n  }\n\n  content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();\n  state.line = nextLine;\n\n  if (content.length) {\n    state.tokens.push({\n      type: 'paragraph_open',\n      tight: false,\n      lines: [startLine, state.line],\n      level: state.level\n    });\n    state.tokens.push({\n      type: 'inline',\n      content: content,\n      level: state.level + 1,\n      lines: [startLine, state.line],\n      children: []\n    });\n    state.tokens.push({\n      type: 'paragraph_close',\n      tight: false,\n      level: state.level\n    });\n  }\n\n  return true;\n};","// fences (``` lang, ~~~ lang)\n'use strict';\n\nmodule.exports = function fences(state, startLine, endLine, silent) {\n  var marker,\n      len,\n      params,\n      nextLine,\n      mem,\n      haveEndMarker = false,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  if (pos + 3 > max) {\n    return false;\n  }\n\n  marker = state.src.charCodeAt(pos);\n\n  if (marker !== 0x7E\n  /* ~ */\n  && marker !== 0x60\n  /* ` */\n  ) {\n      return false;\n    } // scan marker length\n\n\n  mem = pos;\n  pos = state.skipChars(pos, marker);\n  len = pos - mem;\n\n  if (len < 3) {\n    return false;\n  }\n\n  params = state.src.slice(pos, max).trim();\n\n  if (params.indexOf('`') >= 0) {\n    return false;\n  } // Since start is found, we can report success here in validation mode\n\n\n  if (silent) {\n    return true;\n  } // search end of block\n\n\n  nextLine = startLine;\n\n  for (;;) {\n    nextLine++;\n\n    if (nextLine >= endLine) {\n      // unclosed block should be autoclosed by end of document.\n      // also block seems to be autoclosed by end of parent\n      break;\n    }\n\n    pos = mem = state.bMarks[nextLine] + state.tShift[nextLine];\n    max = state.eMarks[nextLine];\n\n    if (pos < max && state.tShift[nextLine] < state.blkIndent) {\n      // non-empty line with negative indent should stop the list:\n      // - ```\n      //  test\n      break;\n    }\n\n    if (state.src.charCodeAt(pos) !== marker) {\n      continue;\n    }\n\n    if (state.tShift[nextLine] - state.blkIndent >= 4) {\n      // closing fence should be indented less than 4 spaces\n      continue;\n    }\n\n    pos = state.skipChars(pos, marker); // closing code fence must be at least as long as the opening one\n\n    if (pos - mem < len) {\n      continue;\n    } // make sure tail has spaces only\n\n\n    pos = state.skipSpaces(pos);\n\n    if (pos < max) {\n      continue;\n    }\n\n    haveEndMarker = true; // found!\n\n    break;\n  } // If a fence has heading spaces, they should be removed from its inner block\n\n\n  len = state.tShift[startLine];\n  state.line = nextLine + (haveEndMarker ? 1 : 0);\n  state.tokens.push({\n    type: 'fence',\n    params: params,\n    content: state.getLines(startLine + 1, nextLine, len, true),\n    lines: [startLine, state.line],\n    level: state.level\n  });\n  return true;\n};","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * @emails react-core\n */\n\nimport ButtonLink from 'components/ButtonLink';\nimport Container from 'components/Container';\nimport Flex from 'components/Flex';\nimport CodeExample from 'components/CodeExample';\nimport PropTypes from 'prop-types';\nimport React, {Component} from 'react';\nimport {graphql} from 'gatsby';\nimport TitleAndMetaTags from 'components/TitleAndMetaTags';\nimport Layout from 'components/Layout';\nimport {colors, media, sharedStyles} from 'theme';\nimport loadScript from 'utils/loadScript';\nimport createCanonicalUrl from 'utils/createCanonicalUrl';\nimport {babelURL} from 'site-constants';\nimport logoWhiteSvg from 'icons/logo-white.svg';\n\nclass Home extends Component {\n  state = {\n    babelLoaded: false,\n  };\n\n  componentDidMount() {\n    loadScript(babelURL).then(\n      () => {\n        this.setState({\n          babelLoaded: true,\n        });\n      },\n      error => {\n        console.error('Babel failed to load.');\n      },\n    );\n  }\n\n  render() {\n    const {babelLoaded} = this.state;\n    const {data, location} = this.props;\n    const {codeExamples, examples, marketing} = data;\n\n    const code = codeExamples.edges.reduce((lookup, {node}) => {\n      lookup[node.mdAbsolutePath] = node;\n      return lookup;\n    }, {});\n\n    return (\n      <Layout location={location}>\n        <TitleAndMetaTags\n          title=\"React &ndash; A JavaScript library for building user interfaces\"\n          canonicalUrl={createCanonicalUrl('/')}\n        />\n        <div\n          css={{\n            width: '100%',\n          }}>\n          <header\n            css={{\n              backgroundColor: colors.dark,\n              color: colors.white,\n            }}>\n            <div\n              css={{\n                paddingTop: 45,\n                paddingBottom: 10,\n\n                [media.greaterThan('small')]: {\n                  paddingTop: 60,\n                  paddingBottom: 70,\n                },\n\n                [media.greaterThan('xlarge')]: {\n                  paddingTop: 95,\n                  paddingBottom: 85,\n                  maxWidth: 1500, // Positioning of background logo\n                  marginLeft: 'auto',\n                  marginRight: 'auto',\n                  position: 'relative',\n                  '::before': {\n                    content: ' ',\n                    position: 'absolute',\n                    top: 0,\n                    left: 0,\n                    bottom: 0,\n                    right: 0,\n                    backgroundImage: `url(${logoWhiteSvg})`,\n                    backgroundRepeat: 'no-repeat',\n                    backgroundPosition: '100% 100px',\n                    backgroundSize: '50% auto',\n                    opacity: 0.05,\n                  },\n                },\n              }}>\n              <div\n                css={{\n                  // Content should be above absolutely-positioned hero image\n                  position: 'relative',\n                }}>\n                <Container>\n                  <h1\n                    css={{\n                      color: colors.brand,\n                      textAlign: 'center',\n                      margin: 0,\n                      fontSize: 45,\n                      letterSpacing: '0.01em',\n                      [media.size('xsmall')]: {\n                        fontSize: 30,\n                      },\n                      [media.greaterThan('xlarge')]: {\n                        fontSize: 60,\n                      },\n                    }}>\n                    React\n                  </h1>\n                  <p\n                    css={{\n                      paddingTop: 15,\n                      textAlign: 'center',\n                      fontSize: 24,\n                      letterSpacing: '0.01em',\n                      fontWeight: 200,\n\n                      [media.size('xsmall')]: {\n                        fontSize: 16,\n                        maxWidth: '12em',\n                        marginLeft: 'auto',\n                        marginRight: 'auto',\n                      },\n\n                      [media.greaterThan('xlarge')]: {\n                        paddingTop: 20,\n                        fontSize: 30,\n                      },\n                    }}>\n                    A JavaScript library for building user interfaces\n                  </p>\n                  <Flex\n                    valign=\"center\"\n                    halign=\"center\"\n                    css={{\n                      paddingTop: 40,\n                      flexWrap: 'wrap',\n                      justifyContent: 'center',\n\n                      [media.greaterThan('xlarge')]: {\n                        paddingTop: 65,\n                      },\n                    }}>\n                    <CtaItem>\n                      <ButtonLink\n                        to=\"/docs/getting-started.html\"\n                        type=\"primary\">\n                        Get Started\n                      </ButtonLink>\n                    </CtaItem>\n                    <CtaItem>\n                      <ButtonLink to=\"/tutorial/tutorial.html\" type=\"secondary\">\n                        Take the Tutorial\n                      </ButtonLink>\n                    </CtaItem>\n                  </Flex>\n                </Container>\n              </div>\n            </div>\n          </header>\n\n          <Container>\n            <div css={sharedStyles.markdown}>\n              <section\n                css={[\n                  sectionStyles,\n                  {\n                    [media.lessThan('medium')]: {\n                      marginTop: 0,\n                      marginBottom: 0,\n                      overflowX: 'auto',\n                      paddingTop: 30,\n                      WebkitOverflowScrolling: 'touch',\n                      position: 'relative',\n                      maskImage:\n                        'linear-gradient(to right, transparent, white 10px, white 90%, transparent)',\n                    },\n                  },\n                ]}>\n                <div\n                  css={{\n                    display: 'flex',\n                    flexDirection: 'row',\n\n                    [media.lessThan('medium')]: {\n                      display: 'block',\n                      whiteSpace: 'nowrap',\n                    },\n                  }}>\n                  {marketing.edges.map(({node: column}, index) => (\n                    <div\n                      key={index}\n                      css={{\n                        display: 'flex',\n                        flexDirection: 'column',\n                        flex: '0 1 33%',\n                        marginLeft: 40,\n\n                        '&:first-of-type': {\n                          marginLeft: 0,\n\n                          [media.lessThan('medium')]: {\n                            marginLeft: 10,\n                          },\n                        },\n\n                        [media.lessThan('medium')]: {\n                          display: 'inline-block',\n                          verticalAlign: 'top',\n                          marginLeft: 0,\n                          whiteSpace: 'normal',\n                          width: '75%',\n                          marginRight: 20,\n                          paddingBottom: 40,\n\n                          '&:first-of-type': {\n                            marginTop: 0,\n                          },\n                        },\n                      }}>\n                      <h3\n                        css={[\n                          headingStyles,\n                          {\n                            '&&': {\n                              // Make specificity higher than the site-wide h3 styles.\n                              color: colors.subtle,\n                              paddingTop: 0,\n                              fontWeight: 300,\n                              fontSize: 20,\n\n                              [media.greaterThan('xlarge')]: {\n                                fontSize: 24,\n                              },\n                            },\n                          },\n                        ]}>\n                        {column.frontmatter.title}\n                      </h3>\n                      <div dangerouslySetInnerHTML={{__html: column.html}} />\n                    </div>\n                  ))}\n                </div>\n              </section>\n              <hr\n                css={{\n                  height: 1,\n                  marginBottom: -1,\n                  border: 'none',\n                  borderBottom: `1 solid ${colors.divider}`,\n                }}\n              />\n              <section css={sectionStyles}>\n                <div id=\"examples\">\n                  {examples.edges.map(({node}, index) => {\n                    const snippet = code[node.fileAbsolutePath];\n                    return (\n                      <CodeExample\n                        key={index}\n                        id={snippet.id}\n                        code={snippet.code}\n                        containerNodeID={node.frontmatter.domid}\n                        loaded={babelLoaded}>\n                        <h3 css={headingStyles}>{node.frontmatter.title}</h3>\n                        <div dangerouslySetInnerHTML={{__html: node.html}} />\n                      </CodeExample>\n                    );\n                  })}\n                </div>\n              </section>\n            </div>\n          </Container>\n\n          <section\n            css={{\n              background: colors.dark,\n              color: colors.white,\n              paddingTop: 45,\n              paddingBottom: 25,\n            }}>\n            <Container>\n              <Flex\n                valign=\"center\"\n                halign=\"center\"\n                css={{\n                  flexWrap: 'wrap',\n                  justifyContent: 'center',\n                }}>\n                <CtaItem>\n                  <ButtonLink to=\"/docs/getting-started.html\" type=\"primary\">\n                    Get Started\n                  </ButtonLink>\n                </CtaItem>\n                <CtaItem>\n                  <ButtonLink to=\"/tutorial/tutorial.html\" type=\"secondary\">\n                    Take the Tutorial\n                  </ButtonLink>\n                </CtaItem>\n              </Flex>\n            </Container>\n          </section>\n        </div>\n      </Layout>\n    );\n  }\n}\n\nHome.propTypes = {\n  data: PropTypes.shape({\n    examples: PropTypes.object.isRequired,\n    marketing: PropTypes.object.isRequired,\n  }).isRequired,\n};\n\nconst CtaItem = ({children, primary = false}) => (\n  <div\n    css={{\n      [media.between('small', 'large')]: {\n        paddingLeft: 20,\n      },\n\n      [media.greaterThan('xlarge')]: {\n        paddingLeft: 40,\n      },\n\n      '&:first-child': {\n        textAlign: 'right',\n        paddingRight: 7,\n        paddingLeft: 7,\n        [media.lessThan('small')]: {\n          marginBottom: 10,\n        },\n      },\n\n      '&:nth-child(2)': {\n        paddingRight: 7,\n        paddingLeft: 7,\n        [media.greaterThan('small')]: {\n          paddingLeft: 15,\n        },\n        [media.lessThan('small')]: {\n          marginBottom: 10,\n        },\n      },\n    }}>\n    {children}\n  </div>\n);\n\nexport const pageQuery = graphql`\n  query IndexMarkdown {\n    codeExamples: allExampleCode {\n      edges {\n        node {\n          id\n          code\n          mdAbsolutePath\n        }\n      }\n    }\n\n    examples: allMarkdownRemark(\n      filter: {fileAbsolutePath: {regex: \"//home/examples//\"}}\n      sort: {fields: [frontmatter___order], order: ASC}\n    ) {\n      edges {\n        node {\n          fileAbsolutePath\n          fields {\n            slug\n          }\n          frontmatter {\n            title\n            domid\n          }\n          html\n        }\n      }\n    }\n    marketing: allMarkdownRemark(\n      filter: {fileAbsolutePath: {regex: \"//home/marketing//\"}}\n      sort: {fields: [frontmatter___order], order: ASC}\n    ) {\n      edges {\n        node {\n          frontmatter {\n            title\n          }\n          html\n        }\n      }\n    }\n  }\n`;\n\nexport default Home;\n\nconst sectionStyles = {\n  marginTop: 20,\n  marginBottom: 15,\n\n  [media.greaterThan('medium')]: {\n    marginTop: 60,\n    marginBottom: 65,\n  },\n};\n\nconst headingStyles = {\n  '&&': {\n    marginBottom: 20,\n  },\n};\n","'use strict';\n/**\n * Local dependencies\n */\n\nvar assign = require('./common/utils').assign;\n\nvar Renderer = require('./renderer');\n\nvar ParserCore = require('./parser_core');\n\nvar ParserBlock = require('./parser_block');\n\nvar ParserInline = require('./parser_inline');\n\nvar Ruler = require('./ruler');\n/**\n * Preset configs\n */\n\n\nvar config = {\n  'default': require('./configs/default'),\n  'full': require('./configs/full'),\n  'commonmark': require('./configs/commonmark')\n};\n/**\n * The `StateCore` class manages state.\n *\n * @param {Object} `instance` Remarkable instance\n * @param {String} `str` Markdown string\n * @param {Object} `env`\n */\n\nfunction StateCore(instance, str, env) {\n  this.src = str;\n  this.env = env;\n  this.options = instance.options;\n  this.tokens = [];\n  this.inlineMode = false;\n  this.inline = instance.inline;\n  this.block = instance.block;\n  this.renderer = instance.renderer;\n  this.typographer = instance.typographer;\n}\n/**\n * The main `Remarkable` class. Create an instance of\n * `Remarkable` with a `preset` and/or `options`.\n *\n * @param {String} `preset` If no preset is given, `default` is used.\n * @param {Object} `options`\n */\n\n\nfunction Remarkable(preset, options) {\n  if (typeof preset !== 'string') {\n    options = preset;\n    preset = 'default';\n  }\n\n  this.inline = new ParserInline();\n  this.block = new ParserBlock();\n  this.core = new ParserCore();\n  this.renderer = new Renderer();\n  this.ruler = new Ruler();\n  this.options = {};\n  this.configure(config[preset]);\n  this.set(options || {});\n}\n/**\n * Set options as an alternative to passing them\n * to the constructor.\n *\n * ```js\n * md.set({typographer: true});\n * ```\n * @param {Object} `options`\n * @api public\n */\n\n\nRemarkable.prototype.set = function (options) {\n  assign(this.options, options);\n};\n/**\n * Batch loader for components rules states, and options\n *\n * @param  {Object} `presets`\n */\n\n\nRemarkable.prototype.configure = function (presets) {\n  var self = this;\n\n  if (!presets) {\n    throw new Error('Wrong `remarkable` preset, check name/content');\n  }\n\n  if (presets.options) {\n    self.set(presets.options);\n  }\n\n  if (presets.components) {\n    Object.keys(presets.components).forEach(function (name) {\n      if (presets.components[name].rules) {\n        self[name].ruler.enable(presets.components[name].rules, true);\n      }\n    });\n  }\n};\n/**\n * Use a plugin.\n *\n * ```js\n * var md = new Remarkable();\n *\n * md.use(plugin1)\n *   .use(plugin2, opts)\n *   .use(plugin3);\n * ```\n *\n * @param  {Function} `plugin`\n * @param  {Object} `options`\n * @return {Object} `Remarkable` for chaining\n */\n\n\nRemarkable.prototype.use = function (plugin, options) {\n  plugin(this, options);\n  return this;\n};\n/**\n * Parse the input `string` and return a tokens array.\n * Modifies `env` with definitions data.\n *\n * @param  {String} `string`\n * @param  {Object} `env`\n * @return {Array} Array of tokens\n */\n\n\nRemarkable.prototype.parse = function (str, env) {\n  var state = new StateCore(this, str, env);\n  this.core.process(state);\n  return state.tokens;\n};\n/**\n * The main `.render()` method that does all the magic :)\n *\n * @param  {String} `string`\n * @param  {Object} `env`\n * @return {String} Rendered HTML.\n */\n\n\nRemarkable.prototype.render = function (str, env) {\n  env = env || {};\n  return this.renderer.render(this.parse(str, env), this.options, env);\n};\n/**\n * Parse the given content `string` as a single string.\n *\n * @param  {String} `string`\n * @param  {Object} `env`\n * @return {Array} Array of tokens\n */\n\n\nRemarkable.prototype.parseInline = function (str, env) {\n  var state = new StateCore(this, str, env);\n  state.inlineMode = true;\n  this.core.process(state);\n  return state.tokens;\n};\n/**\n * Render a single content `string`, without wrapping it\n * to paragraphs\n *\n * @param  {String} `str`\n * @param  {Object} `env`\n * @return {String}\n */\n\n\nRemarkable.prototype.renderInline = function (str, env) {\n  env = env || {};\n  return this.renderer.render(this.parseInline(str, env), this.options, env);\n};\n/**\n * Expose `Remarkable`\n */\n\n\nmodule.exports = Remarkable;\n/**\n * Expose `utils`, Useful helper functions for custom\n * rendering.\n */\n\nmodule.exports.utils = require('./common/utils');","// Process html tags\n'use strict';\n\nvar HTML_TAG_RE = require('../common/html_re').HTML_TAG_RE;\n\nfunction isLetter(ch) {\n  /*eslint no-bitwise:0*/\n  var lc = ch | 0x20; // to lower case\n\n  return lc >= 0x61\n  /* a */\n  && lc <= 0x7a\n  /* z */\n  ;\n}\n\nmodule.exports = function htmltag(state, silent) {\n  var ch,\n      match,\n      max,\n      pos = state.pos;\n\n  if (!state.options.html) {\n    return false;\n  } // Check start\n\n\n  max = state.posMax;\n\n  if (state.src.charCodeAt(pos) !== 0x3C\n  /* < */\n  || pos + 2 >= max) {\n    return false;\n  } // Quick fail on second char\n\n\n  ch = state.src.charCodeAt(pos + 1);\n\n  if (ch !== 0x21\n  /* ! */\n  && ch !== 0x3F\n  /* ? */\n  && ch !== 0x2F\n  /* / */\n  && !isLetter(ch)) {\n    return false;\n  }\n\n  match = state.src.slice(pos).match(HTML_TAG_RE);\n\n  if (!match) {\n    return false;\n  }\n\n  if (!silent) {\n    state.push({\n      type: 'htmltag',\n      content: state.src.slice(pos, pos + match[0].length),\n      level: state.level\n    });\n  }\n\n  state.pos += match[0].length;\n  return true;\n};","'use strict';\n/**\n * Parse link labels\n *\n * This function assumes that first character (`[`) already matches;\n * returns the end of the label.\n *\n * @param  {Object} state\n * @param  {Number} start\n * @api private\n */\n\nmodule.exports = function parseLinkLabel(state, start) {\n  var level,\n      found,\n      marker,\n      labelEnd = -1,\n      max = state.posMax,\n      oldPos = state.pos,\n      oldFlag = state.isInLabel;\n\n  if (state.isInLabel) {\n    return -1;\n  }\n\n  if (state.labelUnmatchedScopes) {\n    state.labelUnmatchedScopes--;\n    return -1;\n  }\n\n  state.pos = start + 1;\n  state.isInLabel = true;\n  level = 1;\n\n  while (state.pos < max) {\n    marker = state.src.charCodeAt(state.pos);\n\n    if (marker === 0x5B\n    /* [ */\n    ) {\n        level++;\n      } else if (marker === 0x5D\n    /* ] */\n    ) {\n        level--;\n\n        if (level === 0) {\n          found = true;\n          break;\n        }\n      }\n\n    state.parser.skipToken(state);\n  }\n\n  if (found) {\n    labelEnd = state.pos;\n    state.labelUnmatchedScopes = 0;\n  } else {\n    state.labelUnmatchedScopes = level - 1;\n  } // restore old state\n\n\n  state.pos = oldPos;\n  state.isInLabel = oldFlag;\n  return labelEnd;\n};","'use strict';\n\nmodule.exports = function inline(state) {\n  var tokens = state.tokens,\n      tok,\n      i,\n      l; // Parse inlines\n\n  for (i = 0, l = tokens.length; i < l; i++) {\n    tok = tokens[i];\n\n    if (tok.type === 'inline') {\n      state.inline.parse(tok.content, state.options, state.env, tok.children);\n    }\n  }\n};","'use strict';\n\nvar unescapeMd = require('../common/utils').unescapeMd;\n/**\n * Parse link title\n *\n *   - on success it returns a string and updates state.pos;\n *   - on failure it returns null\n *\n * @param  {Object} state\n * @param  {Number} pos\n * @api private\n */\n\n\nmodule.exports = function parseLinkTitle(state, pos) {\n  var code,\n      start = pos,\n      max = state.posMax,\n      marker = state.src.charCodeAt(pos);\n\n  if (marker !== 0x22\n  /* \" */\n  && marker !== 0x27\n  /* ' */\n  && marker !== 0x28\n  /* ( */\n  ) {\n      return false;\n    }\n\n  pos++; // if opening marker is \"(\", switch it to closing marker \")\"\n\n  if (marker === 0x28) {\n    marker = 0x29;\n  }\n\n  while (pos < max) {\n    code = state.src.charCodeAt(pos);\n\n    if (code === marker) {\n      state.pos = pos + 1;\n      state.linkContent = unescapeMd(state.src.slice(start + 1, pos));\n      return true;\n    }\n\n    if (code === 0x5C\n    /* \\ */\n    && pos + 1 < max) {\n      pos += 2;\n      continue;\n    }\n\n    pos++;\n  }\n\n  return false;\n};","// List of valid html blocks names, accorting to commonmark spec\n// http://jgm.github.io/CommonMark/spec.html#html-blocks\n'use strict';\n\nvar html_blocks = {};\n['article', 'aside', 'button', 'blockquote', 'body', 'canvas', 'caption', 'col', 'colgroup', 'dd', 'div', 'dl', 'dt', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hgroup', 'hr', 'iframe', 'li', 'map', 'object', 'ol', 'output', 'p', 'pre', 'progress', 'script', 'section', 'style', 'table', 'tbody', 'td', 'textarea', 'tfoot', 'th', 'tr', 'thead', 'ul', 'video'].forEach(function (name) {\n  html_blocks[name] = true;\n});\nmodule.exports = html_blocks;","'use strict';\n/**\n * Local dependencies\n */\n\nvar Ruler = require('./ruler');\n\nvar StateInline = require('./rules_inline/state_inline');\n\nvar utils = require('./common/utils');\n/**\n * Inline Parser `rules`\n */\n\n\nvar _rules = [['text', require('./rules_inline/text')], ['newline', require('./rules_inline/newline')], ['escape', require('./rules_inline/escape')], ['backticks', require('./rules_inline/backticks')], ['del', require('./rules_inline/del')], ['ins', require('./rules_inline/ins')], ['mark', require('./rules_inline/mark')], ['emphasis', require('./rules_inline/emphasis')], ['sub', require('./rules_inline/sub')], ['sup', require('./rules_inline/sup')], ['links', require('./rules_inline/links')], ['footnote_inline', require('./rules_inline/footnote_inline')], ['footnote_ref', require('./rules_inline/footnote_ref')], ['autolink', require('./rules_inline/autolink')], ['htmltag', require('./rules_inline/htmltag')], ['entity', require('./rules_inline/entity')]];\n/**\n * Inline Parser class. Note that link validation is stricter\n * in Remarkable than what is specified by CommonMark. If you\n * want to change this you can use a custom validator.\n *\n * @api private\n */\n\nfunction ParserInline() {\n  this.ruler = new Ruler();\n\n  for (var i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1]);\n  } // Can be overridden with a custom validator\n\n\n  this.validateLink = validateLink;\n}\n/**\n * Skip a single token by running all rules in validation mode.\n * Returns `true` if any rule reports success.\n *\n * @param  {Object} `state`\n * @api privage\n */\n\n\nParserInline.prototype.skipToken = function (state) {\n  var rules = this.ruler.getRules('');\n  var len = rules.length;\n  var pos = state.pos;\n  var i, cached_pos;\n\n  if ((cached_pos = state.cacheGet(pos)) > 0) {\n    state.pos = cached_pos;\n    return;\n  }\n\n  for (i = 0; i < len; i++) {\n    if (rules[i](state, true)) {\n      state.cacheSet(pos, state.pos);\n      return;\n    }\n  }\n\n  state.pos++;\n  state.cacheSet(pos, state.pos);\n};\n/**\n * Generate tokens for the given input range.\n *\n * @param  {Object} `state`\n * @api private\n */\n\n\nParserInline.prototype.tokenize = function (state) {\n  var rules = this.ruler.getRules('');\n  var len = rules.length;\n  var end = state.posMax;\n  var ok, i;\n\n  while (state.pos < end) {\n    // Try all possible rules.\n    // On success, the rule should:\n    //\n    // - update `state.pos`\n    // - update `state.tokens`\n    // - return true\n    for (i = 0; i < len; i++) {\n      ok = rules[i](state, false);\n\n      if (ok) {\n        break;\n      }\n    }\n\n    if (ok) {\n      if (state.pos >= end) {\n        break;\n      }\n\n      continue;\n    }\n\n    state.pending += state.src[state.pos++];\n  }\n\n  if (state.pending) {\n    state.pushPending();\n  }\n};\n/**\n * Parse the given input string.\n *\n * @param  {String} `str`\n * @param  {Object} `options`\n * @param  {Object} `env`\n * @param  {Array} `outTokens`\n * @api private\n */\n\n\nParserInline.prototype.parse = function (str, options, env, outTokens) {\n  var state = new StateInline(str, this, options, env, outTokens);\n  this.tokenize(state);\n};\n/**\n * Validate the given `url` by checking for bad protocols.\n *\n * @param  {String} `url`\n * @return {Boolean}\n */\n\n\nfunction validateLink(url) {\n  var BAD_PROTOCOLS = ['vbscript', 'javascript', 'file', 'data'];\n  var str = url.trim().toLowerCase(); // Care about digital entities \"javascript&#x3A;alert(1)\"\n\n  str = utils.replaceEntities(str);\n\n  if (str.indexOf(':') !== -1 && BAD_PROTOCOLS.indexOf(str.split(':')[0]) !== -1) {\n    return false;\n  }\n\n  return true;\n}\n/**\n * Expose `ParserInline`\n */\n\n\nmodule.exports = ParserInline;","// Process footnote reference list\n'use strict';\n\nmodule.exports = function footnote(state, startLine, endLine, silent) {\n  var oldBMark,\n      oldTShift,\n      oldParentType,\n      pos,\n      label,\n      start = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine]; // line should be at least 5 chars - \"[^x]:\"\n\n  if (start + 4 > max) {\n    return false;\n  }\n\n  if (state.src.charCodeAt(start) !== 0x5B\n  /* [ */\n  ) {\n      return false;\n    }\n\n  if (state.src.charCodeAt(start + 1) !== 0x5E\n  /* ^ */\n  ) {\n      return false;\n    }\n\n  if (state.level >= state.options.maxNesting) {\n    return false;\n  }\n\n  for (pos = start + 2; pos < max; pos++) {\n    if (state.src.charCodeAt(pos) === 0x20) {\n      return false;\n    }\n\n    if (state.src.charCodeAt(pos) === 0x5D\n    /* ] */\n    ) {\n        break;\n      }\n  }\n\n  if (pos === start + 2) {\n    return false;\n  } // no empty footnote labels\n\n\n  if (pos + 1 >= max || state.src.charCodeAt(++pos) !== 0x3A\n  /* : */\n  ) {\n      return false;\n    }\n\n  if (silent) {\n    return true;\n  }\n\n  pos++;\n\n  if (!state.env.footnotes) {\n    state.env.footnotes = {};\n  }\n\n  if (!state.env.footnotes.refs) {\n    state.env.footnotes.refs = {};\n  }\n\n  label = state.src.slice(start + 2, pos - 2);\n  state.env.footnotes.refs[':' + label] = -1;\n  state.tokens.push({\n    type: 'footnote_reference_open',\n    label: label,\n    level: state.level++\n  });\n  oldBMark = state.bMarks[startLine];\n  oldTShift = state.tShift[startLine];\n  oldParentType = state.parentType;\n  state.tShift[startLine] = state.skipSpaces(pos) - pos;\n  state.bMarks[startLine] = pos;\n  state.blkIndent += 4;\n  state.parentType = 'footnote';\n\n  if (state.tShift[startLine] < state.blkIndent) {\n    state.tShift[startLine] += state.blkIndent;\n    state.bMarks[startLine] -= state.blkIndent;\n  }\n\n  state.parser.tokenize(state, startLine, endLine, true);\n  state.parentType = oldParentType;\n  state.blkIndent -= 4;\n  state.tShift[startLine] = oldTShift;\n  state.bMarks[startLine] = oldBMark;\n  state.tokens.push({\n    type: 'footnote_reference_close',\n    level: --state.level\n  });\n  return true;\n};","'use strict';\n\nmodule.exports = require('./lib/');","'use strict';\n/**\n * Local dependencies\n */\n\nvar Ruler = require('./ruler');\n\nvar StateBlock = require('./rules_block/state_block');\n/**\n * Parser rules\n */\n\n\nvar _rules = [['code', require('./rules_block/code')], ['fences', require('./rules_block/fences'), ['paragraph', 'blockquote', 'list']], ['blockquote', require('./rules_block/blockquote'), ['paragraph', 'blockquote', 'list']], ['hr', require('./rules_block/hr'), ['paragraph', 'blockquote', 'list']], ['list', require('./rules_block/list'), ['paragraph', 'blockquote']], ['footnote', require('./rules_block/footnote'), ['paragraph']], ['heading', require('./rules_block/heading'), ['paragraph', 'blockquote']], ['lheading', require('./rules_block/lheading')], ['htmlblock', require('./rules_block/htmlblock'), ['paragraph', 'blockquote']], ['table', require('./rules_block/table'), ['paragraph']], ['deflist', require('./rules_block/deflist'), ['paragraph']], ['paragraph', require('./rules_block/paragraph')]];\n/**\n * Block Parser class\n *\n * @api private\n */\n\nfunction ParserBlock() {\n  this.ruler = new Ruler();\n\n  for (var i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1], {\n      alt: (_rules[i][2] || []).slice()\n    });\n  }\n}\n/**\n * Generate tokens for the given input range.\n *\n * @param  {Object} `state` Has properties like `src`, `parser`, `options` etc\n * @param  {Number} `startLine`\n * @param  {Number} `endLine`\n * @api private\n */\n\n\nParserBlock.prototype.tokenize = function (state, startLine, endLine) {\n  var rules = this.ruler.getRules('');\n  var len = rules.length;\n  var line = startLine;\n  var hasEmptyLines = false;\n  var ok, i;\n\n  while (line < endLine) {\n    state.line = line = state.skipEmptyLines(line);\n\n    if (line >= endLine) {\n      break;\n    } // Termination condition for nested calls.\n    // Nested calls currently used for blockquotes & lists\n\n\n    if (state.tShift[line] < state.blkIndent) {\n      break;\n    } // Try all possible rules.\n    // On success, rule should:\n    //\n    // - update `state.line`\n    // - update `state.tokens`\n    // - return true\n\n\n    for (i = 0; i < len; i++) {\n      ok = rules[i](state, line, endLine, false);\n\n      if (ok) {\n        break;\n      }\n    } // set state.tight iff we had an empty line before current tag\n    // i.e. latest empty line should not count\n\n\n    state.tight = !hasEmptyLines; // paragraph might \"eat\" one newline after it in nested lists\n\n    if (state.isEmpty(state.line - 1)) {\n      hasEmptyLines = true;\n    }\n\n    line = state.line;\n\n    if (line < endLine && state.isEmpty(line)) {\n      hasEmptyLines = true;\n      line++; // two empty lines should stop the parser in list mode\n\n      if (line < endLine && state.parentType === 'list' && state.isEmpty(line)) {\n        break;\n      }\n\n      state.line = line;\n    }\n  }\n};\n\nvar TABS_SCAN_RE = /[\\n\\t]/g;\nvar NEWLINES_RE = /\\r[\\n\\u0085]|[\\u2424\\u2028\\u0085]/g;\nvar SPACES_RE = /\\u00a0/g;\n/**\n * Tokenize the given `str`.\n *\n * @param  {String} `str` Source string\n * @param  {Object} `options`\n * @param  {Object} `env`\n * @param  {Array} `outTokens`\n * @api private\n */\n\nParserBlock.prototype.parse = function (str, options, env, outTokens) {\n  var state,\n      lineStart = 0,\n      lastTabPos = 0;\n\n  if (!str) {\n    return [];\n  } // Normalize spaces\n\n\n  str = str.replace(SPACES_RE, ' '); // Normalize newlines\n\n  str = str.replace(NEWLINES_RE, '\\n'); // Replace tabs with proper number of spaces (1..4)\n\n  if (str.indexOf('\\t') >= 0) {\n    str = str.replace(TABS_SCAN_RE, function (match, offset) {\n      var result;\n\n      if (str.charCodeAt(offset) === 0x0A) {\n        lineStart = offset + 1;\n        lastTabPos = 0;\n        return match;\n      }\n\n      result = '    '.slice((offset - lineStart - lastTabPos) % 4);\n      lastTabPos = offset - lineStart + 1;\n      return result;\n    });\n  }\n\n  state = new StateBlock(str, this, options, env, outTokens);\n  this.tokenize(state, state.line, state.lineMax);\n};\n/**\n * Expose `ParserBlock`\n */\n\n\nmodule.exports = ParserBlock;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * @flow\n */\n\nimport React, {Component} from 'react';\n\nimport {colors, media} from 'theme';\nimport CodeEditor from '../CodeEditor/CodeEditor';\n\ntype Props = {|\n  children: React$Node,\n  code: boolean,\n  containerNodeID: string,\n  id: string,\n  loaded: boolean,\n|};\n\nclass CodeExample extends Component<Props> {\n  render() {\n    const {children, code, id, containerNodeID, loaded} = this.props;\n    return (\n      <div\n        id={id}\n        css={{\n          marginTop: 40,\n\n          '&:first-child': {\n            marginTop: 0,\n          },\n\n          '& .react-live': {\n            width: '100%',\n          },\n\n          [media.greaterThan('xlarge')]: {\n            display: 'flex',\n            flexDirection: 'row',\n            marginTop: 80,\n          },\n\n          [media.lessThan('large')]: {\n            display: 'block',\n          },\n        }}>\n        {children && (\n          <div\n            css={{\n              flex: '0 0 33%',\n              [media.lessThan('xlarge')]: {\n                marginBottom: 20,\n              },\n\n              '& h3': {\n                color: colors.dark,\n                maxWidth: '11em',\n                paddingTop: 0,\n              },\n\n              '& p': {\n                marginTop: 15,\n                marginRight: 40,\n                lineHeight: 1.7,\n\n                [media.greaterThan('xlarge')]: {\n                  marginTop: 25,\n                },\n              },\n            }}>\n            {children}\n          </div>\n        )}\n        {loaded ? (\n          <CodeEditor code={code} containerNodeID={containerNodeID} />\n        ) : (\n          <h4>Loading code example...</h4>\n        )}\n      </div>\n    );\n  }\n}\n\nexport default CodeExample;\n","// List of valid entities\n//\n// Generate with ./support/entities.js script\n//\n'use strict';\n/*eslint quotes:0*/\n\nmodule.exports = {\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\": \">\",\n  \"Gt\": \"\\u226B\",\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\": \"<\",\n  \"Lt\": \"\\u226A\",\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};","// HTML block\n'use strict';\n\nvar block_names = require('../common/html_blocks');\n\nvar HTML_TAG_OPEN_RE = /^<([a-zA-Z]{1,15})[\\s\\/>]/;\nvar HTML_TAG_CLOSE_RE = /^<\\/([a-zA-Z]{1,15})[\\s>]/;\n\nfunction isLetter(ch) {\n  /*eslint no-bitwise:0*/\n  var lc = ch | 0x20; // to lower case\n\n  return lc >= 0x61\n  /* a */\n  && lc <= 0x7a\n  /* z */\n  ;\n}\n\nmodule.exports = function htmlblock(state, startLine, endLine, silent) {\n  var ch,\n      match,\n      nextLine,\n      pos = state.bMarks[startLine],\n      max = state.eMarks[startLine],\n      shift = state.tShift[startLine];\n  pos += shift;\n\n  if (!state.options.html) {\n    return false;\n  }\n\n  if (shift > 3 || pos + 2 >= max) {\n    return false;\n  }\n\n  if (state.src.charCodeAt(pos) !== 0x3C\n  /* < */\n  ) {\n      return false;\n    }\n\n  ch = state.src.charCodeAt(pos + 1);\n\n  if (ch === 0x21\n  /* ! */\n  || ch === 0x3F\n  /* ? */\n  ) {\n      // Directive start / comment start / processing instruction start\n      if (silent) {\n        return true;\n      }\n    } else if (ch === 0x2F\n  /* / */\n  || isLetter(ch)) {\n    // Probably start or end of tag\n    if (ch === 0x2F\n    /* \\ */\n    ) {\n        // closing tag\n        match = state.src.slice(pos, max).match(HTML_TAG_CLOSE_RE);\n\n        if (!match) {\n          return false;\n        }\n      } else {\n      // opening tag\n      match = state.src.slice(pos, max).match(HTML_TAG_OPEN_RE);\n\n      if (!match) {\n        return false;\n      }\n    } // Make sure tag name is valid\n\n\n    if (block_names[match[1].toLowerCase()] !== true) {\n      return false;\n    }\n\n    if (silent) {\n      return true;\n    }\n  } else {\n    return false;\n  } // If we are here - we detected HTML block.\n  // Let's roll down till empty line (block end).\n\n\n  nextLine = startLine + 1;\n\n  while (nextLine < state.lineMax && !state.isEmpty(nextLine)) {\n    nextLine++;\n  }\n\n  state.line = nextLine;\n  state.tokens.push({\n    type: 'htmlblock',\n    level: state.level,\n    lines: [startLine, state.line],\n    content: state.getLines(startLine, nextLine, 0, true)\n  });\n  return true;\n};","// Replace link-like texts with link nodes.\n//\n// Currently restricted by `inline.validateLink()` to http/https/ftp\n//\n'use strict';\n\nvar Autolinker = require('autolinker');\n\nvar LINK_SCAN_RE = /www|@|\\:\\/\\//;\n\nfunction isLinkOpen(str) {\n  return /^<a[>\\s]/i.test(str);\n}\n\nfunction isLinkClose(str) {\n  return /^<\\/a\\s*>/i.test(str);\n} // Stupid fabric to avoid singletons, for thread safety.\n// Required for engines like Nashorn.\n//\n\n\nfunction createLinkifier() {\n  var links = [];\n  var autolinker = new Autolinker({\n    stripPrefix: false,\n    url: true,\n    email: true,\n    twitter: false,\n    replaceFn: function replaceFn(linker, match) {\n      // Only collect matched strings but don't change anything.\n      switch (match.getType()) {\n        /*eslint default-case:0*/\n        case 'url':\n          links.push({\n            text: match.matchedText,\n            url: match.getUrl()\n          });\n          break;\n\n        case 'email':\n          links.push({\n            text: match.matchedText,\n            // normalize email protocol\n            url: 'mailto:' + match.getEmail().replace(/^mailto:/i, '')\n          });\n          break;\n      }\n\n      return false;\n    }\n  });\n  return {\n    links: links,\n    autolinker: autolinker\n  };\n}\n\nmodule.exports = function linkify(state) {\n  var i,\n      j,\n      l,\n      tokens,\n      token,\n      text,\n      nodes,\n      ln,\n      pos,\n      level,\n      htmlLinkLevel,\n      blockTokens = state.tokens,\n      linkifier = null,\n      links,\n      autolinker;\n\n  if (!state.options.linkify) {\n    return;\n  }\n\n  for (j = 0, l = blockTokens.length; j < l; j++) {\n    if (blockTokens[j].type !== 'inline') {\n      continue;\n    }\n\n    tokens = blockTokens[j].children;\n    htmlLinkLevel = 0; // We scan from the end, to keep position when new tags added.\n    // Use reversed logic in links start/end match\n\n    for (i = tokens.length - 1; i >= 0; i--) {\n      token = tokens[i]; // Skip content of markdown links\n\n      if (token.type === 'link_close') {\n        i--;\n\n        while (tokens[i].level !== token.level && tokens[i].type !== 'link_open') {\n          i--;\n        }\n\n        continue;\n      } // Skip content of html tag links\n\n\n      if (token.type === 'htmltag') {\n        if (isLinkOpen(token.content) && htmlLinkLevel > 0) {\n          htmlLinkLevel--;\n        }\n\n        if (isLinkClose(token.content)) {\n          htmlLinkLevel++;\n        }\n      }\n\n      if (htmlLinkLevel > 0) {\n        continue;\n      }\n\n      if (token.type === 'text' && LINK_SCAN_RE.test(token.content)) {\n        // Init linkifier in lazy manner, only if required.\n        if (!linkifier) {\n          linkifier = createLinkifier();\n          links = linkifier.links;\n          autolinker = linkifier.autolinker;\n        }\n\n        text = token.content;\n        links.length = 0;\n        autolinker.link(text);\n\n        if (!links.length) {\n          continue;\n        } // Now split string to nodes\n\n\n        nodes = [];\n        level = token.level;\n\n        for (ln = 0; ln < links.length; ln++) {\n          if (!state.inline.validateLink(links[ln].url)) {\n            continue;\n          }\n\n          pos = text.indexOf(links[ln].text);\n\n          if (pos) {\n            level = level;\n            nodes.push({\n              type: 'text',\n              content: text.slice(0, pos),\n              level: level\n            });\n          }\n\n          nodes.push({\n            type: 'link_open',\n            href: links[ln].url,\n            title: '',\n            level: level++\n          });\n          nodes.push({\n            type: 'text',\n            content: links[ln].text,\n            level: level\n          });\n          nodes.push({\n            type: 'link_close',\n            level: --level\n          });\n          text = text.slice(pos + links[ln].text.length);\n        }\n\n        if (text.length) {\n          nodes.push({\n            type: 'text',\n            content: text,\n            level: level\n          });\n        } // replace current node\n\n\n        blockTokens[j].children = tokens = [].concat(tokens.slice(0, i), nodes, tokens.slice(i + 1));\n      }\n    }\n  }\n};","/*!\n * Autolinker.js\n * 0.28.1\n *\n * Copyright(c) 2016 Gregory Jacobs <greg@greg-jacobs.com>\n * MIT License\n *\n * https://github.com/gregjacobs/Autolinker.js\n */\n;\n\n(function (root, factory) {\n  if (typeof define === 'function' && define.amd) {\n    define([], factory);\n  } else if (typeof exports === 'object') {\n    module.exports = factory();\n  } else {\n    root.Autolinker = factory();\n  }\n})(this, function () {\n  /**\n   * @class Autolinker\n   * @extends Object\n   *\n   * Utility class used to process a given string of text, and wrap the matches in\n   * the appropriate anchor (&lt;a&gt;) tags to turn them into links.\n   *\n   * Any of the configuration options may be provided in an Object (map) provided\n   * to the Autolinker constructor, which will configure how the {@link #link link()}\n   * method will process the links.\n   *\n   * For example:\n   *\n   *     var autolinker = new Autolinker( {\n   *         newWindow : false,\n   *         truncate  : 30\n   *     } );\n   *\n   *     var html = autolinker.link( \"Joe went to www.yahoo.com\" );\n   *     // produces: 'Joe went to <a href=\"http://www.yahoo.com\">yahoo.com</a>'\n   *\n   *\n   * The {@link #static-link static link()} method may also be used to inline\n   * options into a single call, which may be more convenient for one-off uses.\n   * For example:\n   *\n   *     var html = Autolinker.link( \"Joe went to www.yahoo.com\", {\n   *         newWindow : false,\n   *         truncate  : 30\n   *     } );\n   *     // produces: 'Joe went to <a href=\"http://www.yahoo.com\">yahoo.com</a>'\n   *\n   *\n   * ## Custom Replacements of Links\n   *\n   * If the configuration options do not provide enough flexibility, a {@link #replaceFn}\n   * may be provided to fully customize the output of Autolinker. This function is\n   * called once for each URL/Email/Phone#/Twitter Handle/Hashtag match that is\n   * encountered.\n   *\n   * For example:\n   *\n   *     var input = \"...\";  // string with URLs, Email Addresses, Phone #s, Twitter Handles, and Hashtags\n   *\n   *     var linkedText = Autolinker.link( input, {\n   *         replaceFn : function( autolinker, match ) {\n   *             console.log( \"href = \", match.getAnchorHref() );\n   *             console.log( \"text = \", match.getAnchorText() );\n   *\n   *             switch( match.getType() ) {\n   *                 case 'url' :\n   *                     console.log( \"url: \", match.getUrl() );\n   *\n   *                     if( match.getUrl().indexOf( 'mysite.com' ) === -1 ) {\n   *                         var tag = autolinker.getTagBuilder().build( match );  // returns an `Autolinker.HtmlTag` instance, which provides mutator methods for easy changes\n   *                         tag.setAttr( 'rel', 'nofollow' );\n   *                         tag.addClass( 'external-link' );\n   *\n   *                         return tag;\n   *\n   *                     } else {\n   *                         return true;  // let Autolinker perform its normal anchor tag replacement\n   *                     }\n   *\n   *                 case 'email' :\n   *                     var email = match.getEmail();\n   *                     console.log( \"email: \", email );\n   *\n   *                     if( email === \"my@own.address\" ) {\n   *                         return false;  // don't auto-link this particular email address; leave as-is\n   *                     } else {\n   *                         return;  // no return value will have Autolinker perform its normal anchor tag replacement (same as returning `true`)\n   *                     }\n   *\n   *                 case 'phone' :\n   *                     var phoneNumber = match.getPhoneNumber();\n   *                     console.log( phoneNumber );\n   *\n   *                     return '<a href=\"http://newplace.to.link.phone.numbers.to/\">' + phoneNumber + '</a>';\n   *\n   *                 case 'twitter' :\n   *                     var twitterHandle = match.getTwitterHandle();\n   *                     console.log( twitterHandle );\n   *\n   *                     return '<a href=\"http://newplace.to.link.twitter.handles.to/\">' + twitterHandle + '</a>';\n   *\n   *                 case 'hashtag' :\n   *                     var hashtag = match.getHashtag();\n   *                     console.log( hashtag );\n   *\n   *                     return '<a href=\"http://newplace.to.link.hashtag.handles.to/\">' + hashtag + '</a>';\n   *             }\n   *         }\n   *     } );\n   *\n   *\n   * The function may return the following values:\n   *\n   * - `true` (Boolean): Allow Autolinker to replace the match as it normally\n   *   would.\n   * - `false` (Boolean): Do not replace the current match at all - leave as-is.\n   * - Any String: If a string is returned from the function, the string will be\n   *   used directly as the replacement HTML for the match.\n   * - An {@link Autolinker.HtmlTag} instance, which can be used to build/modify\n   *   an HTML tag before writing out its HTML text.\n   *\n   * @constructor\n   * @param {Object} [cfg] The configuration options for the Autolinker instance,\n   *   specified in an Object (map).\n   */\n  var Autolinker = function Autolinker(cfg) {\n    cfg = cfg || {};\n    this.version = Autolinker.version;\n    this.urls = this.normalizeUrlsCfg(cfg.urls);\n    this.email = typeof cfg.email === 'boolean' ? cfg.email : true;\n    this.twitter = typeof cfg.twitter === 'boolean' ? cfg.twitter : true;\n    this.phone = typeof cfg.phone === 'boolean' ? cfg.phone : true;\n    this.hashtag = cfg.hashtag || false;\n    this.newWindow = typeof cfg.newWindow === 'boolean' ? cfg.newWindow : true;\n    this.stripPrefix = typeof cfg.stripPrefix === 'boolean' ? cfg.stripPrefix : true; // Validate the value of the `hashtag` cfg.\n\n    var hashtag = this.hashtag;\n\n    if (hashtag !== false && hashtag !== 'twitter' && hashtag !== 'facebook' && hashtag !== 'instagram') {\n      throw new Error(\"invalid `hashtag` cfg - see docs\");\n    }\n\n    this.truncate = this.normalizeTruncateCfg(cfg.truncate);\n    this.className = cfg.className || '';\n    this.replaceFn = cfg.replaceFn || null;\n    this.htmlParser = null;\n    this.matchers = null;\n    this.tagBuilder = null;\n  };\n  /**\n   * Automatically links URLs, Email addresses, Phone Numbers, Twitter handles,\n   * and Hashtags found in the given chunk of HTML. Does not link URLs found\n   * within HTML tags.\n   *\n   * For instance, if given the text: `You should go to http://www.yahoo.com`,\n   * then the result will be `You should go to &lt;a href=\"http://www.yahoo.com\"&gt;http://www.yahoo.com&lt;/a&gt;`\n   *\n   * Example:\n   *\n   *     var linkedText = Autolinker.link( \"Go to google.com\", { newWindow: false } );\n   *     // Produces: \"Go to <a href=\"http://google.com\">google.com</a>\"\n   *\n   * @static\n   * @param {String} textOrHtml The HTML or text to find matches within (depending\n   *   on if the {@link #urls}, {@link #email}, {@link #phone}, {@link #twitter},\n   *   and {@link #hashtag} options are enabled).\n   * @param {Object} [options] Any of the configuration options for the Autolinker\n   *   class, specified in an Object (map). See the class description for an\n   *   example call.\n   * @return {String} The HTML text, with matches automatically linked.\n   */\n\n\n  Autolinker.link = function (textOrHtml, options) {\n    var autolinker = new Autolinker(options);\n    return autolinker.link(textOrHtml);\n  };\n  /**\n   * @static\n   * @property {String} version (readonly)\n   *\n   * The Autolinker version number in the form major.minor.patch\n   *\n   * Ex: 0.25.1\n   */\n\n\n  Autolinker.version = '0.28.1';\n  Autolinker.prototype = {\n    constructor: Autolinker,\n    // fix constructor property\n\n    /**\n     * @cfg {Boolean/Object} [urls=true]\n     *\n     * `true` if URLs should be automatically linked, `false` if they should not\n     * be.\n     *\n     * This option also accepts an Object form with 3 properties, to allow for\n     * more customization of what exactly gets linked. All default to `true`:\n     *\n     * @param {Boolean} schemeMatches `true` to match URLs found prefixed with a\n     *   scheme, i.e. `http://google.com`, or `other+scheme://google.com`,\n     *   `false` to prevent these types of matches.\n     * @param {Boolean} wwwMatches `true` to match urls found prefixed with\n     *   `'www.'`, i.e. `www.google.com`. `false` to prevent these types of\n     *   matches. Note that if the URL had a prefixed scheme, and\n     *   `schemeMatches` is true, it will still be linked.\n     * @param {Boolean} tldMatches `true` to match URLs with known top level\n     *   domains (.com, .net, etc.) that are not prefixed with a scheme or\n     *   `'www.'`. This option attempts to match anything that looks like a URL\n     *   in the given text. Ex: `google.com`, `asdf.org/?page=1`, etc. `false`\n     *   to prevent these types of matches.\n     */\n\n    /**\n     * @cfg {Boolean} [email=true]\n     *\n     * `true` if email addresses should be automatically linked, `false` if they\n     * should not be.\n     */\n\n    /**\n     * @cfg {Boolean} [twitter=true]\n     *\n     * `true` if Twitter handles (\"@example\") should be automatically linked,\n     * `false` if they should not be.\n     */\n\n    /**\n     * @cfg {Boolean} [phone=true]\n     *\n     * `true` if Phone numbers (\"(555)555-5555\") should be automatically linked,\n     * `false` if they should not be.\n     */\n\n    /**\n     * @cfg {Boolean/String} [hashtag=false]\n     *\n     * A string for the service name to have hashtags (ex: \"#myHashtag\")\n     * auto-linked to. The currently-supported values are:\n     *\n     * - 'twitter'\n     * - 'facebook'\n     * - 'instagram'\n     *\n     * Pass `false` to skip auto-linking of hashtags.\n     */\n\n    /**\n     * @cfg {Boolean} [newWindow=true]\n     *\n     * `true` if the links should open in a new window, `false` otherwise.\n     */\n\n    /**\n     * @cfg {Boolean} [stripPrefix=true]\n     *\n     * `true` if 'http://' or 'https://' and/or the 'www.' should be stripped\n     * from the beginning of URL links' text, `false` otherwise.\n     */\n\n    /**\n     * @cfg {Number/Object} [truncate=0]\n     *\n     * ## Number Form\n     *\n     * A number for how many characters matched text should be truncated to\n     * inside the text of a link. If the matched text is over this number of\n     * characters, it will be truncated to this length by adding a two period\n     * ellipsis ('..') to the end of the string.\n     *\n     * For example: A url like 'http://www.yahoo.com/some/long/path/to/a/file'\n     * truncated to 25 characters might look something like this:\n     * 'yahoo.com/some/long/pat..'\n     *\n     * Example Usage:\n     *\n     *     truncate: 25\n     *\n     *\n     *  Defaults to `0` for \"no truncation.\"\n     *\n     *\n     * ## Object Form\n     *\n     * An Object may also be provided with two properties: `length` (Number) and\n     * `location` (String). `location` may be one of the following: 'end'\n     * (default), 'middle', or 'smart'.\n     *\n     * Example Usage:\n     *\n     *     truncate: { length: 25, location: 'middle' }\n     *\n     * @cfg {Number} [truncate.length=0] How many characters to allow before\n     *   truncation will occur. Defaults to `0` for \"no truncation.\"\n     * @cfg {\"end\"/\"middle\"/\"smart\"} [truncate.location=\"end\"]\n     *\n     * - 'end' (default): will truncate up to the number of characters, and then\n     *   add an ellipsis at the end. Ex: 'yahoo.com/some/long/pat..'\n     * - 'middle': will truncate and add the ellipsis in the middle. Ex:\n     *   'yahoo.com/s..th/to/a/file'\n     * - 'smart': for URLs where the algorithm attempts to strip out unnecessary\n     *   parts first (such as the 'www.', then URL scheme, hash, etc.),\n     *   attempting to make the URL human-readable before looking for a good\n     *   point to insert the ellipsis if it is still too long. Ex:\n     *   'yahoo.com/some..to/a/file'. For more details, see\n     *   {@link Autolinker.truncate.TruncateSmart}.\n     */\n\n    /**\n     * @cfg {String} className\n     *\n     * A CSS class name to add to the generated links. This class will be added\n     * to all links, as well as this class plus match suffixes for styling\n     * url/email/phone/twitter/hashtag links differently.\n     *\n     * For example, if this config is provided as \"myLink\", then:\n     *\n     * - URL links will have the CSS classes: \"myLink myLink-url\"\n     * - Email links will have the CSS classes: \"myLink myLink-email\", and\n     * - Twitter links will have the CSS classes: \"myLink myLink-twitter\"\n     * - Phone links will have the CSS classes: \"myLink myLink-phone\"\n     * - Hashtag links will have the CSS classes: \"myLink myLink-hashtag\"\n     */\n\n    /**\n     * @cfg {Function} replaceFn\n     *\n     * A function to individually process each match found in the input string.\n     *\n     * See the class's description for usage.\n     *\n     * This function is called with the following parameters:\n     *\n     * @cfg {Autolinker} replaceFn.autolinker The Autolinker instance, which may\n     *   be used to retrieve child objects from (such as the instance's\n     *   {@link #getTagBuilder tag builder}).\n     * @cfg {Autolinker.match.Match} replaceFn.match The Match instance which\n     *   can be used to retrieve information about the match that the `replaceFn`\n     *   is currently processing. See {@link Autolinker.match.Match} subclasses\n     *   for details.\n     */\n\n    /**\n     * @property {String} version (readonly)\n     *\n     * The Autolinker version number in the form major.minor.patch\n     *\n     * Ex: 0.25.1\n     */\n\n    /**\n     * @private\n     * @property {Autolinker.htmlParser.HtmlParser} htmlParser\n     *\n     * The HtmlParser instance used to skip over HTML tags, while finding text\n     * nodes to process. This is lazily instantiated in the {@link #getHtmlParser}\n     * method.\n     */\n\n    /**\n     * @private\n     * @property {Autolinker.matcher.Matcher[]} matchers\n     *\n     * The {@link Autolinker.matcher.Matcher} instances for this Autolinker\n     * instance.\n     *\n     * This is lazily created in {@link #getMatchers}.\n     */\n\n    /**\n     * @private\n     * @property {Autolinker.AnchorTagBuilder} tagBuilder\n     *\n     * The AnchorTagBuilder instance used to build match replacement anchor tags.\n     * Note: this is lazily instantiated in the {@link #getTagBuilder} method.\n     */\n\n    /**\n     * Normalizes the {@link #urls} config into an Object with 3 properties:\n     * `schemeMatches`, `wwwMatches`, and `tldMatches`, all Booleans.\n     *\n     * See {@link #urls} config for details.\n     *\n     * @private\n     * @param {Boolean/Object} urls\n     * @return {Object}\n     */\n    normalizeUrlsCfg: function normalizeUrlsCfg(urls) {\n      if (urls == null) urls = true; // default to `true`\n\n      if (typeof urls === 'boolean') {\n        return {\n          schemeMatches: urls,\n          wwwMatches: urls,\n          tldMatches: urls\n        };\n      } else {\n        // object form\n        return {\n          schemeMatches: typeof urls.schemeMatches === 'boolean' ? urls.schemeMatches : true,\n          wwwMatches: typeof urls.wwwMatches === 'boolean' ? urls.wwwMatches : true,\n          tldMatches: typeof urls.tldMatches === 'boolean' ? urls.tldMatches : true\n        };\n      }\n    },\n\n    /**\n     * Normalizes the {@link #truncate} config into an Object with 2 properties:\n     * `length` (Number), and `location` (String).\n     *\n     * See {@link #truncate} config for details.\n     *\n     * @private\n     * @param {Number/Object} truncate\n     * @return {Object}\n     */\n    normalizeTruncateCfg: function normalizeTruncateCfg(truncate) {\n      if (typeof truncate === 'number') {\n        return {\n          length: truncate,\n          location: 'end'\n        };\n      } else {\n        // object, or undefined/null\n        return Autolinker.Util.defaults(truncate || {}, {\n          length: Number.POSITIVE_INFINITY,\n          location: 'end'\n        });\n      }\n    },\n\n    /**\n     * Parses the input `textOrHtml` looking for URLs, email addresses, phone\n     * numbers, username handles, and hashtags (depending on the configuration\n     * of the Autolinker instance), and returns an array of {@link Autolinker.match.Match}\n     * objects describing those matches.\n     *\n     * This method is used by the {@link #link} method, but can also be used to\n     * simply do parsing of the input in order to discover what kinds of links\n     * there are and how many.\n     *\n     * @param {String} textOrHtml The HTML or text to find matches within\n     *   (depending on if the {@link #urls}, {@link #email}, {@link #phone},\n     *   {@link #twitter}, and {@link #hashtag} options are enabled).\n     * @return {Autolinker.match.Match[]} The array of Matches found in the\n     *   given input `textOrHtml`.\n     */\n    parse: function parse(textOrHtml) {\n      var htmlParser = this.getHtmlParser(),\n          htmlNodes = htmlParser.parse(textOrHtml),\n          anchorTagStackCount = 0,\n          // used to only process text around anchor tags, and any inner text/html they may have;\n      matches = []; // Find all matches within the `textOrHtml` (but not matches that are\n      // already nested within <a> tags)\n\n      for (var i = 0, len = htmlNodes.length; i < len; i++) {\n        var node = htmlNodes[i],\n            nodeType = node.getType();\n\n        if (nodeType === 'element' && node.getTagName() === 'a') {\n          // Process HTML anchor element nodes in the input `textOrHtml` to find out when we're within an <a> tag\n          if (!node.isClosing()) {\n            // it's the start <a> tag\n            anchorTagStackCount++;\n          } else {\n            // it's the end </a> tag\n            anchorTagStackCount = Math.max(anchorTagStackCount - 1, 0); // attempt to handle extraneous </a> tags by making sure the stack count never goes below 0\n          }\n        } else if (nodeType === 'text' && anchorTagStackCount === 0) {\n          // Process text nodes that are not within an <a> tag\n          var textNodeMatches = this.parseText(node.getText(), node.getOffset());\n          matches.push.apply(matches, textNodeMatches);\n        }\n      } // After we have found all matches, remove subsequent matches that\n      // overlap with a previous match. This can happen for instance with URLs,\n      // where the url 'google.com/#link' would match '#link' as a hashtag.\n\n\n      matches = this.compactMatches(matches); // And finally, remove matches for match types that have been turned\n      // off. We needed to have all match types turned on initially so that\n      // things like hashtags could be filtered out if they were really just\n      // part of a URL match (for instance, as a named anchor).\n\n      matches = this.removeUnwantedMatches(matches);\n      return matches;\n    },\n\n    /**\n     * After we have found all matches, we need to remove subsequent matches\n     * that overlap with a previous match. This can happen for instance with\n     * URLs, where the url 'google.com/#link' would match '#link' as a hashtag.\n     *\n     * @private\n     * @param {Autolinker.match.Match[]} matches\n     * @return {Autolinker.match.Match[]}\n     */\n    compactMatches: function compactMatches(matches) {\n      // First, the matches need to be sorted in order of offset\n      matches.sort(function (a, b) {\n        return a.getOffset() - b.getOffset();\n      });\n\n      for (var i = 0; i < matches.length - 1; i++) {\n        var match = matches[i],\n            endIdx = match.getOffset() + match.getMatchedText().length; // Remove subsequent matches that overlap with the current match\n\n        while (i + 1 < matches.length && matches[i + 1].getOffset() <= endIdx) {\n          matches.splice(i + 1, 1);\n        }\n      }\n\n      return matches;\n    },\n\n    /**\n     * Removes matches for matchers that were turned off in the options. For\n     * example, if {@link #hashtag hashtags} were not to be matched, we'll\n     * remove them from the `matches` array here.\n     *\n     * @private\n     * @param {Autolinker.match.Match[]} matches The array of matches to remove\n     *   the unwanted matches from. Note: this array is mutated for the\n     *   removals.\n     * @return {Autolinker.match.Match[]} The mutated input `matches` array.\n     */\n    removeUnwantedMatches: function removeUnwantedMatches(matches) {\n      var remove = Autolinker.Util.remove;\n      if (!this.hashtag) remove(matches, function (match) {\n        return match.getType() === 'hashtag';\n      });\n      if (!this.email) remove(matches, function (match) {\n        return match.getType() === 'email';\n      });\n      if (!this.phone) remove(matches, function (match) {\n        return match.getType() === 'phone';\n      });\n      if (!this.twitter) remove(matches, function (match) {\n        return match.getType() === 'twitter';\n      });\n\n      if (!this.urls.schemeMatches) {\n        remove(matches, function (m) {\n          return m.getType() === 'url' && m.getUrlMatchType() === 'scheme';\n        });\n      }\n\n      if (!this.urls.wwwMatches) {\n        remove(matches, function (m) {\n          return m.getType() === 'url' && m.getUrlMatchType() === 'www';\n        });\n      }\n\n      if (!this.urls.tldMatches) {\n        remove(matches, function (m) {\n          return m.getType() === 'url' && m.getUrlMatchType() === 'tld';\n        });\n      }\n\n      return matches;\n    },\n\n    /**\n     * Parses the input `text` looking for URLs, email addresses, phone\n     * numbers, username handles, and hashtags (depending on the configuration\n     * of the Autolinker instance), and returns an array of {@link Autolinker.match.Match}\n     * objects describing those matches.\n     *\n     * This method processes a **non-HTML string**, and is used to parse and\n     * match within the text nodes of an HTML string. This method is used\n     * internally by {@link #parse}.\n     *\n     * @private\n     * @param {String} text The text to find matches within (depending on if the\n     *   {@link #urls}, {@link #email}, {@link #phone}, {@link #twitter}, and\n     *   {@link #hashtag} options are enabled). This must be a non-HTML string.\n     * @param {Number} [offset=0] The offset of the text node within the\n     *   original string. This is used when parsing with the {@link #parse}\n     *   method to generate correct offsets within the {@link Autolinker.match.Match}\n     *   instances, but may be omitted if calling this method publicly.\n     * @return {Autolinker.match.Match[]} The array of Matches found in the\n     *   given input `text`.\n     */\n    parseText: function parseText(text, offset) {\n      offset = offset || 0;\n      var matchers = this.getMatchers(),\n          matches = [];\n\n      for (var i = 0, numMatchers = matchers.length; i < numMatchers; i++) {\n        var textMatches = matchers[i].parseMatches(text); // Correct the offset of each of the matches. They are originally\n        // the offset of the match within the provided text node, but we\n        // need to correct them to be relative to the original HTML input\n        // string (i.e. the one provided to #parse).\n\n        for (var j = 0, numTextMatches = textMatches.length; j < numTextMatches; j++) {\n          textMatches[j].setOffset(offset + textMatches[j].getOffset());\n        }\n\n        matches.push.apply(matches, textMatches);\n      }\n\n      return matches;\n    },\n\n    /**\n     * Automatically links URLs, Email addresses, Phone numbers, Twitter\n     * handles, and Hashtags found in the given chunk of HTML. Does not link\n     * URLs found within HTML tags.\n     *\n     * For instance, if given the text: `You should go to http://www.yahoo.com`,\n     * then the result will be `You should go to\n     * &lt;a href=\"http://www.yahoo.com\"&gt;http://www.yahoo.com&lt;/a&gt;`\n     *\n     * This method finds the text around any HTML elements in the input\n     * `textOrHtml`, which will be the text that is processed. Any original HTML\n     * elements will be left as-is, as well as the text that is already wrapped\n     * in anchor (&lt;a&gt;) tags.\n     *\n     * @param {String} textOrHtml The HTML or text to autolink matches within\n     *   (depending on if the {@link #urls}, {@link #email}, {@link #phone},\n     *   {@link #twitter}, and {@link #hashtag} options are enabled).\n     * @return {String} The HTML, with matches automatically linked.\n     */\n    link: function link(textOrHtml) {\n      if (!textOrHtml) {\n        return \"\";\n      } // handle `null` and `undefined`\n\n\n      var matches = this.parse(textOrHtml),\n          newHtml = [],\n          lastIndex = 0;\n\n      for (var i = 0, len = matches.length; i < len; i++) {\n        var match = matches[i];\n        newHtml.push(textOrHtml.substring(lastIndex, match.getOffset()));\n        newHtml.push(this.createMatchReturnVal(match));\n        lastIndex = match.getOffset() + match.getMatchedText().length;\n      }\n\n      newHtml.push(textOrHtml.substring(lastIndex)); // handle the text after the last match\n\n      return newHtml.join('');\n    },\n\n    /**\n     * Creates the return string value for a given match in the input string.\n     *\n     * This method handles the {@link #replaceFn}, if one was provided.\n     *\n     * @private\n     * @param {Autolinker.match.Match} match The Match object that represents\n     *   the match.\n     * @return {String} The string that the `match` should be replaced with.\n     *   This is usually the anchor tag string, but may be the `matchStr` itself\n     *   if the match is not to be replaced.\n     */\n    createMatchReturnVal: function createMatchReturnVal(match) {\n      // Handle a custom `replaceFn` being provided\n      var replaceFnResult;\n\n      if (this.replaceFn) {\n        replaceFnResult = this.replaceFn.call(this, this, match); // Autolinker instance is the context, and the first arg\n      }\n\n      if (typeof replaceFnResult === 'string') {\n        return replaceFnResult; // `replaceFn` returned a string, use that\n      } else if (replaceFnResult === false) {\n        return match.getMatchedText(); // no replacement for the match\n      } else if (replaceFnResult instanceof Autolinker.HtmlTag) {\n        return replaceFnResult.toAnchorString();\n      } else {\n        // replaceFnResult === true, or no/unknown return value from function\n        // Perform Autolinker's default anchor tag generation\n        var anchorTag = match.buildTag(); // returns an Autolinker.HtmlTag instance\n\n        return anchorTag.toAnchorString();\n      }\n    },\n\n    /**\n     * Lazily instantiates and returns the {@link #htmlParser} instance for this\n     * Autolinker instance.\n     *\n     * @protected\n     * @return {Autolinker.htmlParser.HtmlParser}\n     */\n    getHtmlParser: function getHtmlParser() {\n      var htmlParser = this.htmlParser;\n\n      if (!htmlParser) {\n        htmlParser = this.htmlParser = new Autolinker.htmlParser.HtmlParser();\n      }\n\n      return htmlParser;\n    },\n\n    /**\n     * Lazily instantiates and returns the {@link Autolinker.matcher.Matcher}\n     * instances for this Autolinker instance.\n     *\n     * @protected\n     * @return {Autolinker.matcher.Matcher[]}\n     */\n    getMatchers: function getMatchers() {\n      if (!this.matchers) {\n        var matchersNs = Autolinker.matcher,\n            tagBuilder = this.getTagBuilder();\n        var matchers = [new matchersNs.Hashtag({\n          tagBuilder: tagBuilder,\n          serviceName: this.hashtag\n        }), new matchersNs.Email({\n          tagBuilder: tagBuilder\n        }), new matchersNs.Phone({\n          tagBuilder: tagBuilder\n        }), new matchersNs.Twitter({\n          tagBuilder: tagBuilder\n        }), new matchersNs.Url({\n          tagBuilder: tagBuilder,\n          stripPrefix: this.stripPrefix\n        })];\n        return this.matchers = matchers;\n      } else {\n        return this.matchers;\n      }\n    },\n\n    /**\n     * Returns the {@link #tagBuilder} instance for this Autolinker instance, lazily instantiating it\n     * if it does not yet exist.\n     *\n     * This method may be used in a {@link #replaceFn} to generate the {@link Autolinker.HtmlTag HtmlTag} instance that\n     * Autolinker would normally generate, and then allow for modifications before returning it. For example:\n     *\n     *     var html = Autolinker.link( \"Test google.com\", {\n     *         replaceFn : function( autolinker, match ) {\n     *             var tag = autolinker.getTagBuilder().build( match );  // returns an {@link Autolinker.HtmlTag} instance\n     *             tag.setAttr( 'rel', 'nofollow' );\n     *\n     *             return tag;\n     *         }\n     *     } );\n     *\n     *     // generated html:\n     *     //   Test <a href=\"http://google.com\" target=\"_blank\" rel=\"nofollow\">google.com</a>\n     *\n     * @return {Autolinker.AnchorTagBuilder}\n     */\n    getTagBuilder: function getTagBuilder() {\n      var tagBuilder = this.tagBuilder;\n\n      if (!tagBuilder) {\n        tagBuilder = this.tagBuilder = new Autolinker.AnchorTagBuilder({\n          newWindow: this.newWindow,\n          truncate: this.truncate,\n          className: this.className\n        });\n      }\n\n      return tagBuilder;\n    }\n  }; // Autolinker Namespaces\n\n  Autolinker.match = {};\n  Autolinker.matcher = {};\n  Autolinker.htmlParser = {};\n  Autolinker.truncate = {};\n  /*global Autolinker */\n\n  /*jshint eqnull:true, boss:true */\n\n  /**\n   * @class Autolinker.Util\n   * @singleton\n   *\n   * A few utility methods for Autolinker.\n   */\n\n  Autolinker.Util = {\n    /**\n     * @property {Function} abstractMethod\n     *\n     * A function object which represents an abstract method.\n     */\n    abstractMethod: function abstractMethod() {\n      throw \"abstract\";\n    },\n\n    /**\n     * @private\n     * @property {RegExp} trimRegex\n     *\n     * The regular expression used to trim the leading and trailing whitespace\n     * from a string.\n     */\n    trimRegex: /^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g,\n\n    /**\n     * Assigns (shallow copies) the properties of `src` onto `dest`.\n     *\n     * @param {Object} dest The destination object.\n     * @param {Object} src The source object.\n     * @return {Object} The destination object (`dest`)\n     */\n    assign: function assign(dest, src) {\n      for (var prop in src) {\n        if (src.hasOwnProperty(prop)) {\n          dest[prop] = src[prop];\n        }\n      }\n\n      return dest;\n    },\n\n    /**\n     * Assigns (shallow copies) the properties of `src` onto `dest`, if the\n     * corresponding property on `dest` === `undefined`.\n     *\n     * @param {Object} dest The destination object.\n     * @param {Object} src The source object.\n     * @return {Object} The destination object (`dest`)\n     */\n    defaults: function defaults(dest, src) {\n      for (var prop in src) {\n        if (src.hasOwnProperty(prop) && dest[prop] === undefined) {\n          dest[prop] = src[prop];\n        }\n      }\n\n      return dest;\n    },\n\n    /**\n     * Extends `superclass` to create a new subclass, adding the `protoProps` to the new subclass's prototype.\n     *\n     * @param {Function} superclass The constructor function for the superclass.\n     * @param {Object} protoProps The methods/properties to add to the subclass's prototype. This may contain the\n     *   special property `constructor`, which will be used as the new subclass's constructor function.\n     * @return {Function} The new subclass function.\n     */\n    extend: function extend(superclass, protoProps) {\n      var superclassProto = superclass.prototype;\n\n      var F = function F() {};\n\n      F.prototype = superclassProto;\n      var subclass;\n\n      if (protoProps.hasOwnProperty('constructor')) {\n        subclass = protoProps.constructor;\n      } else {\n        subclass = function subclass() {\n          superclassProto.constructor.apply(this, arguments);\n        };\n      }\n\n      var subclassProto = subclass.prototype = new F(); // set up prototype chain\n\n      subclassProto.constructor = subclass; // fix constructor property\n\n      subclassProto.superclass = superclassProto;\n      delete protoProps.constructor; // don't re-assign constructor property to the prototype, since a new function may have been created (`subclass`), which is now already there\n\n      Autolinker.Util.assign(subclassProto, protoProps);\n      return subclass;\n    },\n\n    /**\n     * Truncates the `str` at `len - ellipsisChars.length`, and adds the `ellipsisChars` to the\n     * end of the string (by default, two periods: '..'). If the `str` length does not exceed\n     * `len`, the string will be returned unchanged.\n     *\n     * @param {String} str The string to truncate and add an ellipsis to.\n     * @param {Number} truncateLen The length to truncate the string at.\n     * @param {String} [ellipsisChars=..] The ellipsis character(s) to add to the end of `str`\n     *   when truncated. Defaults to '..'\n     */\n    ellipsis: function ellipsis(str, truncateLen, ellipsisChars) {\n      if (str.length > truncateLen) {\n        ellipsisChars = ellipsisChars == null ? '..' : ellipsisChars;\n        str = str.substring(0, truncateLen - ellipsisChars.length) + ellipsisChars;\n      }\n\n      return str;\n    },\n\n    /**\n     * Supports `Array.prototype.indexOf()` functionality for old IE (IE8 and below).\n     *\n     * @param {Array} arr The array to find an element of.\n     * @param {*} element The element to find in the array, and return the index of.\n     * @return {Number} The index of the `element`, or -1 if it was not found.\n     */\n    indexOf: function indexOf(arr, element) {\n      if (Array.prototype.indexOf) {\n        return arr.indexOf(element);\n      } else {\n        for (var i = 0, len = arr.length; i < len; i++) {\n          if (arr[i] === element) return i;\n        }\n\n        return -1;\n      }\n    },\n\n    /**\n     * Removes array elements based on a filtering function. Mutates the input\n     * array.\n     *\n     * Using this instead of the ES5 Array.prototype.filter() function, to allow\n     * Autolinker compatibility with IE8, and also to prevent creating many new\n     * arrays in memory for filtering.\n     *\n     * @param {Array} arr The array to remove elements from. This array is\n     *   mutated.\n     * @param {Function} fn A function which should return `true` to\n     *   remove an element.\n     * @return {Array} The mutated input `arr`.\n     */\n    remove: function remove(arr, fn) {\n      for (var i = arr.length - 1; i >= 0; i--) {\n        if (fn(arr[i]) === true) {\n          arr.splice(i, 1);\n        }\n      }\n    },\n\n    /**\n     * Performs the functionality of what modern browsers do when `String.prototype.split()` is called\n     * with a regular expression that contains capturing parenthesis.\n     *\n     * For example:\n     *\n     *     // Modern browsers:\n     *     \"a,b,c\".split( /(,)/ );  // --> [ 'a', ',', 'b', ',', 'c' ]\n     *\n     *     // Old IE (including IE8):\n     *     \"a,b,c\".split( /(,)/ );  // --> [ 'a', 'b', 'c' ]\n     *\n     * This method emulates the functionality of modern browsers for the old IE case.\n     *\n     * @param {String} str The string to split.\n     * @param {RegExp} splitRegex The regular expression to split the input `str` on. The splitting\n     *   character(s) will be spliced into the array, as in the \"modern browsers\" example in the\n     *   description of this method.\n     *   Note #1: the supplied regular expression **must** have the 'g' flag specified.\n     *   Note #2: for simplicity's sake, the regular expression does not need\n     *   to contain capturing parenthesis - it will be assumed that any match has them.\n     * @return {String[]} The split array of strings, with the splitting character(s) included.\n     */\n    splitAndCapture: function splitAndCapture(str, splitRegex) {\n      if (!splitRegex.global) throw new Error(\"`splitRegex` must have the 'g' flag set\");\n      var result = [],\n          lastIdx = 0,\n          match;\n\n      while (match = splitRegex.exec(str)) {\n        result.push(str.substring(lastIdx, match.index));\n        result.push(match[0]); // push the splitting char(s)\n\n        lastIdx = match.index + match[0].length;\n      }\n\n      result.push(str.substring(lastIdx));\n      return result;\n    },\n\n    /**\n     * Trims the leading and trailing whitespace from a string.\n     *\n     * @param {String} str The string to trim.\n     * @return {String}\n     */\n    trim: function trim(str) {\n      return str.replace(this.trimRegex, '');\n    }\n  };\n  /*global Autolinker */\n\n  /*jshint boss:true */\n\n  /**\n   * @class Autolinker.HtmlTag\n   * @extends Object\n   *\n   * Represents an HTML tag, which can be used to easily build/modify HTML tags programmatically.\n   *\n   * Autolinker uses this abstraction to create HTML tags, and then write them out as strings. You may also use\n   * this class in your code, especially within a {@link Autolinker#replaceFn replaceFn}.\n   *\n   * ## Examples\n   *\n   * Example instantiation:\n   *\n   *     var tag = new Autolinker.HtmlTag( {\n   *         tagName : 'a',\n   *         attrs   : { 'href': 'http://google.com', 'class': 'external-link' },\n   *         innerHtml : 'Google'\n   *     } );\n   *\n   *     tag.toAnchorString();  // <a href=\"http://google.com\" class=\"external-link\">Google</a>\n   *\n   *     // Individual accessor methods\n   *     tag.getTagName();                 // 'a'\n   *     tag.getAttr( 'href' );            // 'http://google.com'\n   *     tag.hasClass( 'external-link' );  // true\n   *\n   *\n   * Using mutator methods (which may be used in combination with instantiation config properties):\n   *\n   *     var tag = new Autolinker.HtmlTag();\n   *     tag.setTagName( 'a' );\n   *     tag.setAttr( 'href', 'http://google.com' );\n   *     tag.addClass( 'external-link' );\n   *     tag.setInnerHtml( 'Google' );\n   *\n   *     tag.getTagName();                 // 'a'\n   *     tag.getAttr( 'href' );            // 'http://google.com'\n   *     tag.hasClass( 'external-link' );  // true\n   *\n   *     tag.toAnchorString();  // <a href=\"http://google.com\" class=\"external-link\">Google</a>\n   *\n   *\n   * ## Example use within a {@link Autolinker#replaceFn replaceFn}\n   *\n   *     var html = Autolinker.link( \"Test google.com\", {\n   *         replaceFn : function( autolinker, match ) {\n   *             var tag = match.buildTag();  // returns an {@link Autolinker.HtmlTag} instance, configured with the Match's href and anchor text\n   *             tag.setAttr( 'rel', 'nofollow' );\n   *\n   *             return tag;\n   *         }\n   *     } );\n   *\n   *     // generated html:\n   *     //   Test <a href=\"http://google.com\" target=\"_blank\" rel=\"nofollow\">google.com</a>\n   *\n   *\n   * ## Example use with a new tag for the replacement\n   *\n   *     var html = Autolinker.link( \"Test google.com\", {\n   *         replaceFn : function( autolinker, match ) {\n   *             var tag = new Autolinker.HtmlTag( {\n   *                 tagName : 'button',\n   *                 attrs   : { 'title': 'Load URL: ' + match.getAnchorHref() },\n   *                 innerHtml : 'Load URL: ' + match.getAnchorText()\n   *             } );\n   *\n   *             return tag;\n   *         }\n   *     } );\n   *\n   *     // generated html:\n   *     //   Test <button title=\"Load URL: http://google.com\">Load URL: google.com</button>\n   */\n\n  Autolinker.HtmlTag = Autolinker.Util.extend(Object, {\n    /**\n     * @cfg {String} tagName\n     *\n     * The tag name. Ex: 'a', 'button', etc.\n     *\n     * Not required at instantiation time, but should be set using {@link #setTagName} before {@link #toAnchorString}\n     * is executed.\n     */\n\n    /**\n     * @cfg {Object.<String, String>} attrs\n     *\n     * An key/value Object (map) of attributes to create the tag with. The keys are the attribute names, and the\n     * values are the attribute values.\n     */\n\n    /**\n     * @cfg {String} innerHtml\n     *\n     * The inner HTML for the tag.\n     *\n     * Note the camel case name on `innerHtml`. Acronyms are camelCased in this utility (such as not to run into the acronym\n     * naming inconsistency that the DOM developers created with `XMLHttpRequest`). You may alternatively use {@link #innerHTML}\n     * if you prefer, but this one is recommended.\n     */\n\n    /**\n     * @cfg {String} innerHTML\n     *\n     * Alias of {@link #innerHtml}, accepted for consistency with the browser DOM api, but prefer the camelCased version\n     * for acronym names.\n     */\n\n    /**\n     * @protected\n     * @property {RegExp} whitespaceRegex\n     *\n     * Regular expression used to match whitespace in a string of CSS classes.\n     */\n    whitespaceRegex: /\\s+/,\n\n    /**\n     * @constructor\n     * @param {Object} [cfg] The configuration properties for this class, in an Object (map)\n     */\n    constructor: function constructor(cfg) {\n      Autolinker.Util.assign(this, cfg);\n      this.innerHtml = this.innerHtml || this.innerHTML; // accept either the camelCased form or the fully capitalized acronym\n    },\n\n    /**\n     * Sets the tag name that will be used to generate the tag with.\n     *\n     * @param {String} tagName\n     * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained.\n     */\n    setTagName: function setTagName(tagName) {\n      this.tagName = tagName;\n      return this;\n    },\n\n    /**\n     * Retrieves the tag name.\n     *\n     * @return {String}\n     */\n    getTagName: function getTagName() {\n      return this.tagName || \"\";\n    },\n\n    /**\n     * Sets an attribute on the HtmlTag.\n     *\n     * @param {String} attrName The attribute name to set.\n     * @param {String} attrValue The attribute value to set.\n     * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained.\n     */\n    setAttr: function setAttr(attrName, attrValue) {\n      var tagAttrs = this.getAttrs();\n      tagAttrs[attrName] = attrValue;\n      return this;\n    },\n\n    /**\n     * Retrieves an attribute from the HtmlTag. If the attribute does not exist, returns `undefined`.\n     *\n     * @param {String} attrName The attribute name to retrieve.\n     * @return {String} The attribute's value, or `undefined` if it does not exist on the HtmlTag.\n     */\n    getAttr: function getAttr(attrName) {\n      return this.getAttrs()[attrName];\n    },\n\n    /**\n     * Sets one or more attributes on the HtmlTag.\n     *\n     * @param {Object.<String, String>} attrs A key/value Object (map) of the attributes to set.\n     * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained.\n     */\n    setAttrs: function setAttrs(attrs) {\n      var tagAttrs = this.getAttrs();\n      Autolinker.Util.assign(tagAttrs, attrs);\n      return this;\n    },\n\n    /**\n     * Retrieves the attributes Object (map) for the HtmlTag.\n     *\n     * @return {Object.<String, String>} A key/value object of the attributes for the HtmlTag.\n     */\n    getAttrs: function getAttrs() {\n      return this.attrs || (this.attrs = {});\n    },\n\n    /**\n     * Sets the provided `cssClass`, overwriting any current CSS classes on the HtmlTag.\n     *\n     * @param {String} cssClass One or more space-separated CSS classes to set (overwrite).\n     * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained.\n     */\n    setClass: function setClass(cssClass) {\n      return this.setAttr('class', cssClass);\n    },\n\n    /**\n     * Convenience method to add one or more CSS classes to the HtmlTag. Will not add duplicate CSS classes.\n     *\n     * @param {String} cssClass One or more space-separated CSS classes to add.\n     * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained.\n     */\n    addClass: function addClass(cssClass) {\n      var classAttr = this.getClass(),\n          whitespaceRegex = this.whitespaceRegex,\n          indexOf = Autolinker.Util.indexOf,\n          // to support IE8 and below\n      classes = !classAttr ? [] : classAttr.split(whitespaceRegex),\n          newClasses = cssClass.split(whitespaceRegex),\n          newClass;\n\n      while (newClass = newClasses.shift()) {\n        if (indexOf(classes, newClass) === -1) {\n          classes.push(newClass);\n        }\n      }\n\n      this.getAttrs()['class'] = classes.join(\" \");\n      return this;\n    },\n\n    /**\n     * Convenience method to remove one or more CSS classes from the HtmlTag.\n     *\n     * @param {String} cssClass One or more space-separated CSS classes to remove.\n     * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained.\n     */\n    removeClass: function removeClass(cssClass) {\n      var classAttr = this.getClass(),\n          whitespaceRegex = this.whitespaceRegex,\n          indexOf = Autolinker.Util.indexOf,\n          // to support IE8 and below\n      classes = !classAttr ? [] : classAttr.split(whitespaceRegex),\n          removeClasses = cssClass.split(whitespaceRegex),\n          removeClass;\n\n      while (classes.length && (removeClass = removeClasses.shift())) {\n        var idx = indexOf(classes, removeClass);\n\n        if (idx !== -1) {\n          classes.splice(idx, 1);\n        }\n      }\n\n      this.getAttrs()['class'] = classes.join(\" \");\n      return this;\n    },\n\n    /**\n     * Convenience method to retrieve the CSS class(es) for the HtmlTag, which will each be separated by spaces when\n     * there are multiple.\n     *\n     * @return {String}\n     */\n    getClass: function getClass() {\n      return this.getAttrs()['class'] || \"\";\n    },\n\n    /**\n     * Convenience method to check if the tag has a CSS class or not.\n     *\n     * @param {String} cssClass The CSS class to check for.\n     * @return {Boolean} `true` if the HtmlTag has the CSS class, `false` otherwise.\n     */\n    hasClass: function hasClass(cssClass) {\n      return (' ' + this.getClass() + ' ').indexOf(' ' + cssClass + ' ') !== -1;\n    },\n\n    /**\n     * Sets the inner HTML for the tag.\n     *\n     * @param {String} html The inner HTML to set.\n     * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained.\n     */\n    setInnerHtml: function setInnerHtml(html) {\n      this.innerHtml = html;\n      return this;\n    },\n\n    /**\n     * Retrieves the inner HTML for the tag.\n     *\n     * @return {String}\n     */\n    getInnerHtml: function getInnerHtml() {\n      return this.innerHtml || \"\";\n    },\n\n    /**\n     * Override of superclass method used to generate the HTML string for the tag.\n     *\n     * @return {String}\n     */\n    toAnchorString: function toAnchorString() {\n      var tagName = this.getTagName(),\n          attrsStr = this.buildAttrsStr();\n      attrsStr = attrsStr ? ' ' + attrsStr : ''; // prepend a space if there are actually attributes\n\n      return ['<', tagName, attrsStr, '>', this.getInnerHtml(), '</', tagName, '>'].join(\"\");\n    },\n\n    /**\n     * Support method for {@link #toAnchorString}, returns the string space-separated key=\"value\" pairs, used to populate\n     * the stringified HtmlTag.\n     *\n     * @protected\n     * @return {String} Example return: `attr1=\"value1\" attr2=\"value2\"`\n     */\n    buildAttrsStr: function buildAttrsStr() {\n      if (!this.attrs) return \"\"; // no `attrs` Object (map) has been set, return empty string\n\n      var attrs = this.getAttrs(),\n          attrsArr = [];\n\n      for (var prop in attrs) {\n        if (attrs.hasOwnProperty(prop)) {\n          attrsArr.push(prop + '=\"' + attrs[prop] + '\"');\n        }\n      }\n\n      return attrsArr.join(\" \");\n    }\n  });\n  /*global Autolinker */\n\n  /**\n   * @class Autolinker.RegexLib\n   * @singleton\n   *\n   * Builds and stores a library of the common regular expressions used by the\n   * Autolinker utility.\n   *\n   * Other regular expressions may exist ad-hoc, but these are generally the\n   * regular expressions that are shared between source files.\n   */\n\n  Autolinker.RegexLib = function () {\n    /**\n     * The string form of a regular expression that would match all of the\n     * alphabetic (\"letter\") chars in the unicode character set when placed in a\n     * RegExp character class (`[]`). This includes all international alphabetic\n     * characters.\n     *\n     * These would be the characters matched by unicode regex engines `\\p{L}`\n     * escape (\"all letters\").\n     *\n     * Taken from the XRegExp library: http://xregexp.com/\n     * Specifically: http://xregexp.com/v/3.0.0/unicode-categories.js\n     *\n     * @private\n     * @type {String}\n     */\n    var alphaCharsStr = \"A-Za-z\\\\xAA\\\\xB5\\\\xBA\\\\xC0-\\\\xD6\\\\xD8-\\\\xF6\\\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u08A0-\\u08B4\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0AF9\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58-\\u0C5A\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D5F-\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16F1-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2183\\u2184\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005\\u3006\\u3031-\\u3035\\u303B\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FD5\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA69D\\uA6A0-\\uA6E5\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7AD\\uA7B0-\\uA7B7\\uA7F7-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA8FD\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uA9E0-\\uA9E4\\uA9E6-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB65\\uAB70-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC\";\n    /**\n     * The string form of a regular expression that would match all of the\n     * decimal number chars in the unicode character set when placed in a RegExp\n     * character class (`[]`).\n     *\n     * These would be the characters matched by unicode regex engines `\\p{Nd}`\n     * escape (\"all decimal numbers\")\n     *\n     * Taken from the XRegExp library: http://xregexp.com/\n     * Specifically: http://xregexp.com/v/3.0.0/unicode-categories.js\n     *\n     * @private\n     * @type {String}\n     */\n\n    var decimalNumbersStr = \"0-9\\u0660-\\u0669\\u06F0-\\u06F9\\u07C0-\\u07C9\\u0966-\\u096F\\u09E6-\\u09EF\\u0A66-\\u0A6F\\u0AE6-\\u0AEF\\u0B66-\\u0B6F\\u0BE6-\\u0BEF\\u0C66-\\u0C6F\\u0CE6-\\u0CEF\\u0D66-\\u0D6F\\u0DE6-\\u0DEF\\u0E50-\\u0E59\\u0ED0-\\u0ED9\\u0F20-\\u0F29\\u1040-\\u1049\\u1090-\\u1099\\u17E0-\\u17E9\\u1810-\\u1819\\u1946-\\u194F\\u19D0-\\u19D9\\u1A80-\\u1A89\\u1A90-\\u1A99\\u1B50-\\u1B59\\u1BB0-\\u1BB9\\u1C40-\\u1C49\\u1C50-\\u1C59\\uA620-\\uA629\\uA8D0-\\uA8D9\\uA900-\\uA909\\uA9D0-\\uA9D9\\uA9F0-\\uA9F9\\uAA50-\\uAA59\\uABF0-\\uABF9\\uFF10-\\uFF19\"; // See documentation below\n\n    var alphaNumericCharsStr = alphaCharsStr + decimalNumbersStr; // See documentation below\n\n    var domainNameRegex = new RegExp('[' + alphaNumericCharsStr + '.\\\\-]*[' + alphaNumericCharsStr + '\\\\-]'); // See documentation below\n\n    var tldRegex = /(?:travelersinsurance|sandvikcoromant|kerryproperties|cancerresearch|weatherchannel|kerrylogistics|spreadbetting|international|wolterskluwer|lifeinsurance|construction|pamperedchef|scholarships|versicherung|bridgestone|creditunion|kerryhotels|investments|productions|blackfriday|enterprises|lamborghini|photography|motorcycles|williamhill|playstation|contractors|barclaycard|accountants|redumbrella|engineering|management|telefonica|protection|consulting|tatamotors|creditcard|vlaanderen|schaeffler|associates|properties|foundation|republican|bnpparibas|boehringer|eurovision|extraspace|industries|immobilien|university|technology|volkswagen|healthcare|restaurant|cuisinella|vistaprint|apartments|accountant|travelers|homedepot|institute|vacations|furniture|fresenius|insurance|christmas|bloomberg|solutions|barcelona|firestone|financial|kuokgroup|fairwinds|community|passagens|goldpoint|equipment|lifestyle|yodobashi|aquarelle|marketing|analytics|education|amsterdam|statefarm|melbourne|allfinanz|directory|microsoft|stockholm|montblanc|accenture|lancaster|landrover|everbank|istanbul|graphics|grainger|ipiranga|softbank|attorney|pharmacy|saarland|catering|airforce|yokohama|mortgage|frontier|mutuelle|stcgroup|memorial|pictures|football|symantec|cipriani|ventures|telecity|cityeats|verisign|flsmidth|boutique|cleaning|firmdale|clinique|clothing|redstone|infiniti|deloitte|feedback|services|broadway|plumbing|commbank|training|barclays|exchange|computer|brussels|software|delivery|barefoot|builders|business|bargains|engineer|holdings|download|security|helsinki|lighting|movistar|discount|hdfcbank|supplies|marriott|property|diamonds|capetown|partners|democrat|jpmorgan|bradesco|budapest|rexroth|zuerich|shriram|academy|science|support|youtube|singles|surgery|alibaba|statoil|dentist|schwarz|android|cruises|cricket|digital|markets|starhub|systems|courses|coupons|netbank|country|domains|corsica|network|neustar|realtor|lincoln|limited|schmidt|yamaxun|cooking|contact|auction|spiegel|liaison|leclerc|latrobe|lasalle|abogado|compare|lanxess|exposed|express|company|cologne|college|avianca|lacaixa|fashion|recipes|ferrero|komatsu|storage|wanggou|clubmed|sandvik|fishing|fitness|bauhaus|kitchen|flights|florist|flowers|watches|weather|temasek|samsung|bentley|forsale|channel|theater|frogans|theatre|okinawa|website|tickets|jewelry|gallery|tiffany|iselect|shiksha|brother|organic|wedding|genting|toshiba|origins|philips|hyundai|hotmail|hoteles|hosting|rentals|windows|cartier|bugatti|holiday|careers|whoswho|hitachi|panerai|caravan|reviews|guitars|capital|trading|hamburg|hangout|finance|stream|family|abbott|health|review|travel|report|hermes|hiphop|gratis|career|toyota|hockey|dating|repair|google|social|soccer|reisen|global|otsuka|giving|unicom|casino|photos|center|broker|rocher|orange|bostik|garden|insure|ryukyu|bharti|safety|physio|sakura|oracle|online|jaguar|gallup|piaget|tienda|futbol|pictet|joburg|webcam|berlin|office|juegos|kaufen|chanel|chrome|xihuan|church|tennis|circle|kinder|flickr|bayern|claims|clinic|viajes|nowruz|xperia|norton|yachts|studio|coffee|camera|sanofi|nissan|author|expert|events|comsec|lawyer|tattoo|viking|estate|villas|condos|realty|yandex|energy|emerck|virgin|vision|durban|living|school|coupon|london|taobao|natura|taipei|nagoya|luxury|walter|aramco|sydney|madrid|credit|maison|makeup|schule|market|anquan|direct|design|swatch|suzuki|alsace|vuelos|dental|alipay|voyage|shouji|voting|airtel|mutual|degree|supply|agency|museum|mobily|dealer|monash|select|mormon|active|moscow|racing|datsun|quebec|nissay|rodeo|email|gifts|works|photo|chloe|edeka|cheap|earth|vista|tushu|koeln|glass|shoes|globo|tunes|gmail|nokia|space|kyoto|black|ricoh|seven|lamer|sener|epson|cisco|praxi|trust|citic|crown|shell|lease|green|legal|lexus|ninja|tatar|gripe|nikon|group|video|wales|autos|gucci|party|nexus|guide|linde|adult|parts|amica|lixil|boats|azure|loans|locus|cymru|lotte|lotto|stada|click|poker|quest|dabur|lupin|nadex|paris|faith|dance|canon|place|gives|trade|skype|rocks|mango|cloud|boots|smile|final|swiss|homes|honda|media|horse|cards|deals|watch|bosch|house|pizza|miami|osaka|tours|total|xerox|coach|sucks|style|delta|toray|iinet|tools|money|codes|beats|tokyo|salon|archi|movie|baidu|study|actor|yahoo|store|apple|world|forex|today|bible|tmall|tirol|irish|tires|forum|reise|vegas|vodka|sharp|omega|weber|jetzt|audio|promo|build|bingo|chase|gallo|drive|dubai|rehab|press|solar|sale|beer|bbva|bank|band|auto|sapo|sarl|saxo|audi|asia|arte|arpa|army|yoga|ally|zara|scor|scot|sexy|seat|zero|seek|aero|adac|zone|aarp|maif|meet|meme|menu|surf|mini|mobi|mtpc|porn|desi|star|ltda|name|talk|navy|love|loan|live|link|news|limo|like|spot|life|nico|lidl|lgbt|land|taxi|team|tech|kred|kpmg|sony|song|kiwi|kddi|jprs|jobs|sohu|java|itau|tips|info|immo|icbc|hsbc|town|host|page|toys|here|help|pars|haus|guru|guge|tube|goog|golf|gold|sncf|gmbh|gift|ggee|gent|gbiz|game|vana|pics|fund|ford|ping|pink|fish|film|fast|farm|play|fans|fail|plus|skin|pohl|fage|moda|post|erni|dvag|prod|doha|prof|docs|viva|diet|luxe|site|dell|sina|dclk|show|qpon|date|vote|cyou|voto|read|coop|cool|wang|club|city|chat|cern|cash|reit|rent|casa|cars|care|camp|rest|call|cafe|weir|wien|rich|wiki|buzz|wine|book|bond|room|work|rsvp|shia|ruhr|blue|bing|shaw|bike|safe|xbox|best|pwc|mtn|lds|aig|boo|fyi|nra|nrw|ntt|car|gal|obi|zip|aeg|vin|how|one|ong|onl|dad|ooo|bet|esq|org|htc|bar|uol|ibm|ovh|gdn|ice|icu|uno|gea|ifm|bot|top|wtf|lol|day|pet|eus|wtc|ubs|tvs|aco|ing|ltd|ink|tab|abb|afl|cat|int|pid|pin|bid|cba|gle|com|cbn|ads|man|wed|ceb|gmo|sky|ist|gmx|tui|mba|fan|ski|iwc|app|pro|med|ceo|jcb|jcp|goo|dev|men|aaa|meo|pub|jlc|bom|jll|gop|jmp|mil|got|gov|win|jot|mma|joy|trv|red|cfa|cfd|bio|moe|moi|mom|ren|biz|aws|xin|bbc|dnp|buy|kfh|mov|thd|xyz|fit|kia|rio|rip|kim|dog|vet|nyc|bcg|mtr|bcn|bms|bmw|run|bzh|rwe|tel|stc|axa|kpn|fly|krd|cab|bnl|foo|crs|eat|tci|sap|srl|nec|sas|net|cal|sbs|sfr|sca|scb|csc|edu|new|xxx|hiv|fox|wme|ngo|nhk|vip|sex|frl|lat|yun|law|you|tax|soy|sew|om|ac|hu|se|sc|sg|sh|sb|sa|rw|ru|rs|ro|re|qa|py|si|pw|pt|ps|sj|sk|pr|pn|pm|pl|sl|sm|pk|sn|ph|so|pg|pf|pe|pa|zw|nz|nu|nr|np|no|nl|ni|ng|nf|sr|ne|st|nc|na|mz|my|mx|mw|mv|mu|mt|ms|mr|mq|mp|mo|su|mn|mm|ml|mk|mh|mg|me|sv|md|mc|sx|sy|ma|ly|lv|sz|lu|lt|ls|lr|lk|li|lc|lb|la|tc|kz|td|ky|kw|kr|kp|kn|km|ki|kh|tf|tg|th|kg|ke|jp|jo|jm|je|it|is|ir|tj|tk|tl|tm|iq|tn|to|io|in|im|il|ie|ad|sd|ht|hr|hn|hm|tr|hk|gy|gw|gu|gt|gs|gr|gq|tt|gp|gn|gm|gl|tv|gi|tw|tz|ua|gh|ug|uk|gg|gf|ge|gd|us|uy|uz|va|gb|ga|vc|ve|fr|fo|fm|fk|fj|vg|vi|fi|eu|et|es|er|eg|ee|ec|dz|do|dm|dk|vn|dj|de|cz|cy|cx|cw|vu|cv|cu|cr|co|cn|cm|cl|ck|ci|ch|cg|cf|cd|cc|ca|wf|bz|by|bw|bv|bt|bs|br|bo|bn|bm|bj|bi|ws|bh|bg|bf|be|bd|bb|ba|az|ax|aw|au|at|as|ye|ar|aq|ao|am|al|yt|ai|za|ag|af|ae|zm|id)\\b/;\n    return {\n      /**\n       * The string form of a regular expression that would match all of the\n       * letters and decimal number chars in the unicode character set when placed\n       * in a RegExp character class (`[]`).\n       *\n       * These would be the characters matched by unicode regex engines `[\\p{L}\\p{Nd}]`\n       * escape (\"all letters and decimal numbers\")\n       *\n       * @property {String} alphaNumericCharsStr\n       */\n      alphaNumericCharsStr: alphaNumericCharsStr,\n\n      /**\n       * A regular expression to match domain names of a URL or email address.\n       * Ex: 'google', 'yahoo', 'some-other-company', etc.\n       *\n       * @property {RegExp} domainNameRegex\n       */\n      domainNameRegex: domainNameRegex,\n\n      /**\n       * A regular expression to match top level domains (TLDs) for a URL or\n       * email address. Ex: 'com', 'org', 'net', etc.\n       *\n       * @property {RegExp} tldRegex\n       */\n      tldRegex: tldRegex\n    };\n  }();\n  /*global Autolinker */\n\n  /*jshint sub:true */\n\n  /**\n   * @protected\n   * @class Autolinker.AnchorTagBuilder\n   * @extends Object\n   *\n   * Builds anchor (&lt;a&gt;) tags for the Autolinker utility when a match is\n   * found.\n   *\n   * Normally this class is instantiated, configured, and used internally by an\n   * {@link Autolinker} instance, but may actually be retrieved in a {@link Autolinker#replaceFn replaceFn}\n   * to create {@link Autolinker.HtmlTag HtmlTag} instances which may be modified\n   * before returning from the {@link Autolinker#replaceFn replaceFn}. For\n   * example:\n   *\n   *     var html = Autolinker.link( \"Test google.com\", {\n   *         replaceFn : function( autolinker, match ) {\n   *             var tag = autolinker.getTagBuilder().build( match );  // returns an {@link Autolinker.HtmlTag} instance\n   *             tag.setAttr( 'rel', 'nofollow' );\n   *\n   *             return tag;\n   *         }\n   *     } );\n   *\n   *     // generated html:\n   *     //   Test <a href=\"http://google.com\" target=\"_blank\" rel=\"nofollow\">google.com</a>\n   */\n\n\n  Autolinker.AnchorTagBuilder = Autolinker.Util.extend(Object, {\n    /**\n     * @cfg {Boolean} newWindow\n     * @inheritdoc Autolinker#newWindow\n     */\n\n    /**\n     * @cfg {Object} truncate\n     * @inheritdoc Autolinker#truncate\n     */\n\n    /**\n     * @cfg {String} className\n     * @inheritdoc Autolinker#className\n     */\n\n    /**\n     * @constructor\n     * @param {Object} [cfg] The configuration options for the AnchorTagBuilder instance, specified in an Object (map).\n     */\n    constructor: function constructor(cfg) {\n      Autolinker.Util.assign(this, cfg);\n    },\n\n    /**\n     * Generates the actual anchor (&lt;a&gt;) tag to use in place of the\n     * matched text, via its `match` object.\n     *\n     * @param {Autolinker.match.Match} match The Match instance to generate an\n     *   anchor tag from.\n     * @return {Autolinker.HtmlTag} The HtmlTag instance for the anchor tag.\n     */\n    build: function build(match) {\n      return new Autolinker.HtmlTag({\n        tagName: 'a',\n        attrs: this.createAttrs(match.getType(), match.getAnchorHref()),\n        innerHtml: this.processAnchorText(match.getAnchorText())\n      });\n    },\n\n    /**\n     * Creates the Object (map) of the HTML attributes for the anchor (&lt;a&gt;)\n     *   tag being generated.\n     *\n     * @protected\n     * @param {\"url\"/\"email\"/\"phone\"/\"twitter\"/\"hashtag\"} matchType The type of\n     *   match that an anchor tag is being generated for.\n     * @param {String} anchorHref The href for the anchor tag.\n     * @return {Object} A key/value Object (map) of the anchor tag's attributes.\n     */\n    createAttrs: function createAttrs(matchType, anchorHref) {\n      var attrs = {\n        'href': anchorHref // we'll always have the `href` attribute\n\n      };\n      var cssClass = this.createCssClass(matchType);\n\n      if (cssClass) {\n        attrs['class'] = cssClass;\n      }\n\n      if (this.newWindow) {\n        attrs['target'] = \"_blank\";\n        attrs['rel'] = \"noopener noreferrer\";\n      }\n\n      return attrs;\n    },\n\n    /**\n     * Creates the CSS class that will be used for a given anchor tag, based on\n     * the `matchType` and the {@link #className} config.\n     *\n     * @private\n     * @param {\"url\"/\"email\"/\"phone\"/\"twitter\"/\"hashtag\"} matchType The type of\n     *   match that an anchor tag is being generated for.\n     * @return {String} The CSS class string for the link. Example return:\n     *   \"myLink myLink-url\". If no {@link #className} was configured, returns\n     *   an empty string.\n     */\n    createCssClass: function createCssClass(matchType) {\n      var className = this.className;\n      if (!className) return \"\";else return className + \" \" + className + \"-\" + matchType; // ex: \"myLink myLink-url\", \"myLink myLink-email\", \"myLink myLink-phone\", \"myLink myLink-twitter\", or \"myLink myLink-hashtag\"\n    },\n\n    /**\n     * Processes the `anchorText` by truncating the text according to the\n     * {@link #truncate} config.\n     *\n     * @private\n     * @param {String} anchorText The anchor tag's text (i.e. what will be\n     *   displayed).\n     * @return {String} The processed `anchorText`.\n     */\n    processAnchorText: function processAnchorText(anchorText) {\n      anchorText = this.doTruncate(anchorText);\n      return anchorText;\n    },\n\n    /**\n     * Performs the truncation of the `anchorText` based on the {@link #truncate}\n     * option. If the `anchorText` is longer than the length specified by the\n     * {@link #truncate} option, the truncation is performed based on the\n     * `location` property. See {@link #truncate} for details.\n     *\n     * @private\n     * @param {String} anchorText The anchor tag's text (i.e. what will be\n     *   displayed).\n     * @return {String} The truncated anchor text.\n     */\n    doTruncate: function doTruncate(anchorText) {\n      var truncate = this.truncate;\n      if (!truncate || !truncate.length) return anchorText;\n      var truncateLength = truncate.length,\n          truncateLocation = truncate.location;\n\n      if (truncateLocation === 'smart') {\n        return Autolinker.truncate.TruncateSmart(anchorText, truncateLength, '..');\n      } else if (truncateLocation === 'middle') {\n        return Autolinker.truncate.TruncateMiddle(anchorText, truncateLength, '..');\n      } else {\n        return Autolinker.truncate.TruncateEnd(anchorText, truncateLength, '..');\n      }\n    }\n  });\n  /*global Autolinker */\n\n  /**\n   * @class Autolinker.htmlParser.HtmlParser\n   * @extends Object\n   *\n   * An HTML parser implementation which simply walks an HTML string and returns an array of\n   * {@link Autolinker.htmlParser.HtmlNode HtmlNodes} that represent the basic HTML structure of the input string.\n   *\n   * Autolinker uses this to only link URLs/emails/Twitter handles within text nodes, effectively ignoring / \"walking\n   * around\" HTML tags.\n   */\n\n  Autolinker.htmlParser.HtmlParser = Autolinker.Util.extend(Object, {\n    /**\n     * @private\n     * @property {RegExp} htmlRegex\n     *\n     * The regular expression used to pull out HTML tags from a string. Handles namespaced HTML tags and\n     * attribute names, as specified by http://www.w3.org/TR/html-markup/syntax.html.\n     *\n     * Capturing groups:\n     *\n     * 1. The \"!DOCTYPE\" tag name, if a tag is a &lt;!DOCTYPE&gt; tag.\n     * 2. If it is an end tag, this group will have the '/'.\n     * 3. If it is a comment tag, this group will hold the comment text (i.e.\n     *    the text inside the `&lt;!--` and `--&gt;`.\n     * 4. The tag name for all tags (other than the &lt;!DOCTYPE&gt; tag)\n     */\n    htmlRegex: function () {\n      var commentTagRegex = /!--([\\s\\S]+?)--/,\n          tagNameRegex = /[0-9a-zA-Z][0-9a-zA-Z:]*/,\n          attrNameRegex = /[^\\s\"'>\\/=\\x00-\\x1F\\x7F]+/,\n          // the unicode range accounts for excluding control chars, and the delete char\n      attrValueRegex = /(?:\"[^\"]*?\"|'[^']*?'|[^'\"=<>`\\s]+)/,\n          // double quoted, single quoted, or unquoted attribute values\n      nameEqualsValueRegex = attrNameRegex.source + '(?:\\\\s*=\\\\s*' + attrValueRegex.source + ')?'; // optional '=[value]'\n\n      return new RegExp([// for <!DOCTYPE> tag. Ex: <!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">)\n      '(?:', '<(!DOCTYPE)', // *** Capturing Group 1 - If it's a doctype tag\n      // Zero or more attributes following the tag name\n      '(?:', '\\\\s+', // one or more whitespace chars before an attribute\n      // Either:\n      // A. attr=\"value\", or\n      // B. \"value\" alone (To cover example doctype tag: <!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">)\n      '(?:', nameEqualsValueRegex, '|', attrValueRegex.source + ')', ')*', '>', ')', '|', // All other HTML tags (i.e. tags that are not <!DOCTYPE>)\n      '(?:', '<(/)?', // Beginning of a tag or comment. Either '<' for a start tag, or '</' for an end tag.\n      // *** Capturing Group 2: The slash or an empty string. Slash ('/') for end tag, empty string for start or self-closing tag.\n      '(?:', commentTagRegex.source, // *** Capturing Group 3 - A Comment Tag's Text\n      '|', '(?:', // *** Capturing Group 4 - The tag name\n      '(' + tagNameRegex.source + ')', // Zero or more attributes following the tag name\n      '(?:', '(?:\\\\s+|\\\\b)', // any number of whitespace chars before an attribute. NOTE: Using \\s* here throws Chrome into an infinite loop for some reason, so using \\s+|\\b instead\n      nameEqualsValueRegex, // attr=\"value\" (with optional =\"value\" part)\n      ')*', '\\\\s*/?', // any trailing spaces and optional '/' before the closing '>'\n      ')', ')', '>', ')'].join(\"\"), 'gi');\n    }(),\n\n    /**\n     * @private\n     * @property {RegExp} htmlCharacterEntitiesRegex\n     *\n     * The regular expression that matches common HTML character entities.\n     *\n     * Ignoring &amp; as it could be part of a query string -- handling it separately.\n     */\n    htmlCharacterEntitiesRegex: /(&nbsp;|&#160;|&lt;|&#60;|&gt;|&#62;|&quot;|&#34;|&#39;)/gi,\n\n    /**\n     * Parses an HTML string and returns a simple array of {@link Autolinker.htmlParser.HtmlNode HtmlNodes}\n     * to represent the HTML structure of the input string.\n     *\n     * @param {String} html The HTML to parse.\n     * @return {Autolinker.htmlParser.HtmlNode[]}\n     */\n    parse: function parse(html) {\n      var htmlRegex = this.htmlRegex,\n          currentResult,\n          lastIndex = 0,\n          textAndEntityNodes,\n          nodes = []; // will be the result of the method\n\n      while ((currentResult = htmlRegex.exec(html)) !== null) {\n        var tagText = currentResult[0],\n            commentText = currentResult[3],\n            // if we've matched a comment\n        tagName = currentResult[1] || currentResult[4],\n            // The <!DOCTYPE> tag (ex: \"!DOCTYPE\"), or another tag (ex: \"a\" or \"img\")\n        isClosingTag = !!currentResult[2],\n            offset = currentResult.index,\n            inBetweenTagsText = html.substring(lastIndex, offset); // Push TextNodes and EntityNodes for any text found between tags\n\n        if (inBetweenTagsText) {\n          textAndEntityNodes = this.parseTextAndEntityNodes(lastIndex, inBetweenTagsText);\n          nodes.push.apply(nodes, textAndEntityNodes);\n        } // Push the CommentNode or ElementNode\n\n\n        if (commentText) {\n          nodes.push(this.createCommentNode(offset, tagText, commentText));\n        } else {\n          nodes.push(this.createElementNode(offset, tagText, tagName, isClosingTag));\n        }\n\n        lastIndex = offset + tagText.length;\n      } // Process any remaining text after the last HTML element. Will process all of the text if there were no HTML elements.\n\n\n      if (lastIndex < html.length) {\n        var text = html.substring(lastIndex); // Push TextNodes and EntityNodes for any text found between tags\n\n        if (text) {\n          textAndEntityNodes = this.parseTextAndEntityNodes(lastIndex, text);\n          nodes.push.apply(nodes, textAndEntityNodes);\n        }\n      }\n\n      return nodes;\n    },\n\n    /**\n     * Parses text and HTML entity nodes from a given string. The input string\n     * should not have any HTML tags (elements) within it.\n     *\n     * @private\n     * @param {Number} offset The offset of the text node match within the\n     *   original HTML string.\n     * @param {String} text The string of text to parse. This is from an HTML\n     *   text node.\n     * @return {Autolinker.htmlParser.HtmlNode[]} An array of HtmlNodes to\n     *   represent the {@link Autolinker.htmlParser.TextNode TextNodes} and\n     *   {@link Autolinker.htmlParser.EntityNode EntityNodes} found.\n     */\n    parseTextAndEntityNodes: function parseTextAndEntityNodes(offset, text) {\n      var nodes = [],\n          textAndEntityTokens = Autolinker.Util.splitAndCapture(text, this.htmlCharacterEntitiesRegex); // split at HTML entities, but include the HTML entities in the results array\n      // Every even numbered token is a TextNode, and every odd numbered token is an EntityNode\n      // For example: an input `text` of \"Test &quot;this&quot; today\" would turn into the\n      //   `textAndEntityTokens`: [ 'Test ', '&quot;', 'this', '&quot;', ' today' ]\n\n      for (var i = 0, len = textAndEntityTokens.length; i < len; i += 2) {\n        var textToken = textAndEntityTokens[i],\n            entityToken = textAndEntityTokens[i + 1];\n\n        if (textToken) {\n          nodes.push(this.createTextNode(offset, textToken));\n          offset += textToken.length;\n        }\n\n        if (entityToken) {\n          nodes.push(this.createEntityNode(offset, entityToken));\n          offset += entityToken.length;\n        }\n      }\n\n      return nodes;\n    },\n\n    /**\n     * Factory method to create an {@link Autolinker.htmlParser.CommentNode CommentNode}.\n     *\n     * @private\n     * @param {Number} offset The offset of the match within the original HTML\n     *   string.\n     * @param {String} tagText The full text of the tag (comment) that was\n     *   matched, including its &lt;!-- and --&gt;.\n     * @param {String} commentText The full text of the comment that was matched.\n     */\n    createCommentNode: function createCommentNode(offset, tagText, commentText) {\n      return new Autolinker.htmlParser.CommentNode({\n        offset: offset,\n        text: tagText,\n        comment: Autolinker.Util.trim(commentText)\n      });\n    },\n\n    /**\n     * Factory method to create an {@link Autolinker.htmlParser.ElementNode ElementNode}.\n     *\n     * @private\n     * @param {Number} offset The offset of the match within the original HTML\n     *   string.\n     * @param {String} tagText The full text of the tag (element) that was\n     *   matched, including its attributes.\n     * @param {String} tagName The name of the tag. Ex: An &lt;img&gt; tag would\n     *   be passed to this method as \"img\".\n     * @param {Boolean} isClosingTag `true` if it's a closing tag, false\n     *   otherwise.\n     * @return {Autolinker.htmlParser.ElementNode}\n     */\n    createElementNode: function createElementNode(offset, tagText, tagName, isClosingTag) {\n      return new Autolinker.htmlParser.ElementNode({\n        offset: offset,\n        text: tagText,\n        tagName: tagName.toLowerCase(),\n        closing: isClosingTag\n      });\n    },\n\n    /**\n     * Factory method to create a {@link Autolinker.htmlParser.EntityNode EntityNode}.\n     *\n     * @private\n     * @param {Number} offset The offset of the match within the original HTML\n     *   string.\n     * @param {String} text The text that was matched for the HTML entity (such\n     *   as '&amp;nbsp;').\n     * @return {Autolinker.htmlParser.EntityNode}\n     */\n    createEntityNode: function createEntityNode(offset, text) {\n      return new Autolinker.htmlParser.EntityNode({\n        offset: offset,\n        text: text\n      });\n    },\n\n    /**\n     * Factory method to create a {@link Autolinker.htmlParser.TextNode TextNode}.\n     *\n     * @private\n     * @param {Number} offset The offset of the match within the original HTML\n     *   string.\n     * @param {String} text The text that was matched.\n     * @return {Autolinker.htmlParser.TextNode}\n     */\n    createTextNode: function createTextNode(offset, text) {\n      return new Autolinker.htmlParser.TextNode({\n        offset: offset,\n        text: text\n      });\n    }\n  });\n  /*global Autolinker */\n\n  /**\n   * @abstract\n   * @class Autolinker.htmlParser.HtmlNode\n   *\n   * Represents an HTML node found in an input string. An HTML node is one of the\n   * following:\n   *\n   * 1. An {@link Autolinker.htmlParser.ElementNode ElementNode}, which represents\n   *    HTML tags.\n   * 2. A {@link Autolinker.htmlParser.CommentNode CommentNode}, which represents\n   *    HTML comments.\n   * 3. A {@link Autolinker.htmlParser.TextNode TextNode}, which represents text\n   *    outside or within HTML tags.\n   * 4. A {@link Autolinker.htmlParser.EntityNode EntityNode}, which represents\n   *    one of the known HTML entities that Autolinker looks for. This includes\n   *    common ones such as &amp;quot; and &amp;nbsp;\n   */\n\n  Autolinker.htmlParser.HtmlNode = Autolinker.Util.extend(Object, {\n    /**\n     * @cfg {Number} offset (required)\n     *\n     * The offset of the HTML node in the original text that was parsed.\n     */\n    offset: undefined,\n\n    /**\n     * @cfg {String} text (required)\n     *\n     * The text that was matched for the HtmlNode.\n     *\n     * - In the case of an {@link Autolinker.htmlParser.ElementNode ElementNode},\n     *   this will be the tag's text.\n     * - In the case of an {@link Autolinker.htmlParser.CommentNode CommentNode},\n     *   this will be the comment's text.\n     * - In the case of a {@link Autolinker.htmlParser.TextNode TextNode}, this\n     *   will be the text itself.\n     * - In the case of a {@link Autolinker.htmlParser.EntityNode EntityNode},\n     *   this will be the text of the HTML entity.\n     */\n    text: undefined,\n\n    /**\n     * @constructor\n     * @param {Object} cfg The configuration properties for the Match instance,\n     * specified in an Object (map).\n     */\n    constructor: function constructor(cfg) {\n      Autolinker.Util.assign(this, cfg);\n      if (this.offset == null) throw new Error('`offset` cfg required');\n      if (this.text == null) throw new Error('`text` cfg required');\n    },\n\n    /**\n     * Returns a string name for the type of node that this class represents.\n     *\n     * @abstract\n     * @return {String}\n     */\n    getType: Autolinker.Util.abstractMethod,\n\n    /**\n     * Retrieves the {@link #offset} of the HtmlNode. This is the offset of the\n     * HTML node in the original string that was parsed.\n     *\n     * @return {Number}\n     */\n    getOffset: function getOffset() {\n      return this.offset;\n    },\n\n    /**\n     * Retrieves the {@link #text} for the HtmlNode.\n     *\n     * @return {String}\n     */\n    getText: function getText() {\n      return this.text;\n    }\n  });\n  /*global Autolinker */\n\n  /**\n   * @class Autolinker.htmlParser.CommentNode\n   * @extends Autolinker.htmlParser.HtmlNode\n   *\n   * Represents an HTML comment node that has been parsed by the\n   * {@link Autolinker.htmlParser.HtmlParser}.\n   *\n   * See this class's superclass ({@link Autolinker.htmlParser.HtmlNode}) for more\n   * details.\n   */\n\n  Autolinker.htmlParser.CommentNode = Autolinker.Util.extend(Autolinker.htmlParser.HtmlNode, {\n    /**\n     * @cfg {String} comment (required)\n     *\n     * The text inside the comment tag. This text is stripped of any leading or\n     * trailing whitespace.\n     */\n    comment: '',\n\n    /**\n     * Returns a string name for the type of node that this class represents.\n     *\n     * @return {String}\n     */\n    getType: function getType() {\n      return 'comment';\n    },\n\n    /**\n     * Returns the comment inside the comment tag.\n     *\n     * @return {String}\n     */\n    getComment: function getComment() {\n      return this.comment;\n    }\n  });\n  /*global Autolinker */\n\n  /**\n   * @class Autolinker.htmlParser.ElementNode\n   * @extends Autolinker.htmlParser.HtmlNode\n   *\n   * Represents an HTML element node that has been parsed by the {@link Autolinker.htmlParser.HtmlParser}.\n   *\n   * See this class's superclass ({@link Autolinker.htmlParser.HtmlNode}) for more\n   * details.\n   */\n\n  Autolinker.htmlParser.ElementNode = Autolinker.Util.extend(Autolinker.htmlParser.HtmlNode, {\n    /**\n     * @cfg {String} tagName (required)\n     *\n     * The name of the tag that was matched.\n     */\n    tagName: '',\n\n    /**\n     * @cfg {Boolean} closing (required)\n     *\n     * `true` if the element (tag) is a closing tag, `false` if its an opening\n     * tag.\n     */\n    closing: false,\n\n    /**\n     * Returns a string name for the type of node that this class represents.\n     *\n     * @return {String}\n     */\n    getType: function getType() {\n      return 'element';\n    },\n\n    /**\n     * Returns the HTML element's (tag's) name. Ex: for an &lt;img&gt; tag,\n     * returns \"img\".\n     *\n     * @return {String}\n     */\n    getTagName: function getTagName() {\n      return this.tagName;\n    },\n\n    /**\n     * Determines if the HTML element (tag) is a closing tag. Ex: &lt;div&gt;\n     * returns `false`, while &lt;/div&gt; returns `true`.\n     *\n     * @return {Boolean}\n     */\n    isClosing: function isClosing() {\n      return this.closing;\n    }\n  });\n  /*global Autolinker */\n\n  /**\n   * @class Autolinker.htmlParser.EntityNode\n   * @extends Autolinker.htmlParser.HtmlNode\n   *\n   * Represents a known HTML entity node that has been parsed by the {@link Autolinker.htmlParser.HtmlParser}.\n   * Ex: '&amp;nbsp;', or '&amp#160;' (which will be retrievable from the {@link #getText}\n   * method.\n   *\n   * Note that this class will only be returned from the HtmlParser for the set of\n   * checked HTML entity nodes  defined by the {@link Autolinker.htmlParser.HtmlParser#htmlCharacterEntitiesRegex}.\n   *\n   * See this class's superclass ({@link Autolinker.htmlParser.HtmlNode}) for more\n   * details.\n   */\n\n  Autolinker.htmlParser.EntityNode = Autolinker.Util.extend(Autolinker.htmlParser.HtmlNode, {\n    /**\n     * Returns a string name for the type of node that this class represents.\n     *\n     * @return {String}\n     */\n    getType: function getType() {\n      return 'entity';\n    }\n  });\n  /*global Autolinker */\n\n  /**\n   * @class Autolinker.htmlParser.TextNode\n   * @extends Autolinker.htmlParser.HtmlNode\n   *\n   * Represents a text node that has been parsed by the {@link Autolinker.htmlParser.HtmlParser}.\n   *\n   * See this class's superclass ({@link Autolinker.htmlParser.HtmlNode}) for more\n   * details.\n   */\n\n  Autolinker.htmlParser.TextNode = Autolinker.Util.extend(Autolinker.htmlParser.HtmlNode, {\n    /**\n     * Returns a string name for the type of node that this class represents.\n     *\n     * @return {String}\n     */\n    getType: function getType() {\n      return 'text';\n    }\n  });\n  /*global Autolinker */\n\n  /**\n   * @abstract\n   * @class Autolinker.match.Match\n   *\n   * Represents a match found in an input string which should be Autolinked. A Match object is what is provided in a\n   * {@link Autolinker#replaceFn replaceFn}, and may be used to query for details about the match.\n   *\n   * For example:\n   *\n   *     var input = \"...\";  // string with URLs, Email Addresses, and Twitter Handles\n   *\n   *     var linkedText = Autolinker.link( input, {\n   *         replaceFn : function( autolinker, match ) {\n   *             console.log( \"href = \", match.getAnchorHref() );\n   *             console.log( \"text = \", match.getAnchorText() );\n   *\n   *             switch( match.getType() ) {\n   *                 case 'url' :\n   *                     console.log( \"url: \", match.getUrl() );\n   *\n   *                 case 'email' :\n   *                     console.log( \"email: \", match.getEmail() );\n   *\n   *                 case 'twitter' :\n   *                     console.log( \"twitter: \", match.getTwitterHandle() );\n   *             }\n   *         }\n   *     } );\n   *\n   * See the {@link Autolinker} class for more details on using the {@link Autolinker#replaceFn replaceFn}.\n   */\n\n  Autolinker.match.Match = Autolinker.Util.extend(Object, {\n    /**\n     * @cfg {Autolinker.AnchorTagBuilder} tagBuilder (required)\n     *\n     * Reference to the AnchorTagBuilder instance to use to generate an anchor\n     * tag for the Match.\n     */\n\n    /**\n     * @cfg {String} matchedText (required)\n     *\n     * The original text that was matched by the {@link Autolinker.matcher.Matcher}.\n     */\n\n    /**\n     * @cfg {Number} offset (required)\n     *\n     * The offset of where the match was made in the input string.\n     */\n\n    /**\n     * @constructor\n     * @param {Object} cfg The configuration properties for the Match\n     *   instance, specified in an Object (map).\n     */\n    constructor: function constructor(cfg) {\n      if (cfg.tagBuilder == null) throw new Error('`tagBuilder` cfg required');\n      if (cfg.matchedText == null) throw new Error('`matchedText` cfg required');\n      if (cfg.offset == null) throw new Error('`offset` cfg required');\n      this.tagBuilder = cfg.tagBuilder;\n      this.matchedText = cfg.matchedText;\n      this.offset = cfg.offset;\n    },\n\n    /**\n     * Returns a string name for the type of match that this class represents.\n     *\n     * @abstract\n     * @return {String}\n     */\n    getType: Autolinker.Util.abstractMethod,\n\n    /**\n     * Returns the original text that was matched.\n     *\n     * @return {String}\n     */\n    getMatchedText: function getMatchedText() {\n      return this.matchedText;\n    },\n\n    /**\n     * Sets the {@link #offset} of where the match was made in the input string.\n     *\n     * A {@link Autolinker.matcher.Matcher} will be fed only HTML text nodes,\n     * and will therefore set an original offset that is relative to the HTML\n     * text node itself. However, we want this offset to be relative to the full\n     * HTML input string, and thus if using {@link Autolinker#parse} (rather\n     * than calling a {@link Autolinker.matcher.Matcher} directly), then this\n     * offset is corrected after the Matcher itself has done its job.\n     *\n     * @param {Number} offset\n     */\n    setOffset: function setOffset(offset) {\n      this.offset = offset;\n    },\n\n    /**\n     * Returns the offset of where the match was made in the input string. This\n     * is the 0-based index of the match.\n     *\n     * @return {Number}\n     */\n    getOffset: function getOffset() {\n      return this.offset;\n    },\n\n    /**\n     * Returns the anchor href that should be generated for the match.\n     *\n     * @abstract\n     * @return {String}\n     */\n    getAnchorHref: Autolinker.Util.abstractMethod,\n\n    /**\n     * Returns the anchor text that should be generated for the match.\n     *\n     * @abstract\n     * @return {String}\n     */\n    getAnchorText: Autolinker.Util.abstractMethod,\n\n    /**\n     * Builds and returns an {@link Autolinker.HtmlTag} instance based on the\n     * Match.\n     *\n     * This can be used to easily generate anchor tags from matches, and either\n     * return their HTML string, or modify them before doing so.\n     *\n     * Example Usage:\n     *\n     *     var tag = match.buildTag();\n     *     tag.addClass( 'cordova-link' );\n     *     tag.setAttr( 'target', '_system' );\n     *\n     *     tag.toAnchorString();  // <a href=\"http://google.com\" class=\"cordova-link\" target=\"_system\">Google</a>\n     */\n    buildTag: function buildTag() {\n      return this.tagBuilder.build(this);\n    }\n  });\n  /*global Autolinker */\n\n  /**\n   * @class Autolinker.match.Email\n   * @extends Autolinker.match.Match\n   *\n   * Represents a Email match found in an input string which should be Autolinked.\n   *\n   * See this class's superclass ({@link Autolinker.match.Match}) for more details.\n   */\n\n  Autolinker.match.Email = Autolinker.Util.extend(Autolinker.match.Match, {\n    /**\n     * @cfg {String} email (required)\n     *\n     * The email address that was matched.\n     */\n\n    /**\n     * @constructor\n     * @param {Object} cfg The configuration properties for the Match\n     *   instance, specified in an Object (map).\n     */\n    constructor: function constructor(cfg) {\n      Autolinker.match.Match.prototype.constructor.call(this, cfg);\n      if (!cfg.email) throw new Error('`email` cfg required');\n      this.email = cfg.email;\n    },\n\n    /**\n     * Returns a string name for the type of match that this class represents.\n     *\n     * @return {String}\n     */\n    getType: function getType() {\n      return 'email';\n    },\n\n    /**\n     * Returns the email address that was matched.\n     *\n     * @return {String}\n     */\n    getEmail: function getEmail() {\n      return this.email;\n    },\n\n    /**\n     * Returns the anchor href that should be generated for the match.\n     *\n     * @return {String}\n     */\n    getAnchorHref: function getAnchorHref() {\n      return 'mailto:' + this.email;\n    },\n\n    /**\n     * Returns the anchor text that should be generated for the match.\n     *\n     * @return {String}\n     */\n    getAnchorText: function getAnchorText() {\n      return this.email;\n    }\n  });\n  /*global Autolinker */\n\n  /**\n   * @class Autolinker.match.Hashtag\n   * @extends Autolinker.match.Match\n   *\n   * Represents a Hashtag match found in an input string which should be\n   * Autolinked.\n   *\n   * See this class's superclass ({@link Autolinker.match.Match}) for more\n   * details.\n   */\n\n  Autolinker.match.Hashtag = Autolinker.Util.extend(Autolinker.match.Match, {\n    /**\n     * @cfg {String} serviceName\n     *\n     * The service to point hashtag matches to. See {@link Autolinker#hashtag}\n     * for available values.\n     */\n\n    /**\n     * @cfg {String} hashtag (required)\n     *\n     * The Hashtag that was matched, without the '#'.\n     */\n\n    /**\n     * @constructor\n     * @param {Object} cfg The configuration properties for the Match\n     *   instance, specified in an Object (map).\n     */\n    constructor: function constructor(cfg) {\n      Autolinker.match.Match.prototype.constructor.call(this, cfg); // TODO: if( !serviceName ) throw new Error( '`serviceName` cfg required' );\n\n      if (!cfg.hashtag) throw new Error('`hashtag` cfg required');\n      this.serviceName = cfg.serviceName;\n      this.hashtag = cfg.hashtag;\n    },\n\n    /**\n     * Returns the type of match that this class represents.\n     *\n     * @return {String}\n     */\n    getType: function getType() {\n      return 'hashtag';\n    },\n\n    /**\n     * Returns the configured {@link #serviceName} to point the Hashtag to.\n     * Ex: 'facebook', 'twitter'.\n     *\n     * @return {String}\n     */\n    getServiceName: function getServiceName() {\n      return this.serviceName;\n    },\n\n    /**\n     * Returns the matched hashtag, without the '#' character.\n     *\n     * @return {String}\n     */\n    getHashtag: function getHashtag() {\n      return this.hashtag;\n    },\n\n    /**\n     * Returns the anchor href that should be generated for the match.\n     *\n     * @return {String}\n     */\n    getAnchorHref: function getAnchorHref() {\n      var serviceName = this.serviceName,\n          hashtag = this.hashtag;\n\n      switch (serviceName) {\n        case 'twitter':\n          return 'https://twitter.com/hashtag/' + hashtag;\n\n        case 'facebook':\n          return 'https://www.facebook.com/hashtag/' + hashtag;\n\n        case 'instagram':\n          return 'https://instagram.com/explore/tags/' + hashtag;\n\n        default:\n          // Shouldn't happen because Autolinker's constructor should block any invalid values, but just in case.\n          throw new Error('Unknown service name to point hashtag to: ', serviceName);\n      }\n    },\n\n    /**\n     * Returns the anchor text that should be generated for the match.\n     *\n     * @return {String}\n     */\n    getAnchorText: function getAnchorText() {\n      return '#' + this.hashtag;\n    }\n  });\n  /*global Autolinker */\n\n  /**\n   * @class Autolinker.match.Phone\n   * @extends Autolinker.match.Match\n   *\n   * Represents a Phone number match found in an input string which should be\n   * Autolinked.\n   *\n   * See this class's superclass ({@link Autolinker.match.Match}) for more\n   * details.\n   */\n\n  Autolinker.match.Phone = Autolinker.Util.extend(Autolinker.match.Match, {\n    /**\n     * @protected\n     * @property {String} number (required)\n     *\n     * The phone number that was matched, without any delimiter characters.\n     *\n     * Note: This is a string to allow for prefixed 0's.\n     */\n\n    /**\n     * @protected\n     * @property  {Boolean} plusSign (required)\n     *\n     * `true` if the matched phone number started with a '+' sign. We'll include\n     * it in the `tel:` URL if so, as this is needed for international numbers.\n     *\n     * Ex: '+1 (123) 456 7879'\n     */\n\n    /**\n     * @constructor\n     * @param {Object} cfg The configuration properties for the Match\n     *   instance, specified in an Object (map).\n     */\n    constructor: function constructor(cfg) {\n      Autolinker.match.Match.prototype.constructor.call(this, cfg);\n      if (!cfg.number) throw new Error('`number` cfg required');\n      if (cfg.plusSign == null) throw new Error('`plusSign` cfg required');\n      this.number = cfg.number;\n      this.plusSign = cfg.plusSign;\n    },\n\n    /**\n     * Returns a string name for the type of match that this class represents.\n     *\n     * @return {String}\n     */\n    getType: function getType() {\n      return 'phone';\n    },\n\n    /**\n     * Returns the phone number that was matched as a string, without any\n     * delimiter characters.\n     *\n     * Note: This is a string to allow for prefixed 0's.\n     *\n     * @return {String}\n     */\n    getNumber: function getNumber() {\n      return this.number;\n    },\n\n    /**\n     * Returns the anchor href that should be generated for the match.\n     *\n     * @return {String}\n     */\n    getAnchorHref: function getAnchorHref() {\n      return 'tel:' + (this.plusSign ? '+' : '') + this.number;\n    },\n\n    /**\n     * Returns the anchor text that should be generated for the match.\n     *\n     * @return {String}\n     */\n    getAnchorText: function getAnchorText() {\n      return this.matchedText;\n    }\n  });\n  /*global Autolinker */\n\n  /**\n   * @class Autolinker.match.Twitter\n   * @extends Autolinker.match.Match\n   *\n   * Represents a Twitter match found in an input string which should be Autolinked.\n   *\n   * See this class's superclass ({@link Autolinker.match.Match}) for more details.\n   */\n\n  Autolinker.match.Twitter = Autolinker.Util.extend(Autolinker.match.Match, {\n    /**\n     * @cfg {String} twitterHandle (required)\n     *\n     * The Twitter handle that was matched, without the '@' character.\n     */\n\n    /**\n     * @constructor\n     * @param {Object} cfg The configuration properties for the Match\n     *   instance, specified in an Object (map).\n     */\n    constructor: function constructor(cfg) {\n      Autolinker.match.Match.prototype.constructor.call(this, cfg);\n      if (!cfg.twitterHandle) throw new Error('`twitterHandle` cfg required');\n      this.twitterHandle = cfg.twitterHandle;\n    },\n\n    /**\n     * Returns the type of match that this class represents.\n     *\n     * @return {String}\n     */\n    getType: function getType() {\n      return 'twitter';\n    },\n\n    /**\n     * Returns the twitter handle, without the '@' character.\n     *\n     * @return {String}\n     */\n    getTwitterHandle: function getTwitterHandle() {\n      return this.twitterHandle;\n    },\n\n    /**\n     * Returns the anchor href that should be generated for the match.\n     *\n     * @return {String}\n     */\n    getAnchorHref: function getAnchorHref() {\n      return 'https://twitter.com/' + this.twitterHandle;\n    },\n\n    /**\n     * Returns the anchor text that should be generated for the match.\n     *\n     * @return {String}\n     */\n    getAnchorText: function getAnchorText() {\n      return '@' + this.twitterHandle;\n    }\n  });\n  /*global Autolinker */\n\n  /**\n   * @class Autolinker.match.Url\n   * @extends Autolinker.match.Match\n   *\n   * Represents a Url match found in an input string which should be Autolinked.\n   *\n   * See this class's superclass ({@link Autolinker.match.Match}) for more details.\n   */\n\n  Autolinker.match.Url = Autolinker.Util.extend(Autolinker.match.Match, {\n    /**\n     * @cfg {String} url (required)\n     *\n     * The url that was matched.\n     */\n\n    /**\n     * @cfg {\"scheme\"/\"www\"/\"tld\"} urlMatchType (required)\n     *\n     * The type of URL match that this class represents. This helps to determine\n     * if the match was made in the original text with a prefixed scheme (ex:\n     * 'http://www.google.com'), a prefixed 'www' (ex: 'www.google.com'), or\n     * was matched by a known top-level domain (ex: 'google.com').\n     */\n\n    /**\n     * @cfg {Boolean} protocolUrlMatch (required)\n     *\n     * `true` if the URL is a match which already has a protocol (i.e.\n     * 'http://'), `false` if the match was from a 'www' or known TLD match.\n     */\n\n    /**\n     * @cfg {Boolean} protocolRelativeMatch (required)\n     *\n     * `true` if the URL is a protocol-relative match. A protocol-relative match\n     * is a URL that starts with '//', and will be either http:// or https://\n     * based on the protocol that the site is loaded under.\n     */\n\n    /**\n     * @cfg {Boolean} stripPrefix (required)\n     * @inheritdoc Autolinker#cfg-stripPrefix\n     */\n\n    /**\n     * @constructor\n     * @param {Object} cfg The configuration properties for the Match\n     *   instance, specified in an Object (map).\n     */\n    constructor: function constructor(cfg) {\n      Autolinker.match.Match.prototype.constructor.call(this, cfg);\n      if (cfg.urlMatchType !== 'scheme' && cfg.urlMatchType !== 'www' && cfg.urlMatchType !== 'tld') throw new Error('`urlMatchType` cfg must be one of: \"scheme\", \"www\", or \"tld\"');\n      if (!cfg.url) throw new Error('`url` cfg required');\n      if (cfg.protocolUrlMatch == null) throw new Error('`protocolUrlMatch` cfg required');\n      if (cfg.protocolRelativeMatch == null) throw new Error('`protocolRelativeMatch` cfg required');\n      if (cfg.stripPrefix == null) throw new Error('`stripPrefix` cfg required');\n      this.urlMatchType = cfg.urlMatchType;\n      this.url = cfg.url;\n      this.protocolUrlMatch = cfg.protocolUrlMatch;\n      this.protocolRelativeMatch = cfg.protocolRelativeMatch;\n      this.stripPrefix = cfg.stripPrefix;\n    },\n\n    /**\n     * @private\n     * @property {RegExp} urlPrefixRegex\n     *\n     * A regular expression used to remove the 'http://' or 'https://' and/or the 'www.' from URLs.\n     */\n    urlPrefixRegex: /^(https?:\\/\\/)?(www\\.)?/i,\n\n    /**\n     * @private\n     * @property {RegExp} protocolRelativeRegex\n     *\n     * The regular expression used to remove the protocol-relative '//' from the {@link #url} string, for purposes\n     * of {@link #getAnchorText}. A protocol-relative URL is, for example, \"//yahoo.com\"\n     */\n    protocolRelativeRegex: /^\\/\\//,\n\n    /**\n     * @private\n     * @property {Boolean} protocolPrepended\n     *\n     * Will be set to `true` if the 'http://' protocol has been prepended to the {@link #url} (because the\n     * {@link #url} did not have a protocol)\n     */\n    protocolPrepended: false,\n\n    /**\n     * Returns a string name for the type of match that this class represents.\n     *\n     * @return {String}\n     */\n    getType: function getType() {\n      return 'url';\n    },\n\n    /**\n     * Returns a string name for the type of URL match that this class\n     * represents.\n     *\n     * This helps to determine if the match was made in the original text with a\n     * prefixed scheme (ex: 'http://www.google.com'), a prefixed 'www' (ex:\n     * 'www.google.com'), or was matched by a known top-level domain (ex:\n     * 'google.com').\n     *\n     * @return {\"scheme\"/\"www\"/\"tld\"}\n     */\n    getUrlMatchType: function getUrlMatchType() {\n      return this.urlMatchType;\n    },\n\n    /**\n     * Returns the url that was matched, assuming the protocol to be 'http://' if the original\n     * match was missing a protocol.\n     *\n     * @return {String}\n     */\n    getUrl: function getUrl() {\n      var url = this.url; // if the url string doesn't begin with a protocol, assume 'http://'\n\n      if (!this.protocolRelativeMatch && !this.protocolUrlMatch && !this.protocolPrepended) {\n        url = this.url = 'http://' + url;\n        this.protocolPrepended = true;\n      }\n\n      return url;\n    },\n\n    /**\n     * Returns the anchor href that should be generated for the match.\n     *\n     * @return {String}\n     */\n    getAnchorHref: function getAnchorHref() {\n      var url = this.getUrl();\n      return url.replace(/&amp;/g, '&'); // any &amp;'s in the URL should be converted back to '&' if they were displayed as &amp; in the source html\n    },\n\n    /**\n     * Returns the anchor text that should be generated for the match.\n     *\n     * @return {String}\n     */\n    getAnchorText: function getAnchorText() {\n      var anchorText = this.getMatchedText();\n\n      if (this.protocolRelativeMatch) {\n        // Strip off any protocol-relative '//' from the anchor text\n        anchorText = this.stripProtocolRelativePrefix(anchorText);\n      }\n\n      if (this.stripPrefix) {\n        anchorText = this.stripUrlPrefix(anchorText);\n      }\n\n      anchorText = this.removeTrailingSlash(anchorText); // remove trailing slash, if there is one\n\n      return anchorText;\n    },\n    // ---------------------------------------\n    // Utility Functionality\n\n    /**\n     * Strips the URL prefix (such as \"http://\" or \"https://\") from the given text.\n     *\n     * @private\n     * @param {String} text The text of the anchor that is being generated, for which to strip off the\n     *   url prefix (such as stripping off \"http://\")\n     * @return {String} The `anchorText`, with the prefix stripped.\n     */\n    stripUrlPrefix: function stripUrlPrefix(text) {\n      return text.replace(this.urlPrefixRegex, '');\n    },\n\n    /**\n     * Strips any protocol-relative '//' from the anchor text.\n     *\n     * @private\n     * @param {String} text The text of the anchor that is being generated, for which to strip off the\n     *   protocol-relative prefix (such as stripping off \"//\")\n     * @return {String} The `anchorText`, with the protocol-relative prefix stripped.\n     */\n    stripProtocolRelativePrefix: function stripProtocolRelativePrefix(text) {\n      return text.replace(this.protocolRelativeRegex, '');\n    },\n\n    /**\n     * Removes any trailing slash from the given `anchorText`, in preparation for the text to be displayed.\n     *\n     * @private\n     * @param {String} anchorText The text of the anchor that is being generated, for which to remove any trailing\n     *   slash ('/') that may exist.\n     * @return {String} The `anchorText`, with the trailing slash removed.\n     */\n    removeTrailingSlash: function removeTrailingSlash(anchorText) {\n      if (anchorText.charAt(anchorText.length - 1) === '/') {\n        anchorText = anchorText.slice(0, -1);\n      }\n\n      return anchorText;\n    }\n  });\n  /*global Autolinker */\n\n  /**\n   * @abstract\n   * @class Autolinker.matcher.Matcher\n   *\n   * An abstract class and interface for individual matchers to find matches in\n   * an input string with linkified versions of them.\n   *\n   * Note that Matchers do not take HTML into account - they must be fed the text\n   * nodes of any HTML string, which is handled by {@link Autolinker#parse}.\n   */\n\n  Autolinker.matcher.Matcher = Autolinker.Util.extend(Object, {\n    /**\n     * @cfg {Autolinker.AnchorTagBuilder} tagBuilder (required)\n     *\n     * Reference to the AnchorTagBuilder instance to use to generate HTML tags\n     * for {@link Autolinker.match.Match Matches}.\n     */\n\n    /**\n     * @constructor\n     * @param {Object} cfg The configuration properties for the Matcher\n     *   instance, specified in an Object (map).\n     */\n    constructor: function constructor(cfg) {\n      if (!cfg.tagBuilder) throw new Error('`tagBuilder` cfg required');\n      this.tagBuilder = cfg.tagBuilder;\n    },\n\n    /**\n     * Parses the input `text` and returns the array of {@link Autolinker.match.Match Matches}\n     * for the matcher.\n     *\n     * @abstract\n     * @param {String} text The text to scan and replace matches in.\n     * @return {Autolinker.match.Match[]}\n     */\n    parseMatches: Autolinker.Util.abstractMethod\n  });\n  /*global Autolinker */\n\n  /**\n   * @class Autolinker.matcher.Email\n   * @extends Autolinker.matcher.Matcher\n   *\n   * Matcher to find email matches in an input string.\n   *\n   * See this class's superclass ({@link Autolinker.matcher.Matcher}) for more details.\n   */\n\n  Autolinker.matcher.Email = Autolinker.Util.extend(Autolinker.matcher.Matcher, {\n    /**\n     * The regular expression to match email addresses. Example match:\n     *\n     *     person@place.com\n     *\n     * @private\n     * @property {RegExp} matcherRegex\n     */\n    matcherRegex: function () {\n      var alphaNumericChars = Autolinker.RegexLib.alphaNumericCharsStr,\n          emailRegex = new RegExp('[' + alphaNumericChars + '\\\\-_\\';:&=+$.,]+@'),\n          // something@ for email addresses (a.k.a. local-part)\n      domainNameRegex = Autolinker.RegexLib.domainNameRegex,\n          tldRegex = Autolinker.RegexLib.tldRegex; // match our known top level domains (TLDs)\n\n      return new RegExp([emailRegex.source, domainNameRegex.source, '\\\\.', tldRegex.source // '.com', '.net', etc\n      ].join(\"\"), 'gi');\n    }(),\n\n    /**\n     * @inheritdoc\n     */\n    parseMatches: function parseMatches(text) {\n      var matcherRegex = this.matcherRegex,\n          tagBuilder = this.tagBuilder,\n          matches = [],\n          match;\n\n      while ((match = matcherRegex.exec(text)) !== null) {\n        var matchedText = match[0];\n        matches.push(new Autolinker.match.Email({\n          tagBuilder: tagBuilder,\n          matchedText: matchedText,\n          offset: match.index,\n          email: matchedText\n        }));\n      }\n\n      return matches;\n    }\n  });\n  /*global Autolinker */\n\n  /**\n   * @class Autolinker.matcher.Hashtag\n   * @extends Autolinker.matcher.Matcher\n   *\n   * Matcher to find Hashtag matches in an input string.\n   */\n\n  Autolinker.matcher.Hashtag = Autolinker.Util.extend(Autolinker.matcher.Matcher, {\n    /**\n     * @cfg {String} serviceName\n     *\n     * The service to point hashtag matches to. See {@link Autolinker#hashtag}\n     * for available values.\n     */\n\n    /**\n     * The regular expression to match Hashtags. Example match:\n     *\n     *     #asdf\n     *\n     * @private\n     * @property {RegExp} matcherRegex\n     */\n    matcherRegex: new RegExp('#[_' + Autolinker.RegexLib.alphaNumericCharsStr + ']{1,139}', 'g'),\n\n    /**\n     * The regular expression to use to check the character before a username match to\n     * make sure we didn't accidentally match an email address.\n     *\n     * For example, the string \"asdf@asdf.com\" should not match \"@asdf\" as a username.\n     *\n     * @private\n     * @property {RegExp} nonWordCharRegex\n     */\n    nonWordCharRegex: new RegExp('[^' + Autolinker.RegexLib.alphaNumericCharsStr + ']'),\n\n    /**\n     * @constructor\n     * @param {Object} cfg The configuration properties for the Match instance,\n     *   specified in an Object (map).\n     */\n    constructor: function constructor(cfg) {\n      Autolinker.matcher.Matcher.prototype.constructor.call(this, cfg);\n      this.serviceName = cfg.serviceName;\n    },\n\n    /**\n     * @inheritdoc\n     */\n    parseMatches: function parseMatches(text) {\n      var matcherRegex = this.matcherRegex,\n          nonWordCharRegex = this.nonWordCharRegex,\n          serviceName = this.serviceName,\n          tagBuilder = this.tagBuilder,\n          matches = [],\n          match;\n\n      while ((match = matcherRegex.exec(text)) !== null) {\n        var offset = match.index,\n            prevChar = text.charAt(offset - 1); // If we found the match at the beginning of the string, or we found the match\n        // and there is a whitespace char in front of it (meaning it is not a '#' char\n        // in the middle of a word), then it is a hashtag match.\n\n        if (offset === 0 || nonWordCharRegex.test(prevChar)) {\n          var matchedText = match[0],\n              hashtag = match[0].slice(1); // strip off the '#' character at the beginning\n\n          matches.push(new Autolinker.match.Hashtag({\n            tagBuilder: tagBuilder,\n            matchedText: matchedText,\n            offset: offset,\n            serviceName: serviceName,\n            hashtag: hashtag\n          }));\n        }\n      }\n\n      return matches;\n    }\n  });\n  /*global Autolinker */\n\n  /**\n   * @class Autolinker.matcher.Phone\n   * @extends Autolinker.matcher.Matcher\n   *\n   * Matcher to find Phone number matches in an input string.\n   *\n   * See this class's superclass ({@link Autolinker.matcher.Matcher}) for more\n   * details.\n   */\n\n  Autolinker.matcher.Phone = Autolinker.Util.extend(Autolinker.matcher.Matcher, {\n    /**\n     * The regular expression to match Phone numbers. Example match:\n     *\n     *     (123) 456-7890\n     *\n     * This regular expression has the following capturing groups:\n     *\n     * 1. The prefixed '+' sign, if there is one.\n     *\n     * @private\n     * @property {RegExp} matcherRegex\n     */\n    matcherRegex: /(?:(\\+)?\\d{1,3}[-\\040.])?\\(?\\d{3}\\)?[-\\040.]?\\d{3}[-\\040.]\\d{4}/g,\n    // ex: (123) 456-7890, 123 456 7890, 123-456-7890, etc.\n\n    /**\n     * @inheritdoc\n     */\n    parseMatches: function parseMatches(text) {\n      var matcherRegex = this.matcherRegex,\n          tagBuilder = this.tagBuilder,\n          matches = [],\n          match;\n\n      while ((match = matcherRegex.exec(text)) !== null) {\n        // Remove non-numeric values from phone number string\n        var matchedText = match[0],\n            cleanNumber = matchedText.replace(/\\D/g, ''),\n            // strip out non-digit characters\n        plusSign = !!match[1]; // match[ 1 ] is the prefixed plus sign, if there is one\n\n        matches.push(new Autolinker.match.Phone({\n          tagBuilder: tagBuilder,\n          matchedText: matchedText,\n          offset: match.index,\n          number: cleanNumber,\n          plusSign: plusSign\n        }));\n      }\n\n      return matches;\n    }\n  });\n  /*global Autolinker */\n\n  /**\n   * @class Autolinker.matcher.Twitter\n   * @extends Autolinker.matcher.Matcher\n   *\n   * Matcher to find/replace username matches in an input string.\n   */\n\n  Autolinker.matcher.Twitter = Autolinker.Util.extend(Autolinker.matcher.Matcher, {\n    /**\n     * The regular expression to match username handles. Example match:\n     *\n     *     @asdf\n     *\n     * @private\n     * @property {RegExp} matcherRegex\n     */\n    matcherRegex: new RegExp('@[_' + Autolinker.RegexLib.alphaNumericCharsStr + ']{1,20}', 'g'),\n\n    /**\n     * The regular expression to use to check the character before a username match to\n     * make sure we didn't accidentally match an email address.\n     *\n     * For example, the string \"asdf@asdf.com\" should not match \"@asdf\" as a username.\n     *\n     * @private\n     * @property {RegExp} nonWordCharRegex\n     */\n    nonWordCharRegex: new RegExp('[^' + Autolinker.RegexLib.alphaNumericCharsStr + ']'),\n\n    /**\n     * @inheritdoc\n     */\n    parseMatches: function parseMatches(text) {\n      var matcherRegex = this.matcherRegex,\n          nonWordCharRegex = this.nonWordCharRegex,\n          tagBuilder = this.tagBuilder,\n          matches = [],\n          match;\n\n      while ((match = matcherRegex.exec(text)) !== null) {\n        var offset = match.index,\n            prevChar = text.charAt(offset - 1); // If we found the match at the beginning of the string, or we found the match\n        // and there is a whitespace char in front of it (meaning it is not an email\n        // address), then it is a username match.\n\n        if (offset === 0 || nonWordCharRegex.test(prevChar)) {\n          var matchedText = match[0],\n              twitterHandle = match[0].slice(1); // strip off the '@' character at the beginning\n\n          matches.push(new Autolinker.match.Twitter({\n            tagBuilder: tagBuilder,\n            matchedText: matchedText,\n            offset: offset,\n            twitterHandle: twitterHandle\n          }));\n        }\n      }\n\n      return matches;\n    }\n  });\n  /*global Autolinker */\n\n  /**\n   * @class Autolinker.matcher.Url\n   * @extends Autolinker.matcher.Matcher\n   *\n   * Matcher to find URL matches in an input string.\n   *\n   * See this class's superclass ({@link Autolinker.matcher.Matcher}) for more details.\n   */\n\n  Autolinker.matcher.Url = Autolinker.Util.extend(Autolinker.matcher.Matcher, {\n    /**\n     * @cfg {Boolean} stripPrefix (required)\n     * @inheritdoc Autolinker#stripPrefix\n     */\n\n    /**\n     * @private\n     * @property {RegExp} matcherRegex\n     *\n     * The regular expression to match URLs with an optional scheme, port\n     * number, path, query string, and hash anchor.\n     *\n     * Example matches:\n     *\n     *     http://google.com\n     *     www.google.com\n     *     google.com/path/to/file?q1=1&q2=2#myAnchor\n     *\n     *\n     * This regular expression will have the following capturing groups:\n     *\n     * 1.  Group that matches a scheme-prefixed URL (i.e. 'http://google.com').\n     *     This is used to match scheme URLs with just a single word, such as\n     *     'http://localhost', where we won't double check that the domain name\n     *     has at least one dot ('.') in it.\n     * 2.  Group that matches a 'www.' prefixed URL. This is only matched if the\n     *     'www.' text was not prefixed by a scheme (i.e.: not prefixed by\n     *     'http://', 'ftp:', etc.)\n     * 3.  A protocol-relative ('//') match for the case of a 'www.' prefixed\n     *     URL. Will be an empty string if it is not a protocol-relative match.\n     *     We need to know the character before the '//' in order to determine\n     *     if it is a valid match or the // was in a string we don't want to\n     *     auto-link.\n     * 4.  Group that matches a known TLD (top level domain), when a scheme\n     *     or 'www.'-prefixed domain is not matched.\n     * 5.  A protocol-relative ('//') match for the case of a known TLD prefixed\n     *     URL. Will be an empty string if it is not a protocol-relative match.\n     *     See #3 for more info.\n     */\n    matcherRegex: function () {\n      var schemeRegex = /(?:[A-Za-z][-.+A-Za-z0-9]*:(?![A-Za-z][-.+A-Za-z0-9]*:\\/\\/)(?!\\d+\\/?)(?:\\/\\/)?)/,\n          // match protocol, allow in format \"http://\" or \"mailto:\". However, do not match the first part of something like 'link:http://www.google.com' (i.e. don't match \"link:\"). Also, make sure we don't interpret 'google.com:8000' as if 'google.com' was a protocol here (i.e. ignore a trailing port number in this regex)\n      wwwRegex = /(?:www\\.)/,\n          // starting with 'www.'\n      domainNameRegex = Autolinker.RegexLib.domainNameRegex,\n          tldRegex = Autolinker.RegexLib.tldRegex,\n          // match our known top level domains (TLDs)\n      alphaNumericCharsStr = Autolinker.RegexLib.alphaNumericCharsStr,\n          // Allow optional path, query string, and hash anchor, not ending in the following characters: \"?!:,.;\"\n      // http://blog.codinghorror.com/the-problem-with-urls/\n      urlSuffixRegex = new RegExp('[' + alphaNumericCharsStr + '\\\\-+&@#/%=~_()|\\'$*\\\\[\\\\]?!:,.;]*[' + alphaNumericCharsStr + '\\\\-+&@#/%=~_()|\\'$*\\\\[\\\\]]');\n      return new RegExp(['(?:', // parens to cover match for scheme (optional), and domain\n      '(', // *** Capturing group $1, for a scheme-prefixed url (ex: http://google.com)\n      schemeRegex.source, domainNameRegex.source, ')', '|', '(', // *** Capturing group $2, for a 'www.' prefixed url (ex: www.google.com)\n      '(//)?', // *** Capturing group $3 for an optional protocol-relative URL. Must be at the beginning of the string or start with a non-word character (handled later)\n      wwwRegex.source, domainNameRegex.source, ')', '|', '(', // *** Capturing group $4, for known a TLD url (ex: google.com)\n      '(//)?', // *** Capturing group $5 for an optional protocol-relative URL. Must be at the beginning of the string or start with a non-word character (handled later)\n      domainNameRegex.source + '\\\\.', tldRegex.source, ')', ')', '(?:' + urlSuffixRegex.source + ')?' // match for path, query string, and/or hash anchor - optional\n      ].join(\"\"), 'gi');\n    }(),\n\n    /**\n     * A regular expression to use to check the character before a protocol-relative\n     * URL match. We don't want to match a protocol-relative URL if it is part\n     * of another word.\n     *\n     * For example, we want to match something like \"Go to: //google.com\",\n     * but we don't want to match something like \"abc//google.com\"\n     *\n     * This regular expression is used to test the character before the '//'.\n     *\n     * @private\n     * @type {RegExp} wordCharRegExp\n     */\n    wordCharRegExp: /\\w/,\n\n    /**\n     * The regular expression to match opening parenthesis in a URL match.\n     *\n     * This is to determine if we have unbalanced parenthesis in the URL, and to\n     * drop the final parenthesis that was matched if so.\n     *\n     * Ex: The text \"(check out: wikipedia.com/something_(disambiguation))\"\n     * should only autolink the inner \"wikipedia.com/something_(disambiguation)\"\n     * part, so if we find that we have unbalanced parenthesis, we will drop the\n     * last one for the match.\n     *\n     * @private\n     * @property {RegExp}\n     */\n    openParensRe: /\\(/g,\n\n    /**\n     * The regular expression to match closing parenthesis in a URL match. See\n     * {@link #openParensRe} for more information.\n     *\n     * @private\n     * @property {RegExp}\n     */\n    closeParensRe: /\\)/g,\n\n    /**\n     * @constructor\n     * @param {Object} cfg The configuration properties for the Match instance,\n     *   specified in an Object (map).\n     */\n    constructor: function constructor(cfg) {\n      Autolinker.matcher.Matcher.prototype.constructor.call(this, cfg);\n      this.stripPrefix = cfg.stripPrefix;\n      if (this.stripPrefix == null) throw new Error('`stripPrefix` cfg required');\n    },\n\n    /**\n     * @inheritdoc\n     */\n    parseMatches: function parseMatches(text) {\n      var matcherRegex = this.matcherRegex,\n          stripPrefix = this.stripPrefix,\n          tagBuilder = this.tagBuilder,\n          matches = [],\n          match;\n\n      while ((match = matcherRegex.exec(text)) !== null) {\n        var matchStr = match[0],\n            schemeUrlMatch = match[1],\n            wwwUrlMatch = match[2],\n            wwwProtocolRelativeMatch = match[3],\n            //tldUrlMatch = match[ 4 ],  -- not needed at the moment\n        tldProtocolRelativeMatch = match[5],\n            offset = match.index,\n            protocolRelativeMatch = wwwProtocolRelativeMatch || tldProtocolRelativeMatch,\n            prevChar = text.charAt(offset - 1);\n\n        if (!Autolinker.matcher.UrlMatchValidator.isValid(matchStr, schemeUrlMatch)) {\n          continue;\n        } // If the match is preceded by an '@' character, then it is either\n        // an email address or a username. Skip these types of matches.\n\n\n        if (offset > 0 && prevChar === '@') {\n          continue;\n        } // If it's a protocol-relative '//' match, but the character before the '//'\n        // was a word character (i.e. a letter/number), then we found the '//' in the\n        // middle of another word (such as \"asdf//asdf.com\"). In this case, skip the\n        // match.\n\n\n        if (offset > 0 && protocolRelativeMatch && this.wordCharRegExp.test(prevChar)) {\n          continue;\n        } // Handle a closing parenthesis at the end of the match, and exclude\n        // it if there is not a matching open parenthesis in the match\n        // itself.\n\n\n        if (this.matchHasUnbalancedClosingParen(matchStr)) {\n          matchStr = matchStr.substr(0, matchStr.length - 1); // remove the trailing \")\"\n        } else {\n          // Handle an invalid character after the TLD\n          var pos = this.matchHasInvalidCharAfterTld(matchStr, schemeUrlMatch);\n\n          if (pos > -1) {\n            matchStr = matchStr.substr(0, pos); // remove the trailing invalid chars\n          }\n        }\n\n        var urlMatchType = schemeUrlMatch ? 'scheme' : wwwUrlMatch ? 'www' : 'tld',\n            protocolUrlMatch = !!schemeUrlMatch;\n        matches.push(new Autolinker.match.Url({\n          tagBuilder: tagBuilder,\n          matchedText: matchStr,\n          offset: offset,\n          urlMatchType: urlMatchType,\n          url: matchStr,\n          protocolUrlMatch: protocolUrlMatch,\n          protocolRelativeMatch: !!protocolRelativeMatch,\n          stripPrefix: stripPrefix\n        }));\n      }\n\n      return matches;\n    },\n\n    /**\n     * Determines if a match found has an unmatched closing parenthesis. If so,\n     * this parenthesis will be removed from the match itself, and appended\n     * after the generated anchor tag.\n     *\n     * A match may have an extra closing parenthesis at the end of the match\n     * because the regular expression must include parenthesis for URLs such as\n     * \"wikipedia.com/something_(disambiguation)\", which should be auto-linked.\n     *\n     * However, an extra parenthesis *will* be included when the URL itself is\n     * wrapped in parenthesis, such as in the case of \"(wikipedia.com/something_(disambiguation))\".\n     * In this case, the last closing parenthesis should *not* be part of the\n     * URL itself, and this method will return `true`.\n     *\n     * @private\n     * @param {String} matchStr The full match string from the {@link #matcherRegex}.\n     * @return {Boolean} `true` if there is an unbalanced closing parenthesis at\n     *   the end of the `matchStr`, `false` otherwise.\n     */\n    matchHasUnbalancedClosingParen: function matchHasUnbalancedClosingParen(matchStr) {\n      var lastChar = matchStr.charAt(matchStr.length - 1);\n\n      if (lastChar === ')') {\n        var openParensMatch = matchStr.match(this.openParensRe),\n            closeParensMatch = matchStr.match(this.closeParensRe),\n            numOpenParens = openParensMatch && openParensMatch.length || 0,\n            numCloseParens = closeParensMatch && closeParensMatch.length || 0;\n\n        if (numOpenParens < numCloseParens) {\n          return true;\n        }\n      }\n\n      return false;\n    },\n\n    /**\n     * Determine if there's an invalid character after the TLD in a URL. Valid\n     * characters after TLD are ':/?#'. Exclude scheme matched URLs from this\n     * check.\n     *\n     * @private\n     * @param {String} urlMatch The matched URL, if there was one. Will be an\n     *   empty string if the match is not a URL match.\n     * @param {String} schemeUrlMatch The match URL string for a scheme\n     *   match. Ex: 'http://yahoo.com'. This is used to match something like\n     *   'http://localhost', where we won't double check that the domain name\n     *   has at least one '.' in it.\n     * @return {Number} the position where the invalid character was found. If\n     *   no such character was found, returns -1\n     */\n    matchHasInvalidCharAfterTld: function matchHasInvalidCharAfterTld(urlMatch, schemeUrlMatch) {\n      if (!urlMatch) {\n        return -1;\n      }\n\n      var offset = 0;\n\n      if (schemeUrlMatch) {\n        offset = urlMatch.indexOf(':');\n        urlMatch = urlMatch.slice(offset);\n      }\n\n      var re = /^((.?\\/\\/)?[A-Za-z0-9\\u00C0-\\u017F\\.\\-]*[A-Za-z0-9\\u00C0-\\u017F\\-]\\.[A-Za-z]+)/;\n      var res = re.exec(urlMatch);\n\n      if (res === null) {\n        return -1;\n      }\n\n      offset += res[1].length;\n      urlMatch = urlMatch.slice(res[1].length);\n\n      if (/^[^.A-Za-z:\\/?#]/.test(urlMatch)) {\n        return offset;\n      }\n\n      return -1;\n    }\n  });\n  /*global Autolinker */\n\n  /*jshint scripturl:true */\n\n  /**\n   * @private\n   * @class Autolinker.matcher.UrlMatchValidator\n   * @singleton\n   *\n   * Used by Autolinker to filter out false URL positives from the\n   * {@link Autolinker.matcher.Url UrlMatcher}.\n   *\n   * Due to the limitations of regular expressions (including the missing feature\n   * of look-behinds in JS regular expressions), we cannot always determine the\n   * validity of a given match. This class applies a bit of additional logic to\n   * filter out any false positives that have been matched by the\n   * {@link Autolinker.matcher.Url UrlMatcher}.\n   */\n\n  Autolinker.matcher.UrlMatchValidator = {\n    /**\n     * Regex to test for a full protocol, with the two trailing slashes. Ex: 'http://'\n     *\n     * @private\n     * @property {RegExp} hasFullProtocolRegex\n     */\n    hasFullProtocolRegex: /^[A-Za-z][-.+A-Za-z0-9]*:\\/\\//,\n\n    /**\n     * Regex to find the URI scheme, such as 'mailto:'.\n     *\n     * This is used to filter out 'javascript:' and 'vbscript:' schemes.\n     *\n     * @private\n     * @property {RegExp} uriSchemeRegex\n     */\n    uriSchemeRegex: /^[A-Za-z][-.+A-Za-z0-9]*:/,\n\n    /**\n     * Regex to determine if at least one word char exists after the protocol (i.e. after the ':')\n     *\n     * @private\n     * @property {RegExp} hasWordCharAfterProtocolRegex\n     */\n    hasWordCharAfterProtocolRegex: /:[^\\s]*?[A-Za-z\\u00C0-\\u017F]/,\n\n    /**\n     * Regex to determine if the string is a valid IP address\n     *\n     * @private\n     * @property {RegExp} ipRegex\n     */\n    ipRegex: /[0-9][0-9]?[0-9]?\\.[0-9][0-9]?[0-9]?\\.[0-9][0-9]?[0-9]?\\.[0-9][0-9]?[0-9]?(:[0-9]*)?\\/?$/,\n\n    /**\n     * Determines if a given URL match found by the {@link Autolinker.matcher.Url UrlMatcher}\n     * is valid. Will return `false` for:\n     *\n     * 1) URL matches which do not have at least have one period ('.') in the\n     *    domain name (effectively skipping over matches like \"abc:def\").\n     *    However, URL matches with a protocol will be allowed (ex: 'http://localhost')\n     * 2) URL matches which do not have at least one word character in the\n     *    domain name (effectively skipping over matches like \"git:1.0\").\n     * 3) A protocol-relative url match (a URL beginning with '//') whose\n     *    previous character is a word character (effectively skipping over\n     *    strings like \"abc//google.com\")\n     *\n     * Otherwise, returns `true`.\n     *\n     * @param {String} urlMatch The matched URL, if there was one. Will be an\n     *   empty string if the match is not a URL match.\n     * @param {String} protocolUrlMatch The match URL string for a protocol\n     *   match. Ex: 'http://yahoo.com'. This is used to match something like\n     *   'http://localhost', where we won't double check that the domain name\n     *   has at least one '.' in it.\n     * @return {Boolean} `true` if the match given is valid and should be\n     *   processed, or `false` if the match is invalid and/or should just not be\n     *   processed.\n     */\n    isValid: function isValid(urlMatch, protocolUrlMatch) {\n      if (protocolUrlMatch && !this.isValidUriScheme(protocolUrlMatch) || this.urlMatchDoesNotHaveProtocolOrDot(urlMatch, protocolUrlMatch) || // At least one period ('.') must exist in the URL match for us to consider it an actual URL, *unless* it was a full protocol match (like 'http://localhost')\n      this.urlMatchDoesNotHaveAtLeastOneWordChar(urlMatch, protocolUrlMatch) && // At least one letter character must exist in the domain name after a protocol match. Ex: skip over something like \"git:1.0\"\n      !this.isValidIpAddress(urlMatch) // Except if it's an IP address\n      ) {\n        return false;\n      }\n\n      return true;\n    },\n    isValidIpAddress: function isValidIpAddress(uriSchemeMatch) {\n      var newRegex = new RegExp(this.hasFullProtocolRegex.source + this.ipRegex.source);\n      var uriScheme = uriSchemeMatch.match(newRegex);\n      return uriScheme !== null;\n    },\n\n    /**\n     * Determines if the URI scheme is a valid scheme to be autolinked. Returns\n     * `false` if the scheme is 'javascript:' or 'vbscript:'\n     *\n     * @private\n     * @param {String} uriSchemeMatch The match URL string for a full URI scheme\n     *   match. Ex: 'http://yahoo.com' or 'mailto:a@a.com'.\n     * @return {Boolean} `true` if the scheme is a valid one, `false` otherwise.\n     */\n    isValidUriScheme: function isValidUriScheme(uriSchemeMatch) {\n      var uriScheme = uriSchemeMatch.match(this.uriSchemeRegex)[0].toLowerCase();\n      return uriScheme !== 'javascript:' && uriScheme !== 'vbscript:';\n    },\n\n    /**\n     * Determines if a URL match does not have either:\n     *\n     * a) a full protocol (i.e. 'http://'), or\n     * b) at least one dot ('.') in the domain name (for a non-full-protocol\n     *    match).\n     *\n     * Either situation is considered an invalid URL (ex: 'git:d' does not have\n     * either the '://' part, or at least one dot in the domain name. If the\n     * match was 'git:abc.com', we would consider this valid.)\n     *\n     * @private\n     * @param {String} urlMatch The matched URL, if there was one. Will be an\n     *   empty string if the match is not a URL match.\n     * @param {String} protocolUrlMatch The match URL string for a protocol\n     *   match. Ex: 'http://yahoo.com'. This is used to match something like\n     *   'http://localhost', where we won't double check that the domain name\n     *   has at least one '.' in it.\n     * @return {Boolean} `true` if the URL match does not have a full protocol,\n     *   or at least one dot ('.') in a non-full-protocol match.\n     */\n    urlMatchDoesNotHaveProtocolOrDot: function urlMatchDoesNotHaveProtocolOrDot(urlMatch, protocolUrlMatch) {\n      return !!urlMatch && (!protocolUrlMatch || !this.hasFullProtocolRegex.test(protocolUrlMatch)) && urlMatch.indexOf('.') === -1;\n    },\n\n    /**\n     * Determines if a URL match does not have at least one word character after\n     * the protocol (i.e. in the domain name).\n     *\n     * At least one letter character must exist in the domain name after a\n     * protocol match. Ex: skip over something like \"git:1.0\"\n     *\n     * @private\n     * @param {String} urlMatch The matched URL, if there was one. Will be an\n     *   empty string if the match is not a URL match.\n     * @param {String} protocolUrlMatch The match URL string for a protocol\n     *   match. Ex: 'http://yahoo.com'. This is used to know whether or not we\n     *   have a protocol in the URL string, in order to check for a word\n     *   character after the protocol separator (':').\n     * @return {Boolean} `true` if the URL match does not have at least one word\n     *   character in it after the protocol, `false` otherwise.\n     */\n    urlMatchDoesNotHaveAtLeastOneWordChar: function urlMatchDoesNotHaveAtLeastOneWordChar(urlMatch, protocolUrlMatch) {\n      if (urlMatch && protocolUrlMatch) {\n        return !this.hasWordCharAfterProtocolRegex.test(urlMatch);\n      } else {\n        return false;\n      }\n    }\n  };\n  /*global Autolinker */\n\n  /**\n   * A truncation feature where the ellipsis will be placed at the end of the URL.\n   *\n   * @param {String} anchorText\n   * @param {Number} truncateLen The maximum length of the truncated output URL string.\n   * @param {String} ellipsisChars The characters to place within the url, e.g. \"..\".\n   * @return {String} The truncated URL.\n   */\n\n  Autolinker.truncate.TruncateEnd = function (anchorText, truncateLen, ellipsisChars) {\n    return Autolinker.Util.ellipsis(anchorText, truncateLen, ellipsisChars);\n  };\n  /*global Autolinker */\n\n  /**\n   * Date: 2015-10-05\n   * Author: Kasper Søfren <soefritz@gmail.com> (https://github.com/kafoso)\n   *\n   * A truncation feature, where the ellipsis will be placed in the dead-center of the URL.\n   *\n   * @param {String} url             A URL.\n   * @param {Number} truncateLen     The maximum length of the truncated output URL string.\n   * @param {String} ellipsisChars   The characters to place within the url, e.g. \"..\".\n   * @return {String} The truncated URL.\n   */\n\n\n  Autolinker.truncate.TruncateMiddle = function (url, truncateLen, ellipsisChars) {\n    if (url.length <= truncateLen) {\n      return url;\n    }\n\n    var availableLength = truncateLen - ellipsisChars.length;\n    var end = \"\";\n\n    if (availableLength > 0) {\n      end = url.substr(-1 * Math.floor(availableLength / 2));\n    }\n\n    return (url.substr(0, Math.ceil(availableLength / 2)) + ellipsisChars + end).substr(0, truncateLen);\n  };\n  /*global Autolinker */\n\n  /**\n   * Date: 2015-10-05\n   * Author: Kasper Søfren <soefritz@gmail.com> (https://github.com/kafoso)\n   *\n   * A truncation feature, where the ellipsis will be placed at a section within\n   * the URL making it still somewhat human readable.\n   *\n   * @param {String} url\t\t\t\t\t\t A URL.\n   * @param {Number} truncateLen\t\t The maximum length of the truncated output URL string.\n   * @param {String} ellipsisChars\t The characters to place within the url, e.g. \"..\".\n   * @return {String} The truncated URL.\n   */\n\n\n  Autolinker.truncate.TruncateSmart = function (url, truncateLen, ellipsisChars) {\n    var parse_url = function parse_url(url) {\n      // Functionality inspired by PHP function of same name\n      var urlObj = {};\n      var urlSub = url;\n      var match = urlSub.match(/^([a-z]+):\\/\\//i);\n\n      if (match) {\n        urlObj.scheme = match[1];\n        urlSub = urlSub.substr(match[0].length);\n      }\n\n      match = urlSub.match(/^(.*?)(?=(\\?|#|\\/|$))/i);\n\n      if (match) {\n        urlObj.host = match[1];\n        urlSub = urlSub.substr(match[0].length);\n      }\n\n      match = urlSub.match(/^\\/(.*?)(?=(\\?|#|$))/i);\n\n      if (match) {\n        urlObj.path = match[1];\n        urlSub = urlSub.substr(match[0].length);\n      }\n\n      match = urlSub.match(/^\\?(.*?)(?=(#|$))/i);\n\n      if (match) {\n        urlObj.query = match[1];\n        urlSub = urlSub.substr(match[0].length);\n      }\n\n      match = urlSub.match(/^#(.*?)$/i);\n\n      if (match) {\n        urlObj.fragment = match[1]; //urlSub = urlSub.substr(match[0].length);  -- not used. Uncomment if adding another block.\n      }\n\n      return urlObj;\n    };\n\n    var buildUrl = function buildUrl(urlObj) {\n      var url = \"\";\n\n      if (urlObj.scheme && urlObj.host) {\n        url += urlObj.scheme + \"://\";\n      }\n\n      if (urlObj.host) {\n        url += urlObj.host;\n      }\n\n      if (urlObj.path) {\n        url += \"/\" + urlObj.path;\n      }\n\n      if (urlObj.query) {\n        url += \"?\" + urlObj.query;\n      }\n\n      if (urlObj.fragment) {\n        url += \"#\" + urlObj.fragment;\n      }\n\n      return url;\n    };\n\n    var buildSegment = function buildSegment(segment, remainingAvailableLength) {\n      var remainingAvailableLengthHalf = remainingAvailableLength / 2,\n          startOffset = Math.ceil(remainingAvailableLengthHalf),\n          endOffset = -1 * Math.floor(remainingAvailableLengthHalf),\n          end = \"\";\n\n      if (endOffset < 0) {\n        end = segment.substr(endOffset);\n      }\n\n      return segment.substr(0, startOffset) + ellipsisChars + end;\n    };\n\n    if (url.length <= truncateLen) {\n      return url;\n    }\n\n    var availableLength = truncateLen - ellipsisChars.length;\n    var urlObj = parse_url(url); // Clean up the URL\n\n    if (urlObj.query) {\n      var matchQuery = urlObj.query.match(/^(.*?)(?=(\\?|\\#))(.*?)$/i);\n\n      if (matchQuery) {\n        // Malformed URL; two or more \"?\". Removed any content behind the 2nd.\n        urlObj.query = urlObj.query.substr(0, matchQuery[1].length);\n        url = buildUrl(urlObj);\n      }\n    }\n\n    if (url.length <= truncateLen) {\n      return url;\n    }\n\n    if (urlObj.host) {\n      urlObj.host = urlObj.host.replace(/^www\\./, \"\");\n      url = buildUrl(urlObj);\n    }\n\n    if (url.length <= truncateLen) {\n      return url;\n    } // Process and build the URL\n\n\n    var str = \"\";\n\n    if (urlObj.host) {\n      str += urlObj.host;\n    }\n\n    if (str.length >= availableLength) {\n      if (urlObj.host.length == truncateLen) {\n        return (urlObj.host.substr(0, truncateLen - ellipsisChars.length) + ellipsisChars).substr(0, truncateLen);\n      }\n\n      return buildSegment(str, availableLength).substr(0, truncateLen);\n    }\n\n    var pathAndQuery = \"\";\n\n    if (urlObj.path) {\n      pathAndQuery += \"/\" + urlObj.path;\n    }\n\n    if (urlObj.query) {\n      pathAndQuery += \"?\" + urlObj.query;\n    }\n\n    if (pathAndQuery) {\n      if ((str + pathAndQuery).length >= availableLength) {\n        if ((str + pathAndQuery).length == truncateLen) {\n          return (str + pathAndQuery).substr(0, truncateLen);\n        }\n\n        var remainingAvailableLength = availableLength - str.length;\n        return (str + buildSegment(pathAndQuery, remainingAvailableLength)).substr(0, truncateLen);\n      } else {\n        str += pathAndQuery;\n      }\n    }\n\n    if (urlObj.fragment) {\n      var fragment = \"#\" + urlObj.fragment;\n\n      if ((str + fragment).length >= availableLength) {\n        if ((str + fragment).length == truncateLen) {\n          return (str + fragment).substr(0, truncateLen);\n        }\n\n        var remainingAvailableLength2 = availableLength - str.length;\n        return (str + buildSegment(fragment, remainingAvailableLength2)).substr(0, truncateLen);\n      } else {\n        str += fragment;\n      }\n    }\n\n    if (urlObj.scheme && urlObj.host) {\n      var scheme = urlObj.scheme + \"://\";\n\n      if ((str + scheme).length < availableLength) {\n        return (scheme + str).substr(0, truncateLen);\n      }\n    }\n\n    if (str.length <= truncateLen) {\n      return str;\n    }\n\n    var end = \"\";\n\n    if (availableLength > 0) {\n      end = str.substr(-1 * Math.floor(availableLength / 2));\n    }\n\n    return (str.substr(0, Math.ceil(availableLength / 2)) + ellipsisChars + end).substr(0, truncateLen);\n  };\n\n  return Autolinker;\n});","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * @emails react-core\n */\n\nimport React, {Component} from 'react';\nimport ReactDOM from 'react-dom';\nimport Remarkable from 'remarkable';\nimport {LiveEditor, LiveProvider} from 'react-live';\nimport {colors, media} from 'theme';\nimport MetaTitle from 'templates/components/MetaTitle';\n\n// Replace unicode to text for other languages\nconst unicodeToText = text =>\n  text.replace(/\\\\u([\\dA-F]{4})/gi, (_, p1) =>\n    String.fromCharCode(parseInt(p1, 16)),\n  );\n\nconst compileES5 = (\n  code, // eslint-disable-next-line no-undef\n) => Babel.transform(code, {presets: ['es2015', 'react']}).code;\n\n// eslint-disable-next-line no-undef\nconst compileES6 = code => Babel.transform(code, {presets: ['react']}).code;\n\nclass CodeEditor extends Component {\n  constructor(props, context) {\n    super(props, context);\n\n    this.state = this._updateState(props.code);\n    this.state.showJSX = true;\n  }\n\n  componentDidMount() {\n    this._render();\n  }\n\n  componentDidUpdate(prevProps, prevState) {\n    if (prevState.compiled !== this.state.compiled) {\n      this._render();\n    }\n  }\n\n  UNSAFE_componentWillReceiveProps(nextProps) {\n    if (this.props.code !== nextProps.code) {\n      this.setState(this._updateState(nextProps.code));\n    }\n  }\n\n  render() {\n    const {containerNodeID} = this.props;\n    const {\n      compiledES6,\n      code,\n      error,\n      showBabelErrorMessage,\n      showJSX,\n    } = this.state;\n\n    let errorMessage;\n    if (showBabelErrorMessage) {\n      errorMessage = (\n        <span>\n          Babel could not be loaded.\n          <br />\n          <br />\n          This can be caused by an ad blocker. If you're using one, consider\n          adding reactjs.org to the whitelist so the live code examples will\n          work.\n        </span>\n      );\n    } else if (error != null) {\n      errorMessage = error.message;\n    }\n\n    return (\n      <LiveProvider code={showJSX ? code : compiledES6} mountStylesheet={false}>\n        <div\n          css={{\n            [media.greaterThan('medium')]: {\n              display: 'flex',\n              alignItems: 'stretch',\n              flexDirection: 'row',\n            },\n\n            [media.lessThan('small')]: {\n              display: 'block',\n            },\n          }}>\n          <div\n            css={{\n              flex: '0 0 70%',\n              overflow: 'hidden',\n              borderRadius: '10px 0 0 10px',\n\n              [media.lessThan('medium')]: {\n                borderRadius: '10px 10px 0 0',\n              },\n            }}>\n            <div\n              css={{\n                padding: '0px 10px',\n                background: colors.darker,\n                color: colors.white,\n              }}>\n              <MetaTitle onDark={true}>\n                Live JSX Editor\n                <label\n                  css={{\n                    fontSize: 14,\n                    float: 'right',\n                    cursor: 'pointer',\n                  }}>\n                  <input\n                    checked={this.state.showJSX}\n                    onChange={event =>\n                      this.setState({showJSX: event.target.checked})\n                    }\n                    type=\"checkbox\"\n                  />{' '}\n                  JSX?\n                </label>\n              </MetaTitle>\n            </div>\n            <div\n              css={{\n                height: '100%',\n                width: '100%',\n                borderRadius: '0',\n                maxHeight: '340px !important',\n                marginTop: '0 !important',\n                marginLeft: '0 !important',\n                paddingLeft: '0 !important',\n                marginRight: '0 !important',\n                paddingRight: '0 !important',\n                marginBottom: '0 !important',\n                paddingBottom: '20px !important',\n                [media.lessThan('medium')]: {\n                  marginBottom: '0 !important',\n                },\n\n                '& pre.prism-code[contenteditable]': {\n                  outline: 0,\n                  overflow: 'auto',\n                  marginRight: '0 !important',\n                  marginBottom: '0 !important',\n                },\n              }}\n              className=\"gatsby-highlight\">\n              <LiveEditor ignoreTabKey={true} onChange={this._onChange} />\n            </div>\n          </div>\n          {error && (\n            <div\n              css={{\n                flex: '0 0 30%',\n                overflow: 'hidden',\n                border: `1px solid ${colors.error}`,\n                borderRadius: '0 10px 10px 0',\n                fontSize: 12,\n                lineHeight: 1.5,\n\n                [media.lessThan('medium')]: {\n                  borderRadius: '0 0 10px 10px',\n                },\n              }}>\n              <div\n                css={{\n                  padding: '0px 10px',\n                  background: colors.error,\n                  color: colors.white,\n                }}>\n                <MetaTitle\n                  cssProps={{\n                    color: colors.white,\n                  }}>\n                  Error\n                </MetaTitle>\n              </div>\n              <pre\n                css={{\n                  whiteSpace: 'pre-wrap',\n                  wordBreak: 'break-word',\n                  color: colors.error,\n                  padding: 10,\n                }}>\n                {errorMessage}\n              </pre>\n            </div>\n          )}\n          {!error && (\n            <div\n              css={{\n                flex: '0 0 30%',\n                overflow: 'hidden',\n                border: `1px solid ${colors.divider}`,\n                borderRadius: '0 10px 10px 0',\n\n                [media.lessThan('medium')]: {\n                  borderRadius: '0 0 10px 10px',\n                },\n              }}>\n              <div\n                css={{\n                  padding: '0 10px',\n                  backgroundColor: colors.divider,\n                }}>\n                <MetaTitle>Result</MetaTitle>\n              </div>\n              <div\n                id={containerNodeID}\n                css={{\n                  padding: 10,\n                  maxHeight: '340px !important',\n                  overflow: 'auto',\n\n                  '& input': {\n                    width: '100%',\n                    display: 'block',\n                    border: '1px solid #ccc', // TODO\n                    padding: 5,\n                  },\n\n                  '& button': {\n                    marginTop: 10,\n                    padding: '5px 10px',\n                  },\n\n                  '& label': {\n                    display: 'block',\n                    marginTop: 10,\n                  },\n\n                  '& textarea': {\n                    width: '100%',\n                    height: 60,\n                    padding: 5,\n                  },\n                }}\n              />\n            </div>\n          )}\n        </div>\n      </LiveProvider>\n    );\n  }\n\n  _render() {\n    const {compiled} = this.state;\n    const {containerNodeID} = this.props;\n\n    // Until we upgrade Gatsby to React 18, fake the new root API.\n    const root = {\n      render: element => {\n        ReactDOM.render(element, document.getElementById(containerNodeID));\n      },\n    };\n\n    try {\n      // Example code requires React, ReactDOM, and Remarkable to be within scope.\n      // It also requires a \"mountNode\" variable for ReactDOM.render()\n      // eslint-disable-next-line no-new-func\n      new Function('React', 'ReactDOM', 'root', 'Remarkable', compiled)(\n        React,\n        ReactDOM,\n        root,\n        Remarkable,\n      );\n    } catch (error) {\n      console.error(error);\n\n      this.setState({\n        compiled: null,\n        error,\n      });\n    }\n  }\n\n  _updateState(code, showJSX = true) {\n    try {\n      const newState = {\n        compiled: compileES5(code),\n        error: null,\n      };\n\n      if (showJSX) {\n        newState.code = code;\n        newState.compiledES6 = unicodeToText(compileES6(code));\n      } else {\n        newState.compiledES6 = code;\n      }\n\n      return newState;\n    } catch (error) {\n      console.error(error);\n\n      // Certain ad blockers (eg Fair AdBlocker) prevent Babel from loading.\n      // If we suspect this is the case, we can show a more helpful error.\n      const showBabelErrorMessage = !window.Babel;\n\n      return {\n        compiled: null,\n        error,\n        showBabelErrorMessage,\n      };\n    }\n  }\n\n  _onChange = code => {\n    this.setState(state => this._updateState(code, state.showJSX));\n  };\n}\n\nexport default CodeEditor;\n","'use strict';\nvar $ = require('../internals/export');\nvar $trimStart = require('../internals/string-trim').start;\nvar forcedStringTrimMethod = require('../internals/string-trim-forced');\n\nvar FORCED = forcedStringTrimMethod('trimStart');\n\nvar trimStart = FORCED ? function trimStart() {\n  return $trimStart(this);\n} : ''.trimStart;\n\n// `String.prototype.{ trimStart, trimLeft }` methods\n// https://github.com/tc39/ecmascript-string-left-right-trim\n$({ target: 'String', proto: true, forced: FORCED }, {\n  trimStart: trimStart,\n  trimLeft: trimStart\n});\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * @emails react-core\n */\n\nimport ButtonLink from './ButtonLink';\n\nexport default ButtonLink;\n","// Inline parser state\n'use strict';\n\nfunction StateInline(src, parserInline, options, env, outTokens) {\n  this.src = src;\n  this.env = env;\n  this.options = options;\n  this.parser = parserInline;\n  this.tokens = outTokens;\n  this.pos = 0;\n  this.posMax = this.src.length;\n  this.level = 0;\n  this.pending = '';\n  this.pendingLevel = 0;\n  this.cache = []; // Stores { start: end } pairs. Useful for backtrack\n  // optimization of pairs parse (emphasis, strikes).\n  // Link parser state vars\n\n  this.isInLabel = false; // Set true when seek link label - we should disable\n  // \"paired\" rules (emphasis, strikes) to not skip\n  // tailing `]`\n\n  this.linkLevel = 0; // Increment for each nesting link. Used to prevent\n  // nesting in definitions\n\n  this.linkContent = ''; // Temporary storage for link url\n\n  this.labelUnmatchedScopes = 0; // Track unpaired `[` for link labels\n  // (backtrack optimization)\n} // Flush pending text\n//\n\n\nStateInline.prototype.pushPending = function () {\n  this.tokens.push({\n    type: 'text',\n    content: this.pending,\n    level: this.pendingLevel\n  });\n  this.pending = '';\n}; // Push new token to \"stream\".\n// If pending text exists - flush it as text token\n//\n\n\nStateInline.prototype.push = function (token) {\n  if (this.pending) {\n    this.pushPending();\n  }\n\n  this.tokens.push(token);\n  this.pendingLevel = this.level;\n}; // Store value to cache.\n// !!! Implementation has parser-specific optimizations\n// !!! keys MUST be integer, >= 0; values MUST be integer, > 0\n//\n\n\nStateInline.prototype.cacheSet = function (key, val) {\n  for (var i = this.cache.length; i <= key; i++) {\n    this.cache.push(0);\n  }\n\n  this.cache[key] = val;\n}; // Get cache value\n//\n\n\nStateInline.prototype.cacheGet = function (key) {\n  return key < this.cache.length ? this.cache[key] : 0;\n};\n\nmodule.exports = StateInline;","// Enclose abbreviations in <abbr> tags\n//\n'use strict';\n\nvar PUNCT_CHARS = ' \\n()[]\\'\".,!?-'; // from Google closure library\n// http://closure-library.googlecode.com/git-history/docs/local_closure_goog_string_string.js.source.html#line1021\n\nfunction regEscape(s) {\n  return s.replace(/([-()\\[\\]{}+?*.$\\^|,:#<!\\\\])/g, '\\\\$1');\n}\n\nmodule.exports = function abbr2(state) {\n  var i,\n      j,\n      l,\n      tokens,\n      token,\n      text,\n      nodes,\n      pos,\n      level,\n      reg,\n      m,\n      regText,\n      blockTokens = state.tokens;\n\n  if (!state.env.abbreviations) {\n    return;\n  }\n\n  if (!state.env.abbrRegExp) {\n    regText = '(^|[' + PUNCT_CHARS.split('').map(regEscape).join('') + '])' + '(' + Object.keys(state.env.abbreviations).map(function (x) {\n      return x.substr(1);\n    }).sort(function (a, b) {\n      return b.length - a.length;\n    }).map(regEscape).join('|') + ')' + '($|[' + PUNCT_CHARS.split('').map(regEscape).join('') + '])';\n    state.env.abbrRegExp = new RegExp(regText, 'g');\n  }\n\n  reg = state.env.abbrRegExp;\n\n  for (j = 0, l = blockTokens.length; j < l; j++) {\n    if (blockTokens[j].type !== 'inline') {\n      continue;\n    }\n\n    tokens = blockTokens[j].children; // We scan from the end, to keep position when new tags added.\n\n    for (i = tokens.length - 1; i >= 0; i--) {\n      token = tokens[i];\n\n      if (token.type !== 'text') {\n        continue;\n      }\n\n      pos = 0;\n      text = token.content;\n      reg.lastIndex = 0;\n      level = token.level;\n      nodes = [];\n\n      while (m = reg.exec(text)) {\n        if (reg.lastIndex > pos) {\n          nodes.push({\n            type: 'text',\n            content: text.slice(pos, m.index + m[1].length),\n            level: level\n          });\n        }\n\n        nodes.push({\n          type: 'abbr_open',\n          title: state.env.abbreviations[':' + m[2]],\n          level: level++\n        });\n        nodes.push({\n          type: 'text',\n          content: m[2],\n          level: level\n        });\n        nodes.push({\n          type: 'abbr_close',\n          level: --level\n        });\n        pos = reg.lastIndex - m[3].length;\n      }\n\n      if (!nodes.length) {\n        continue;\n      }\n\n      if (pos < text.length) {\n        nodes.push({\n          type: 'text',\n          content: text.slice(pos),\n          level: level\n        });\n      } // replace current node\n\n\n      blockTokens[j].children = tokens = [].concat(tokens.slice(0, i), nodes, tokens.slice(i + 1));\n    }\n  }\n};","'use strict';\n/**\n * Utility functions\n */\n\nfunction typeOf(obj) {\n  return Object.prototype.toString.call(obj);\n}\n\nfunction isString(obj) {\n  return typeOf(obj) === '[object String]';\n}\n\nvar hasOwn = Object.prototype.hasOwnProperty;\n\nfunction has(object, key) {\n  return object ? hasOwn.call(object, key) : false;\n} // Extend objects\n//\n\n\nfunction assign(obj\n/*from1, from2, from3, ...*/\n) {\n  var sources = [].slice.call(arguments, 1);\n  sources.forEach(function (source) {\n    if (!source) {\n      return;\n    }\n\n    if (typeof source !== 'object') {\n      throw new TypeError(source + 'must be object');\n    }\n\n    Object.keys(source).forEach(function (key) {\n      obj[key] = source[key];\n    });\n  });\n  return obj;\n} ////////////////////////////////////////////////////////////////////////////////\n\n\nvar UNESCAPE_MD_RE = /\\\\([\\\\!\"#$%&'()*+,.\\/:;<=>?@[\\]^_`{|}~-])/g;\n\nfunction unescapeMd(str) {\n  if (str.indexOf('\\\\') < 0) {\n    return str;\n  }\n\n  return str.replace(UNESCAPE_MD_RE, '$1');\n} ////////////////////////////////////////////////////////////////////////////////\n\n\nfunction isValidEntityCode(c) {\n  /*eslint no-bitwise:0*/\n  // broken sequence\n  if (c >= 0xD800 && c <= 0xDFFF) {\n    return false;\n  } // never used\n\n\n  if (c >= 0xFDD0 && c <= 0xFDEF) {\n    return false;\n  }\n\n  if ((c & 0xFFFF) === 0xFFFF || (c & 0xFFFF) === 0xFFFE) {\n    return false;\n  } // control codes\n\n\n  if (c >= 0x00 && c <= 0x08) {\n    return false;\n  }\n\n  if (c === 0x0B) {\n    return false;\n  }\n\n  if (c >= 0x0E && c <= 0x1F) {\n    return false;\n  }\n\n  if (c >= 0x7F && c <= 0x9F) {\n    return false;\n  } // out of range\n\n\n  if (c > 0x10FFFF) {\n    return false;\n  }\n\n  return true;\n}\n\nfunction fromCodePoint(c) {\n  /*eslint no-bitwise:0*/\n  if (c > 0xffff) {\n    c -= 0x10000;\n    var surrogate1 = 0xd800 + (c >> 10),\n        surrogate2 = 0xdc00 + (c & 0x3ff);\n    return String.fromCharCode(surrogate1, surrogate2);\n  }\n\n  return String.fromCharCode(c);\n}\n\nvar NAMED_ENTITY_RE = /&([a-z#][a-z0-9]{1,31});/gi;\nvar DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))/i;\n\nvar entities = require('./entities');\n\nfunction replaceEntityPattern(match, name) {\n  var code = 0;\n\n  if (has(entities, name)) {\n    return entities[name];\n  } else if (name.charCodeAt(0) === 0x23\n  /* # */\n  && DIGITAL_ENTITY_TEST_RE.test(name)) {\n    code = name[1].toLowerCase() === 'x' ? parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);\n\n    if (isValidEntityCode(code)) {\n      return fromCodePoint(code);\n    }\n  }\n\n  return match;\n}\n\nfunction replaceEntities(str) {\n  if (str.indexOf('&') < 0) {\n    return str;\n  }\n\n  return str.replace(NAMED_ENTITY_RE, replaceEntityPattern);\n} ////////////////////////////////////////////////////////////////////////////////\n\n\nvar HTML_ESCAPE_TEST_RE = /[&<>\"]/;\nvar HTML_ESCAPE_REPLACE_RE = /[&<>\"]/g;\nvar HTML_REPLACEMENTS = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;'\n};\n\nfunction replaceUnsafeChar(ch) {\n  return HTML_REPLACEMENTS[ch];\n}\n\nfunction escapeHtml(str) {\n  if (HTML_ESCAPE_TEST_RE.test(str)) {\n    return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);\n  }\n\n  return str;\n} ////////////////////////////////////////////////////////////////////////////////\n\n\nexports.assign = assign;\nexports.isString = isString;\nexports.has = has;\nexports.unescapeMd = unescapeMd;\nexports.isValidEntityCode = isValidEntityCode;\nexports.fromCodePoint = fromCodePoint;\nexports.replaceEntities = replaceEntities;\nexports.escapeHtml = escapeHtml;","'use strict';\n/**\n * Local dependencies\n */\n\nvar Ruler = require('./ruler');\n/**\n * Core parser `rules`\n */\n\n\nvar _rules = [['block', require('./rules_core/block')], ['abbr', require('./rules_core/abbr')], ['references', require('./rules_core/references')], ['inline', require('./rules_core/inline')], ['footnote_tail', require('./rules_core/footnote_tail')], ['abbr2', require('./rules_core/abbr2')], ['replacements', require('./rules_core/replacements')], ['smartquotes', require('./rules_core/smartquotes')], ['linkify', require('./rules_core/linkify')]];\n/**\n * Class for top level (`core`) parser rules\n *\n * @api private\n */\n\nfunction Core() {\n  this.options = {};\n  this.ruler = new Ruler();\n\n  for (var i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1]);\n  }\n}\n/**\n * Process rules with the given `state`\n *\n * @param  {Object} `state`\n * @api private\n */\n\n\nCore.prototype.process = function (state) {\n  var i, l, rules;\n  rules = this.ruler.getRules('');\n\n  for (i = 0, l = rules.length; i < l; i++) {\n    rules[i](state);\n  }\n};\n/**\n * Expose `Core`\n */\n\n\nmodule.exports = Core;","// Lists\n'use strict'; // Search `[-+*][\\n ]`, returns next pos arter marker on success\n// or -1 on fail.\n\nfunction skipBulletListMarker(state, startLine) {\n  var marker, pos, max;\n  pos = state.bMarks[startLine] + state.tShift[startLine];\n  max = state.eMarks[startLine];\n\n  if (pos >= max) {\n    return -1;\n  }\n\n  marker = state.src.charCodeAt(pos++); // Check bullet\n\n  if (marker !== 0x2A\n  /* * */\n  && marker !== 0x2D\n  /* - */\n  && marker !== 0x2B\n  /* + */\n  ) {\n      return -1;\n    }\n\n  if (pos < max && state.src.charCodeAt(pos) !== 0x20) {\n    // \" 1.test \" - is not a list item\n    return -1;\n  }\n\n  return pos;\n} // Search `\\d+[.)][\\n ]`, returns next pos arter marker on success\n// or -1 on fail.\n\n\nfunction skipOrderedListMarker(state, startLine) {\n  var ch,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  if (pos + 1 >= max) {\n    return -1;\n  }\n\n  ch = state.src.charCodeAt(pos++);\n\n  if (ch < 0x30\n  /* 0 */\n  || ch > 0x39\n  /* 9 */\n  ) {\n      return -1;\n    }\n\n  for (;;) {\n    // EOL -> fail\n    if (pos >= max) {\n      return -1;\n    }\n\n    ch = state.src.charCodeAt(pos++);\n\n    if (ch >= 0x30\n    /* 0 */\n    && ch <= 0x39\n    /* 9 */\n    ) {\n        continue;\n      } // found valid marker\n\n\n    if (ch === 0x29\n    /* ) */\n    || ch === 0x2e\n    /* . */\n    ) {\n        break;\n      }\n\n    return -1;\n  }\n\n  if (pos < max && state.src.charCodeAt(pos) !== 0x20\n  /* space */\n  ) {\n      // \" 1.test \" - is not a list item\n      return -1;\n    }\n\n  return pos;\n}\n\nfunction markTightParagraphs(state, idx) {\n  var i,\n      l,\n      level = state.level + 2;\n\n  for (i = idx + 2, l = state.tokens.length - 2; i < l; i++) {\n    if (state.tokens[i].level === level && state.tokens[i].type === 'paragraph_open') {\n      state.tokens[i + 2].tight = true;\n      state.tokens[i].tight = true;\n      i += 2;\n    }\n  }\n}\n\nmodule.exports = function list(state, startLine, endLine, silent) {\n  var nextLine,\n      indent,\n      oldTShift,\n      oldIndent,\n      oldTight,\n      oldParentType,\n      start,\n      posAfterMarker,\n      max,\n      indentAfterMarker,\n      markerValue,\n      markerCharCode,\n      isOrdered,\n      contentStart,\n      listTokIdx,\n      prevEmptyEnd,\n      listLines,\n      itemLines,\n      tight = true,\n      terminatorRules,\n      i,\n      l,\n      terminate; // Detect list type and position after marker\n\n  if ((posAfterMarker = skipOrderedListMarker(state, startLine)) >= 0) {\n    isOrdered = true;\n  } else if ((posAfterMarker = skipBulletListMarker(state, startLine)) >= 0) {\n    isOrdered = false;\n  } else {\n    return false;\n  }\n\n  if (state.level >= state.options.maxNesting) {\n    return false;\n  } // We should terminate list on style change. Remember first one to compare.\n\n\n  markerCharCode = state.src.charCodeAt(posAfterMarker - 1); // For validation mode we can terminate immediately\n\n  if (silent) {\n    return true;\n  } // Start list\n\n\n  listTokIdx = state.tokens.length;\n\n  if (isOrdered) {\n    start = state.bMarks[startLine] + state.tShift[startLine];\n    markerValue = Number(state.src.substr(start, posAfterMarker - start - 1));\n    state.tokens.push({\n      type: 'ordered_list_open',\n      order: markerValue,\n      lines: listLines = [startLine, 0],\n      level: state.level++\n    });\n  } else {\n    state.tokens.push({\n      type: 'bullet_list_open',\n      lines: listLines = [startLine, 0],\n      level: state.level++\n    });\n  } //\n  // Iterate list items\n  //\n\n\n  nextLine = startLine;\n  prevEmptyEnd = false;\n  terminatorRules = state.parser.ruler.getRules('list');\n\n  while (nextLine < endLine) {\n    contentStart = state.skipSpaces(posAfterMarker);\n    max = state.eMarks[nextLine];\n\n    if (contentStart >= max) {\n      // trimming space in \"-    \\n  3\" case, indent is 1 here\n      indentAfterMarker = 1;\n    } else {\n      indentAfterMarker = contentStart - posAfterMarker;\n    } // If we have more than 4 spaces, the indent is 1\n    // (the rest is just indented code block)\n\n\n    if (indentAfterMarker > 4) {\n      indentAfterMarker = 1;\n    } // If indent is less than 1, assume that it's one, example:\n    //  \"-\\n  test\"\n\n\n    if (indentAfterMarker < 1) {\n      indentAfterMarker = 1;\n    } // \"  -  test\"\n    //  ^^^^^ - calculating total length of this thing\n\n\n    indent = posAfterMarker - state.bMarks[nextLine] + indentAfterMarker; // Run subparser & write tokens\n\n    state.tokens.push({\n      type: 'list_item_open',\n      lines: itemLines = [startLine, 0],\n      level: state.level++\n    });\n    oldIndent = state.blkIndent;\n    oldTight = state.tight;\n    oldTShift = state.tShift[startLine];\n    oldParentType = state.parentType;\n    state.tShift[startLine] = contentStart - state.bMarks[startLine];\n    state.blkIndent = indent;\n    state.tight = true;\n    state.parentType = 'list';\n    state.parser.tokenize(state, startLine, endLine, true); // If any of list item is tight, mark list as tight\n\n    if (!state.tight || prevEmptyEnd) {\n      tight = false;\n    } // Item become loose if finish with empty line,\n    // but we should filter last element, because it means list finish\n\n\n    prevEmptyEnd = state.line - startLine > 1 && state.isEmpty(state.line - 1);\n    state.blkIndent = oldIndent;\n    state.tShift[startLine] = oldTShift;\n    state.tight = oldTight;\n    state.parentType = oldParentType;\n    state.tokens.push({\n      type: 'list_item_close',\n      level: --state.level\n    });\n    nextLine = startLine = state.line;\n    itemLines[1] = nextLine;\n    contentStart = state.bMarks[startLine];\n\n    if (nextLine >= endLine) {\n      break;\n    }\n\n    if (state.isEmpty(nextLine)) {\n      break;\n    } //\n    // Try to check if list is terminated or continued.\n    //\n\n\n    if (state.tShift[nextLine] < state.blkIndent) {\n      break;\n    } // fail if terminating block found\n\n\n    terminate = false;\n\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n\n    if (terminate) {\n      break;\n    } // fail if list has another type\n\n\n    if (isOrdered) {\n      posAfterMarker = skipOrderedListMarker(state, nextLine);\n\n      if (posAfterMarker < 0) {\n        break;\n      }\n    } else {\n      posAfterMarker = skipBulletListMarker(state, nextLine);\n\n      if (posAfterMarker < 0) {\n        break;\n      }\n    }\n\n    if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) {\n      break;\n    }\n  } // Finilize list\n\n\n  state.tokens.push({\n    type: isOrdered ? 'ordered_list_close' : 'bullet_list_close',\n    level: --state.level\n  });\n  listLines[1] = nextLine;\n  state.line = nextLine; // mark paragraphs tight if needed\n\n  if (tight) {\n    markTightParagraphs(state, listTokIdx);\n  }\n\n  return true;\n};","'use strict';\n/**\n * Local dependencies\n */\n\nvar has = require('./common/utils').has;\n\nvar unescapeMd = require('./common/utils').unescapeMd;\n\nvar replaceEntities = require('./common/utils').replaceEntities;\n\nvar escapeHtml = require('./common/utils').escapeHtml;\n/**\n * Renderer rules cache\n */\n\n\nvar rules = {};\n/**\n * Blockquotes\n */\n\nrules.blockquote_open = function ()\n/* tokens, idx, options, env */\n{\n  return '<blockquote>\\n';\n};\n\nrules.blockquote_close = function (tokens, idx\n/*, options, env */\n) {\n  return '</blockquote>' + getBreak(tokens, idx);\n};\n/**\n * Code\n */\n\n\nrules.code = function (tokens, idx\n/*, options, env */\n) {\n  if (tokens[idx].block) {\n    return '<pre><code>' + escapeHtml(tokens[idx].content) + '</code></pre>' + getBreak(tokens, idx);\n  }\n\n  return '<code>' + escapeHtml(tokens[idx].content) + '</code>';\n};\n/**\n * Fenced code blocks\n */\n\n\nrules.fence = function (tokens, idx, options, env, instance) {\n  var token = tokens[idx];\n  var langClass = '';\n  var langPrefix = options.langPrefix;\n  var langName = '',\n      fences,\n      fenceName;\n  var highlighted;\n\n  if (token.params) {\n    //\n    // ```foo bar\n    //\n    // Try custom renderer \"foo\" first. That will simplify overwrite\n    // for diagrams, latex, and any other fenced block with custom look\n    //\n    fences = token.params.split(/\\s+/g);\n    fenceName = fences.join(' ');\n\n    if (has(instance.rules.fence_custom, fences[0])) {\n      return instance.rules.fence_custom[fences[0]](tokens, idx, options, env, instance);\n    }\n\n    langName = escapeHtml(replaceEntities(unescapeMd(fenceName)));\n    langClass = ' class=\"' + langPrefix + langName + '\"';\n  }\n\n  if (options.highlight) {\n    highlighted = options.highlight.apply(options.highlight, [token.content].concat(fences)) || escapeHtml(token.content);\n  } else {\n    highlighted = escapeHtml(token.content);\n  }\n\n  return '<pre><code' + langClass + '>' + highlighted + '</code></pre>' + getBreak(tokens, idx);\n};\n\nrules.fence_custom = {};\n/**\n * Headings\n */\n\nrules.heading_open = function (tokens, idx\n/*, options, env */\n) {\n  return '<h' + tokens[idx].hLevel + '>';\n};\n\nrules.heading_close = function (tokens, idx\n/*, options, env */\n) {\n  return '</h' + tokens[idx].hLevel + '>\\n';\n};\n/**\n * Horizontal rules\n */\n\n\nrules.hr = function (tokens, idx, options\n/*, env */\n) {\n  return (options.xhtmlOut ? '<hr />' : '<hr>') + getBreak(tokens, idx);\n};\n/**\n * Bullets\n */\n\n\nrules.bullet_list_open = function ()\n/* tokens, idx, options, env */\n{\n  return '<ul>\\n';\n};\n\nrules.bullet_list_close = function (tokens, idx\n/*, options, env */\n) {\n  return '</ul>' + getBreak(tokens, idx);\n};\n/**\n * List items\n */\n\n\nrules.list_item_open = function ()\n/* tokens, idx, options, env */\n{\n  return '<li>';\n};\n\nrules.list_item_close = function ()\n/* tokens, idx, options, env */\n{\n  return '</li>\\n';\n};\n/**\n * Ordered list items\n */\n\n\nrules.ordered_list_open = function (tokens, idx\n/*, options, env */\n) {\n  var token = tokens[idx];\n  var order = token.order > 1 ? ' start=\"' + token.order + '\"' : '';\n  return '<ol' + order + '>\\n';\n};\n\nrules.ordered_list_close = function (tokens, idx\n/*, options, env */\n) {\n  return '</ol>' + getBreak(tokens, idx);\n};\n/**\n * Paragraphs\n */\n\n\nrules.paragraph_open = function (tokens, idx\n/*, options, env */\n) {\n  return tokens[idx].tight ? '' : '<p>';\n};\n\nrules.paragraph_close = function (tokens, idx\n/*, options, env */\n) {\n  var addBreak = !(tokens[idx].tight && idx && tokens[idx - 1].type === 'inline' && !tokens[idx - 1].content);\n  return (tokens[idx].tight ? '' : '</p>') + (addBreak ? getBreak(tokens, idx) : '');\n};\n/**\n * Links\n */\n\n\nrules.link_open = function (tokens, idx, options\n/* env */\n) {\n  var title = tokens[idx].title ? ' title=\"' + escapeHtml(replaceEntities(tokens[idx].title)) + '\"' : '';\n  var target = options.linkTarget ? ' target=\"' + options.linkTarget + '\"' : '';\n  return '<a href=\"' + escapeHtml(tokens[idx].href) + '\"' + title + target + '>';\n};\n\nrules.link_close = function ()\n/* tokens, idx, options, env */\n{\n  return '</a>';\n};\n/**\n * Images\n */\n\n\nrules.image = function (tokens, idx, options\n/*, env */\n) {\n  var src = ' src=\"' + escapeHtml(tokens[idx].src) + '\"';\n  var title = tokens[idx].title ? ' title=\"' + escapeHtml(replaceEntities(tokens[idx].title)) + '\"' : '';\n  var alt = ' alt=\"' + (tokens[idx].alt ? escapeHtml(replaceEntities(unescapeMd(tokens[idx].alt))) : '') + '\"';\n  var suffix = options.xhtmlOut ? ' /' : '';\n  return '<img' + src + alt + title + suffix + '>';\n};\n/**\n * Tables\n */\n\n\nrules.table_open = function ()\n/* tokens, idx, options, env */\n{\n  return '<table>\\n';\n};\n\nrules.table_close = function ()\n/* tokens, idx, options, env */\n{\n  return '</table>\\n';\n};\n\nrules.thead_open = function ()\n/* tokens, idx, options, env */\n{\n  return '<thead>\\n';\n};\n\nrules.thead_close = function ()\n/* tokens, idx, options, env */\n{\n  return '</thead>\\n';\n};\n\nrules.tbody_open = function ()\n/* tokens, idx, options, env */\n{\n  return '<tbody>\\n';\n};\n\nrules.tbody_close = function ()\n/* tokens, idx, options, env */\n{\n  return '</tbody>\\n';\n};\n\nrules.tr_open = function ()\n/* tokens, idx, options, env */\n{\n  return '<tr>';\n};\n\nrules.tr_close = function ()\n/* tokens, idx, options, env */\n{\n  return '</tr>\\n';\n};\n\nrules.th_open = function (tokens, idx\n/*, options, env */\n) {\n  var token = tokens[idx];\n  return '<th' + (token.align ? ' style=\"text-align:' + token.align + '\"' : '') + '>';\n};\n\nrules.th_close = function ()\n/* tokens, idx, options, env */\n{\n  return '</th>';\n};\n\nrules.td_open = function (tokens, idx\n/*, options, env */\n) {\n  var token = tokens[idx];\n  return '<td' + (token.align ? ' style=\"text-align:' + token.align + '\"' : '') + '>';\n};\n\nrules.td_close = function ()\n/* tokens, idx, options, env */\n{\n  return '</td>';\n};\n/**\n * Bold\n */\n\n\nrules.strong_open = function ()\n/* tokens, idx, options, env */\n{\n  return '<strong>';\n};\n\nrules.strong_close = function ()\n/* tokens, idx, options, env */\n{\n  return '</strong>';\n};\n/**\n * Italicize\n */\n\n\nrules.em_open = function ()\n/* tokens, idx, options, env */\n{\n  return '<em>';\n};\n\nrules.em_close = function ()\n/* tokens, idx, options, env */\n{\n  return '</em>';\n};\n/**\n * Strikethrough\n */\n\n\nrules.del_open = function ()\n/* tokens, idx, options, env */\n{\n  return '<del>';\n};\n\nrules.del_close = function ()\n/* tokens, idx, options, env */\n{\n  return '</del>';\n};\n/**\n * Insert\n */\n\n\nrules.ins_open = function ()\n/* tokens, idx, options, env */\n{\n  return '<ins>';\n};\n\nrules.ins_close = function ()\n/* tokens, idx, options, env */\n{\n  return '</ins>';\n};\n/**\n * Highlight\n */\n\n\nrules.mark_open = function ()\n/* tokens, idx, options, env */\n{\n  return '<mark>';\n};\n\nrules.mark_close = function ()\n/* tokens, idx, options, env */\n{\n  return '</mark>';\n};\n/**\n * Super- and sub-script\n */\n\n\nrules.sub = function (tokens, idx\n/*, options, env */\n) {\n  return '<sub>' + escapeHtml(tokens[idx].content) + '</sub>';\n};\n\nrules.sup = function (tokens, idx\n/*, options, env */\n) {\n  return '<sup>' + escapeHtml(tokens[idx].content) + '</sup>';\n};\n/**\n * Breaks\n */\n\n\nrules.hardbreak = function (tokens, idx, options\n/*, env */\n) {\n  return options.xhtmlOut ? '<br />\\n' : '<br>\\n';\n};\n\nrules.softbreak = function (tokens, idx, options\n/*, env */\n) {\n  return options.breaks ? options.xhtmlOut ? '<br />\\n' : '<br>\\n' : '\\n';\n};\n/**\n * Text\n */\n\n\nrules.text = function (tokens, idx\n/*, options, env */\n) {\n  return escapeHtml(tokens[idx].content);\n};\n/**\n * Content\n */\n\n\nrules.htmlblock = function (tokens, idx\n/*, options, env */\n) {\n  return tokens[idx].content;\n};\n\nrules.htmltag = function (tokens, idx\n/*, options, env */\n) {\n  return tokens[idx].content;\n};\n/**\n * Abbreviations, initialism\n */\n\n\nrules.abbr_open = function (tokens, idx\n/*, options, env */\n) {\n  return '<abbr title=\"' + escapeHtml(replaceEntities(tokens[idx].title)) + '\">';\n};\n\nrules.abbr_close = function ()\n/* tokens, idx, options, env */\n{\n  return '</abbr>';\n};\n/**\n * Footnotes\n */\n\n\nrules.footnote_ref = function (tokens, idx) {\n  var n = Number(tokens[idx].id + 1).toString();\n  var id = 'fnref' + n;\n\n  if (tokens[idx].subId > 0) {\n    id += ':' + tokens[idx].subId;\n  }\n\n  return '<sup class=\"footnote-ref\"><a href=\"#fn' + n + '\" id=\"' + id + '\">[' + n + ']</a></sup>';\n};\n\nrules.footnote_block_open = function (tokens, idx, options) {\n  var hr = options.xhtmlOut ? '<hr class=\"footnotes-sep\" />\\n' : '<hr class=\"footnotes-sep\">\\n';\n  return hr + '<section class=\"footnotes\">\\n<ol class=\"footnotes-list\">\\n';\n};\n\nrules.footnote_block_close = function () {\n  return '</ol>\\n</section>\\n';\n};\n\nrules.footnote_open = function (tokens, idx) {\n  var id = Number(tokens[idx].id + 1).toString();\n  return '<li id=\"fn' + id + '\"  class=\"footnote-item\">';\n};\n\nrules.footnote_close = function () {\n  return '</li>\\n';\n};\n\nrules.footnote_anchor = function (tokens, idx) {\n  var n = Number(tokens[idx].id + 1).toString();\n  var id = 'fnref' + n;\n\n  if (tokens[idx].subId > 0) {\n    id += ':' + tokens[idx].subId;\n  }\n\n  return ' <a href=\"#' + id + '\" class=\"footnote-backref\">↩</a>';\n};\n/**\n * Definition lists\n */\n\n\nrules.dl_open = function () {\n  return '<dl>\\n';\n};\n\nrules.dt_open = function () {\n  return '<dt>';\n};\n\nrules.dd_open = function () {\n  return '<dd>';\n};\n\nrules.dl_close = function () {\n  return '</dl>\\n';\n};\n\nrules.dt_close = function () {\n  return '</dt>\\n';\n};\n\nrules.dd_close = function () {\n  return '</dd>\\n';\n};\n/**\n * Helper functions\n */\n\n\nfunction nextToken(tokens, idx) {\n  if (++idx >= tokens.length - 2) {\n    return idx;\n  }\n\n  if (tokens[idx].type === 'paragraph_open' && tokens[idx].tight && tokens[idx + 1].type === 'inline' && tokens[idx + 1].content.length === 0 && tokens[idx + 2].type === 'paragraph_close' && tokens[idx + 2].tight) {\n    return nextToken(tokens, idx + 2);\n  }\n\n  return idx;\n}\n/**\n * Check to see if `\\n` is needed before the next token.\n *\n * @param  {Array} `tokens`\n * @param  {Number} `idx`\n * @return {String} Empty string or newline\n * @api private\n */\n\n\nvar getBreak = rules.getBreak = function getBreak(tokens, idx) {\n  idx = nextToken(tokens, idx);\n\n  if (idx < tokens.length && tokens[idx].type === 'list_item_close') {\n    return '';\n  }\n\n  return '\\n';\n};\n/**\n * Expose `rules`\n */\n\n\nmodule.exports = rules;","// lheading (---, ===)\n'use strict';\n\nmodule.exports = function lheading(state, startLine, endLine\n/*, silent*/\n) {\n  var marker,\n      pos,\n      max,\n      next = startLine + 1;\n\n  if (next >= endLine) {\n    return false;\n  }\n\n  if (state.tShift[next] < state.blkIndent) {\n    return false;\n  } // Scan next line\n\n\n  if (state.tShift[next] - state.blkIndent > 3) {\n    return false;\n  }\n\n  pos = state.bMarks[next] + state.tShift[next];\n  max = state.eMarks[next];\n\n  if (pos >= max) {\n    return false;\n  }\n\n  marker = state.src.charCodeAt(pos);\n\n  if (marker !== 0x2D\n  /* - */\n  && marker !== 0x3D\n  /* = */\n  ) {\n      return false;\n    }\n\n  pos = state.skipChars(pos, marker);\n  pos = state.skipSpaces(pos);\n\n  if (pos < max) {\n    return false;\n  }\n\n  pos = state.bMarks[startLine] + state.tShift[startLine];\n  state.line = next + 1;\n  state.tokens.push({\n    type: 'heading_open',\n    hLevel: marker === 0x3D\n    /* = */\n    ? 1 : 2,\n    lines: [startLine, state.line],\n    level: state.level\n  });\n  state.tokens.push({\n    type: 'inline',\n    content: state.src.slice(pos, state.eMarks[startLine]).trim(),\n    level: state.level + 1,\n    lines: [startLine, state.line - 1],\n    children: []\n  });\n  state.tokens.push({\n    type: 'heading_close',\n    hLevel: marker === 0x3D\n    /* = */\n    ? 1 : 2,\n    level: state.level\n  });\n  return true;\n};","// Proceess escaped chars and hardbreaks\n'use strict';\n\nvar ESCAPED = [];\n\nfor (var i = 0; i < 256; i++) {\n  ESCAPED.push(0);\n}\n\n'\\\\!\"#$%&\\'()*+,./:;<=>?@[]^_`{|}~-'.split('').forEach(function (ch) {\n  ESCAPED[ch.charCodeAt(0)] = 1;\n});\n\nmodule.exports = function escape(state, silent) {\n  var ch,\n      pos = state.pos,\n      max = state.posMax;\n\n  if (state.src.charCodeAt(pos) !== 0x5C\n  /* \\ */\n  ) {\n      return false;\n    }\n\n  pos++;\n\n  if (pos < max) {\n    ch = state.src.charCodeAt(pos);\n\n    if (ch < 256 && ESCAPED[ch] !== 0) {\n      if (!silent) {\n        state.pending += state.src[pos];\n      }\n\n      state.pos += 2;\n      return true;\n    }\n\n    if (ch === 0x0A) {\n      if (!silent) {\n        state.push({\n          type: 'hardbreak',\n          level: state.level\n        });\n      }\n\n      pos++; // skip leading whitespaces from next line\n\n      while (pos < max && state.src.charCodeAt(pos) === 0x20) {\n        pos++;\n      }\n\n      state.pos = pos;\n      return true;\n    }\n  }\n\n  if (!silent) {\n    state.pending += '\\\\';\n  }\n\n  state.pos++;\n  return true;\n};","// Process ==highlighted text==\n'use strict';\n\nmodule.exports = function del(state, silent) {\n  var found,\n      pos,\n      stack,\n      max = state.posMax,\n      start = state.pos,\n      lastChar,\n      nextChar;\n\n  if (state.src.charCodeAt(start) !== 0x3D\n  /* = */\n  ) {\n      return false;\n    }\n\n  if (silent) {\n    return false;\n  } // don't run any pairs in validation mode\n\n\n  if (start + 4 >= max) {\n    return false;\n  }\n\n  if (state.src.charCodeAt(start + 1) !== 0x3D\n  /* = */\n  ) {\n      return false;\n    }\n\n  if (state.level >= state.options.maxNesting) {\n    return false;\n  }\n\n  lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1;\n  nextChar = state.src.charCodeAt(start + 2);\n\n  if (lastChar === 0x3D\n  /* = */\n  ) {\n      return false;\n    }\n\n  if (nextChar === 0x3D\n  /* = */\n  ) {\n      return false;\n    }\n\n  if (nextChar === 0x20 || nextChar === 0x0A) {\n    return false;\n  }\n\n  pos = start + 2;\n\n  while (pos < max && state.src.charCodeAt(pos) === 0x3D\n  /* = */\n  ) {\n    pos++;\n  }\n\n  if (pos !== start + 2) {\n    // sequence of 3+ markers taking as literal, same as in a emphasis\n    state.pos += pos - start;\n\n    if (!silent) {\n      state.pending += state.src.slice(start, pos);\n    }\n\n    return true;\n  }\n\n  state.pos = start + 2;\n  stack = 1;\n\n  while (state.pos + 1 < max) {\n    if (state.src.charCodeAt(state.pos) === 0x3D\n    /* = */\n    ) {\n        if (state.src.charCodeAt(state.pos + 1) === 0x3D\n        /* = */\n        ) {\n            lastChar = state.src.charCodeAt(state.pos - 1);\n            nextChar = state.pos + 2 < max ? state.src.charCodeAt(state.pos + 2) : -1;\n\n            if (nextChar !== 0x3D\n            /* = */\n            && lastChar !== 0x3D\n            /* = */\n            ) {\n                if (lastChar !== 0x20 && lastChar !== 0x0A) {\n                  // closing '=='\n                  stack--;\n                } else if (nextChar !== 0x20 && nextChar !== 0x0A) {\n                  // opening '=='\n                  stack++;\n                } // else {\n                //  // standalone ' == ' indented with spaces\n                // }\n\n\n                if (stack <= 0) {\n                  found = true;\n                  break;\n                }\n              }\n          }\n      }\n\n    state.parser.skipToken(state);\n  }\n\n  if (!found) {\n    // parser failed to find ending tag, so it's not valid emphasis\n    state.pos = start;\n    return false;\n  } // found!\n\n\n  state.posMax = state.pos;\n  state.pos = start + 2;\n\n  if (!silent) {\n    state.push({\n      type: 'mark_open',\n      level: state.level++\n    });\n    state.parser.tokenize(state);\n    state.push({\n      type: 'mark_close',\n      level: --state.level\n    });\n  }\n\n  state.pos = state.posMax + 2;\n  state.posMax = max;\n  return true;\n};","// Remarkable default options\n'use strict';\n\nmodule.exports = {\n  options: {\n    html: false,\n    // Enable HTML tags in source\n    xhtmlOut: false,\n    // Use '/' to close single tags (<br />)\n    breaks: false,\n    // Convert '\\n' in paragraphs into <br>\n    langPrefix: 'language-',\n    // CSS language prefix for fenced blocks\n    linkify: false,\n    // autoconvert URL-like texts to links\n    linkTarget: '',\n    // set target to open link in\n    // Enable some language-neutral replacements + quotes beautification\n    typographer: false,\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Set doubles to '«»' for Russian, '„“' for German.\n    quotes: '“”‘’',\n    // Highlighter function. Should return escaped HTML,\n    // or '' if input not changed\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n    maxNesting: 20 // Internal protection, recursion limit\n\n  },\n  components: {\n    core: {\n      rules: ['block', 'inline', 'references', 'replacements', 'linkify', 'smartquotes', 'references', 'abbr2', 'footnote_tail']\n    },\n    block: {\n      rules: ['blockquote', 'code', 'fences', 'footnote', 'heading', 'hr', 'htmlblock', 'lheading', 'list', 'paragraph', 'table']\n    },\n    inline: {\n      rules: ['autolink', 'backticks', 'del', 'emphasis', 'entity', 'escape', 'footnote_ref', 'htmltag', 'links', 'newline', 'text']\n    }\n  }\n};","'use strict';\n\nmodule.exports = function footnote_block(state) {\n  var i,\n      l,\n      j,\n      t,\n      lastParagraph,\n      list,\n      tokens,\n      current,\n      currentLabel,\n      level = 0,\n      insideRef = false,\n      refTokens = {};\n\n  if (!state.env.footnotes) {\n    return;\n  }\n\n  state.tokens = state.tokens.filter(function (tok) {\n    if (tok.type === 'footnote_reference_open') {\n      insideRef = true;\n      current = [];\n      currentLabel = tok.label;\n      return false;\n    }\n\n    if (tok.type === 'footnote_reference_close') {\n      insideRef = false; // prepend ':' to avoid conflict with Object.prototype members\n\n      refTokens[':' + currentLabel] = current;\n      return false;\n    }\n\n    if (insideRef) {\n      current.push(tok);\n    }\n\n    return !insideRef;\n  });\n\n  if (!state.env.footnotes.list) {\n    return;\n  }\n\n  list = state.env.footnotes.list;\n  state.tokens.push({\n    type: 'footnote_block_open',\n    level: level++\n  });\n\n  for (i = 0, l = list.length; i < l; i++) {\n    state.tokens.push({\n      type: 'footnote_open',\n      id: i,\n      level: level++\n    });\n\n    if (list[i].tokens) {\n      tokens = [];\n      tokens.push({\n        type: 'paragraph_open',\n        tight: false,\n        level: level++\n      });\n      tokens.push({\n        type: 'inline',\n        content: '',\n        level: level,\n        children: list[i].tokens\n      });\n      tokens.push({\n        type: 'paragraph_close',\n        tight: false,\n        level: --level\n      });\n    } else if (list[i].label) {\n      tokens = refTokens[':' + list[i].label];\n    }\n\n    state.tokens = state.tokens.concat(tokens);\n\n    if (state.tokens[state.tokens.length - 1].type === 'paragraph_close') {\n      lastParagraph = state.tokens.pop();\n    } else {\n      lastParagraph = null;\n    }\n\n    t = list[i].count > 0 ? list[i].count : 1;\n\n    for (j = 0; j < t; j++) {\n      state.tokens.push({\n        type: 'footnote_anchor',\n        id: i,\n        subId: j,\n        level: level\n      });\n    }\n\n    if (lastParagraph) {\n      state.tokens.push(lastParagraph);\n    }\n\n    state.tokens.push({\n      type: 'footnote_close',\n      level: --level\n    });\n  }\n\n  state.tokens.push({\n    type: 'footnote_block_close',\n    level: --level\n  });\n};","// Code block (4 spaces padded)\n'use strict';\n\nmodule.exports = function code(state, startLine, endLine\n/*, silent*/\n) {\n  var nextLine, last;\n\n  if (state.tShift[startLine] - state.blkIndent < 4) {\n    return false;\n  }\n\n  last = nextLine = startLine + 1;\n\n  while (nextLine < endLine) {\n    if (state.isEmpty(nextLine)) {\n      nextLine++;\n      continue;\n    }\n\n    if (state.tShift[nextLine] - state.blkIndent >= 4) {\n      nextLine++;\n      last = nextLine;\n      continue;\n    }\n\n    break;\n  }\n\n  state.line = nextLine;\n  state.tokens.push({\n    type: 'code',\n    content: state.getLines(startLine, last, 4 + state.blkIndent, true),\n    block: true,\n    lines: [startLine, state.line],\n    level: state.level\n  });\n  return true;\n};","'use strict';\n/**\n * Local dependencies\n */\n\nvar utils = require('./common/utils');\n\nvar rules = require('./rules');\n/**\n * Expose `Renderer`\n */\n\n\nmodule.exports = Renderer;\n/**\n * Renderer class. Renders HTML and exposes `rules` to allow\n * local modifications.\n */\n\nfunction Renderer() {\n  this.rules = utils.assign({}, rules); // exported helper, for custom rules only\n\n  this.getBreak = rules.getBreak;\n}\n/**\n * Render a string of inline HTML with the given `tokens` and\n * `options`.\n *\n * @param  {Array} `tokens`\n * @param  {Object} `options`\n * @param  {Object} `env`\n * @return {String}\n * @api public\n */\n\n\nRenderer.prototype.renderInline = function (tokens, options, env) {\n  var _rules = this.rules;\n  var len = tokens.length,\n      i = 0;\n  var result = '';\n\n  while (len--) {\n    result += _rules[tokens[i].type](tokens, i++, options, env, this);\n  }\n\n  return result;\n};\n/**\n * Render a string of HTML with the given `tokens` and\n * `options`.\n *\n * @param  {Array} `tokens`\n * @param  {Object} `options`\n * @param  {Object} `env`\n * @return {String}\n * @api public\n */\n\n\nRenderer.prototype.render = function (tokens, options, env) {\n  var _rules = this.rules;\n  var len = tokens.length,\n      i = -1;\n  var result = '';\n\n  while (++i < len) {\n    if (tokens[i].type === 'inline') {\n      result += this.renderInline(tokens[i].children, options, env);\n    } else {\n      result += _rules[tokens[i].type](tokens, i, options, env, this);\n    }\n  }\n\n  return result;\n};","// Parse abbreviation definitions, i.e. `*[abbr]: description`\n//\n'use strict';\n\nvar StateInline = require('../rules_inline/state_inline');\n\nvar parseLinkLabel = require('../helpers/parse_link_label');\n\nfunction parseAbbr(str, parserInline, options, env) {\n  var state, labelEnd, pos, max, label, title;\n\n  if (str.charCodeAt(0) !== 0x2A\n  /* * */\n  ) {\n      return -1;\n    }\n\n  if (str.charCodeAt(1) !== 0x5B\n  /* [ */\n  ) {\n      return -1;\n    }\n\n  if (str.indexOf(']:') === -1) {\n    return -1;\n  }\n\n  state = new StateInline(str, parserInline, options, env, []);\n  labelEnd = parseLinkLabel(state, 1);\n\n  if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A\n  /* : */\n  ) {\n      return -1;\n    }\n\n  max = state.posMax; // abbr title is always one line, so looking for ending \"\\n\" here\n\n  for (pos = labelEnd + 2; pos < max; pos++) {\n    if (state.src.charCodeAt(pos) === 0x0A) {\n      break;\n    }\n  }\n\n  label = str.slice(2, labelEnd);\n  title = str.slice(labelEnd + 2, pos).trim();\n\n  if (title.length === 0) {\n    return -1;\n  }\n\n  if (!env.abbreviations) {\n    env.abbreviations = {};\n  } // prepend ':' to avoid conflict with Object.prototype members\n\n\n  if (typeof env.abbreviations[':' + label] === 'undefined') {\n    env.abbreviations[':' + label] = title;\n  }\n\n  return pos;\n}\n\nmodule.exports = function abbr(state) {\n  var tokens = state.tokens,\n      i,\n      l,\n      content,\n      pos;\n\n  if (state.inlineMode) {\n    return;\n  } // Parse inlines\n\n\n  for (i = 1, l = tokens.length - 1; i < l; i++) {\n    if (tokens[i - 1].type === 'paragraph_open' && tokens[i].type === 'inline' && tokens[i + 1].type === 'paragraph_close') {\n      content = tokens[i].content;\n\n      while (content.length) {\n        pos = parseAbbr(content, state.inline, state.options, state.env);\n\n        if (pos < 0) {\n          break;\n        }\n\n        content = content.slice(pos).trim();\n      }\n\n      tokens[i].content = content;\n\n      if (!content.length) {\n        tokens[i - 1].tight = true;\n        tokens[i + 1].tight = true;\n      }\n    }\n  }\n};","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m;\n  var eLen = nBytes * 8 - mLen - 1;\n  var eMax = (1 << eLen) - 1;\n  var eBias = eMax >> 1;\n  var nBits = -7;\n  var i = isLE ? nBytes - 1 : 0;\n  var d = isLE ? -1 : 1;\n  var s = buffer[offset + i];\n  i += d;\n  e = s & (1 << -nBits) - 1;\n  s >>= -nBits;\n  nBits += eLen;\n\n  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & (1 << -nBits) - 1;\n  e >>= -nBits;\n  nBits += mLen;\n\n  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias;\n  } else if (e === eMax) {\n    return m ? NaN : (s ? -1 : 1) * Infinity;\n  } else {\n    m = m + Math.pow(2, mLen);\n    e = e - eBias;\n  }\n\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen);\n};\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c;\n  var eLen = nBytes * 8 - mLen - 1;\n  var eMax = (1 << eLen) - 1;\n  var eBias = eMax >> 1;\n  var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;\n  var i = isLE ? 0 : nBytes - 1;\n  var d = isLE ? 1 : -1;\n  var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;\n  value = Math.abs(value);\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0;\n    e = eMax;\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2);\n\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--;\n      c *= 2;\n    }\n\n    if (e + eBias >= 1) {\n      value += rt / c;\n    } else {\n      value += rt * Math.pow(2, 1 - eBias);\n    }\n\n    if (value * c >= 2) {\n      e++;\n      c /= 2;\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0;\n      e = eMax;\n    } else if (e + eBias >= 1) {\n      m = (value * c - 1) * Math.pow(2, mLen);\n      e = e + eBias;\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);\n      e = 0;\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = e << mLen | m;\n  eLen += mLen;\n\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128;\n};","'use strict';\n\nmodule.exports = function block(state) {\n  if (state.inlineMode) {\n    state.tokens.push({\n      type: 'inline',\n      content: state.src.replace(/\\n/g, ' ').trim(),\n      level: 0,\n      lines: [0, 1],\n      children: []\n    });\n  } else {\n    state.block.parse(state.src, state.options, state.env, state.tokens);\n  }\n};","module.exports = \"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9Ii0xMS41IC0xMC4yMzE3NCAyMyAyMC40NjM0OCI+CiAgPHRpdGxlPlJlYWN0IExvZ288L3RpdGxlPgogIDxjaXJjbGUgY3g9IjAiIGN5PSIwIiByPSIyLjA1IiBmaWxsPSIjZmZmIi8+CiAgPGcgc3Ryb2tlPSIjZmZmIiBzdHJva2Utd2lkdGg9IjEiIGZpbGw9Im5vbmUiPgogICAgPGVsbGlwc2Ugcng9IjExIiByeT0iNC4yIi8+CiAgICA8ZWxsaXBzZSByeD0iMTEiIHJ5PSI0LjIiIHRyYW5zZm9ybT0icm90YXRlKDYwKSIvPgogICAgPGVsbGlwc2Ugcng9IjExIiByeT0iNC4yIiB0cmFuc2Zvcm09InJvdGF0ZSgxMjApIi8+CiAgPC9nPgo8L3N2Zz4K\"","'use strict';\nvar $ = require('../internals/export');\nvar $trimEnd = require('../internals/string-trim').end;\nvar forcedStringTrimMethod = require('../internals/string-trim-forced');\n\nvar FORCED = forcedStringTrimMethod('trimEnd');\n\nvar trimEnd = FORCED ? function trimEnd() {\n  return $trimEnd(this);\n} : ''.trimEnd;\n\n// `String.prototype.{ trimEnd, trimRight }` methods\n// https://github.com/tc39/ecmascript-string-left-right-trim\n$({ target: 'String', proto: true, forced: FORCED }, {\n  trimEnd: trimEnd,\n  trimRight: trimEnd\n});\n","'use strict';\n\nvar replaceEntities = require('../common/utils').replaceEntities;\n\nmodule.exports = function normalizeLink(url) {\n  var normalized = replaceEntities(url); // We shouldn't care about the result of malformed URIs,\n  // and should not throw an exception.\n\n  try {\n    normalized = decodeURI(normalized);\n  } catch (err) {}\n\n  return encodeURI(normalized);\n};","// Skip text characters for text token, place those to pending buffer\n// and increment current pos\n'use strict'; // Rule to skip pure text\n// '{}$%@~+=:' reserved for extentions\n\nfunction isTerminatorChar(ch) {\n  switch (ch) {\n    case 0x0A\n    /* \\n */\n    :\n    case 0x5C\n    /* \\ */\n    :\n    case 0x60\n    /* ` */\n    :\n    case 0x2A\n    /* * */\n    :\n    case 0x5F\n    /* _ */\n    :\n    case 0x5E\n    /* ^ */\n    :\n    case 0x5B\n    /* [ */\n    :\n    case 0x5D\n    /* ] */\n    :\n    case 0x21\n    /* ! */\n    :\n    case 0x26\n    /* & */\n    :\n    case 0x3C\n    /* < */\n    :\n    case 0x3E\n    /* > */\n    :\n    case 0x7B\n    /* { */\n    :\n    case 0x7D\n    /* } */\n    :\n    case 0x24\n    /* $ */\n    :\n    case 0x25\n    /* % */\n    :\n    case 0x40\n    /* @ */\n    :\n    case 0x7E\n    /* ~ */\n    :\n    case 0x2B\n    /* + */\n    :\n    case 0x3D\n    /* = */\n    :\n    case 0x3A\n    /* : */\n    :\n      return true;\n\n    default:\n      return false;\n  }\n}\n\nmodule.exports = function text(state, silent) {\n  var pos = state.pos;\n\n  while (pos < state.posMax && !isTerminatorChar(state.src.charCodeAt(pos))) {\n    pos++;\n  }\n\n  if (pos === state.pos) {\n    return false;\n  }\n\n  if (!silent) {\n    state.pending += state.src.slice(state.pos, pos);\n  }\n\n  state.pos = pos;\n  return true;\n};","// Process ++inserted text++\n'use strict';\n\nmodule.exports = function ins(state, silent) {\n  var found,\n      pos,\n      stack,\n      max = state.posMax,\n      start = state.pos,\n      lastChar,\n      nextChar;\n\n  if (state.src.charCodeAt(start) !== 0x2B\n  /* + */\n  ) {\n      return false;\n    }\n\n  if (silent) {\n    return false;\n  } // don't run any pairs in validation mode\n\n\n  if (start + 4 >= max) {\n    return false;\n  }\n\n  if (state.src.charCodeAt(start + 1) !== 0x2B\n  /* + */\n  ) {\n      return false;\n    }\n\n  if (state.level >= state.options.maxNesting) {\n    return false;\n  }\n\n  lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1;\n  nextChar = state.src.charCodeAt(start + 2);\n\n  if (lastChar === 0x2B\n  /* + */\n  ) {\n      return false;\n    }\n\n  if (nextChar === 0x2B\n  /* + */\n  ) {\n      return false;\n    }\n\n  if (nextChar === 0x20 || nextChar === 0x0A) {\n    return false;\n  }\n\n  pos = start + 2;\n\n  while (pos < max && state.src.charCodeAt(pos) === 0x2B\n  /* + */\n  ) {\n    pos++;\n  }\n\n  if (pos !== start + 2) {\n    // sequence of 3+ markers taking as literal, same as in a emphasis\n    state.pos += pos - start;\n\n    if (!silent) {\n      state.pending += state.src.slice(start, pos);\n    }\n\n    return true;\n  }\n\n  state.pos = start + 2;\n  stack = 1;\n\n  while (state.pos + 1 < max) {\n    if (state.src.charCodeAt(state.pos) === 0x2B\n    /* + */\n    ) {\n        if (state.src.charCodeAt(state.pos + 1) === 0x2B\n        /* + */\n        ) {\n            lastChar = state.src.charCodeAt(state.pos - 1);\n            nextChar = state.pos + 2 < max ? state.src.charCodeAt(state.pos + 2) : -1;\n\n            if (nextChar !== 0x2B\n            /* + */\n            && lastChar !== 0x2B\n            /* + */\n            ) {\n                if (lastChar !== 0x20 && lastChar !== 0x0A) {\n                  // closing '++'\n                  stack--;\n                } else if (nextChar !== 0x20 && nextChar !== 0x0A) {\n                  // opening '++'\n                  stack++;\n                } // else {\n                //  // standalone ' ++ ' indented with spaces\n                // }\n\n\n                if (stack <= 0) {\n                  found = true;\n                  break;\n                }\n              }\n          }\n      }\n\n    state.parser.skipToken(state);\n  }\n\n  if (!found) {\n    // parser failed to find ending tag, so it's not valid emphasis\n    state.pos = start;\n    return false;\n  } // found!\n\n\n  state.posMax = state.pos;\n  state.pos = start + 2;\n\n  if (!silent) {\n    state.push({\n      type: 'ins_open',\n      level: state.level++\n    });\n    state.parser.tokenize(state);\n    state.push({\n      type: 'ins_close',\n      level: --state.level\n    });\n  }\n\n  state.pos = state.posMax + 2;\n  state.posMax = max;\n  return true;\n};","// Definition lists\n'use strict'; // Search `[:~][\\n ]`, returns next pos after marker on success\n// or -1 on fail.\n\nfunction skipMarker(state, line) {\n  var pos,\n      marker,\n      start = state.bMarks[line] + state.tShift[line],\n      max = state.eMarks[line];\n\n  if (start >= max) {\n    return -1;\n  } // Check bullet\n\n\n  marker = state.src.charCodeAt(start++);\n\n  if (marker !== 0x7E\n  /* ~ */\n  && marker !== 0x3A\n  /* : */\n  ) {\n      return -1;\n    }\n\n  pos = state.skipSpaces(start); // require space after \":\"\n\n  if (start === pos) {\n    return -1;\n  } // no empty definitions, e.g. \"  : \"\n\n\n  if (pos >= max) {\n    return -1;\n  }\n\n  return pos;\n}\n\nfunction markTightParagraphs(state, idx) {\n  var i,\n      l,\n      level = state.level + 2;\n\n  for (i = idx + 2, l = state.tokens.length - 2; i < l; i++) {\n    if (state.tokens[i].level === level && state.tokens[i].type === 'paragraph_open') {\n      state.tokens[i + 2].tight = true;\n      state.tokens[i].tight = true;\n      i += 2;\n    }\n  }\n}\n\nmodule.exports = function deflist(state, startLine, endLine, silent) {\n  var contentStart, ddLine, dtLine, itemLines, listLines, listTokIdx, nextLine, oldIndent, oldDDIndent, oldParentType, oldTShift, oldTight, prevEmptyEnd, tight;\n\n  if (silent) {\n    // quirk: validation mode validates a dd block only, not a whole deflist\n    if (state.ddIndent < 0) {\n      return false;\n    }\n\n    return skipMarker(state, startLine) >= 0;\n  }\n\n  nextLine = startLine + 1;\n\n  if (state.isEmpty(nextLine)) {\n    if (++nextLine > endLine) {\n      return false;\n    }\n  }\n\n  if (state.tShift[nextLine] < state.blkIndent) {\n    return false;\n  }\n\n  contentStart = skipMarker(state, nextLine);\n\n  if (contentStart < 0) {\n    return false;\n  }\n\n  if (state.level >= state.options.maxNesting) {\n    return false;\n  } // Start list\n\n\n  listTokIdx = state.tokens.length;\n  state.tokens.push({\n    type: 'dl_open',\n    lines: listLines = [startLine, 0],\n    level: state.level++\n  }); //\n  // Iterate list items\n  //\n\n  dtLine = startLine;\n  ddLine = nextLine; // One definition list can contain multiple DTs,\n  // and one DT can be followed by multiple DDs.\n  //\n  // Thus, there is two loops here, and label is\n  // needed to break out of the second one\n  //\n\n  /*eslint no-labels:0,block-scoped-var:0*/\n\n  OUTER: for (;;) {\n    tight = true;\n    prevEmptyEnd = false;\n    state.tokens.push({\n      type: 'dt_open',\n      lines: [dtLine, dtLine],\n      level: state.level++\n    });\n    state.tokens.push({\n      type: 'inline',\n      content: state.getLines(dtLine, dtLine + 1, state.blkIndent, false).trim(),\n      level: state.level + 1,\n      lines: [dtLine, dtLine],\n      children: []\n    });\n    state.tokens.push({\n      type: 'dt_close',\n      level: --state.level\n    });\n\n    for (;;) {\n      state.tokens.push({\n        type: 'dd_open',\n        lines: itemLines = [nextLine, 0],\n        level: state.level++\n      });\n      oldTight = state.tight;\n      oldDDIndent = state.ddIndent;\n      oldIndent = state.blkIndent;\n      oldTShift = state.tShift[ddLine];\n      oldParentType = state.parentType;\n      state.blkIndent = state.ddIndent = state.tShift[ddLine] + 2;\n      state.tShift[ddLine] = contentStart - state.bMarks[ddLine];\n      state.tight = true;\n      state.parentType = 'deflist';\n      state.parser.tokenize(state, ddLine, endLine, true); // If any of list item is tight, mark list as tight\n\n      if (!state.tight || prevEmptyEnd) {\n        tight = false;\n      } // Item become loose if finish with empty line,\n      // but we should filter last element, because it means list finish\n\n\n      prevEmptyEnd = state.line - ddLine > 1 && state.isEmpty(state.line - 1);\n      state.tShift[ddLine] = oldTShift;\n      state.tight = oldTight;\n      state.parentType = oldParentType;\n      state.blkIndent = oldIndent;\n      state.ddIndent = oldDDIndent;\n      state.tokens.push({\n        type: 'dd_close',\n        level: --state.level\n      });\n      itemLines[1] = nextLine = state.line;\n\n      if (nextLine >= endLine) {\n        break OUTER;\n      }\n\n      if (state.tShift[nextLine] < state.blkIndent) {\n        break OUTER;\n      }\n\n      contentStart = skipMarker(state, nextLine);\n\n      if (contentStart < 0) {\n        break;\n      }\n\n      ddLine = nextLine; // go to the next loop iteration:\n      // insert DD tag and repeat checking\n    }\n\n    if (nextLine >= endLine) {\n      break;\n    }\n\n    dtLine = nextLine;\n\n    if (state.isEmpty(dtLine)) {\n      break;\n    }\n\n    if (state.tShift[dtLine] < state.blkIndent) {\n      break;\n    }\n\n    ddLine = dtLine + 1;\n\n    if (ddLine >= endLine) {\n      break;\n    }\n\n    if (state.isEmpty(ddLine)) {\n      ddLine++;\n    }\n\n    if (ddLine >= endLine) {\n      break;\n    }\n\n    if (state.tShift[ddLine] < state.blkIndent) {\n      break;\n    }\n\n    contentStart = skipMarker(state, ddLine);\n\n    if (contentStart < 0) {\n      break;\n    } // go to the next loop iteration:\n    // insert DT and DD tags and repeat checking\n\n  } // Finilize list\n\n\n  state.tokens.push({\n    type: 'dl_close',\n    level: --state.level\n  });\n  listLines[1] = nextLine;\n  state.line = nextLine; // mark paragraphs tight if needed\n\n  if (tight) {\n    markTightParagraphs(state, listTokIdx);\n  }\n\n  return true;\n};","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails react-core\n */\n\nexport default url =>\n  new Promise((resolve, reject) =>\n    document.head.appendChild(\n      Object.assign(document.createElement('script'), {\n        async: true,\n        src: url,\n        onload: resolve,\n        onerror: reject,\n      }),\n    ),\n  );\n","// List of valid url schemas, accorting to commonmark spec\n// http://jgm.github.io/CommonMark/spec.html#autolinks\n'use strict';\n\nmodule.exports = ['coap', 'doi', 'javascript', 'aaa', 'aaas', 'about', 'acap', 'cap', 'cid', 'crid', 'data', 'dav', 'dict', 'dns', 'file', 'ftp', 'geo', 'go', 'gopher', 'h323', 'http', 'https', 'iax', 'icap', 'im', 'imap', 'info', 'ipp', 'iris', 'iris.beep', 'iris.xpc', 'iris.xpcs', 'iris.lwz', 'ldap', 'mailto', 'mid', 'msrp', 'msrps', 'mtqp', 'mupdate', 'news', 'nfs', 'ni', 'nih', 'nntp', 'opaquelocktoken', 'pop', 'pres', 'rtsp', 'service', 'session', 'shttp', 'sieve', 'sip', 'sips', 'sms', 'snmp', 'soap.beep', 'soap.beeps', 'tag', 'tel', 'telnet', 'tftp', 'thismessage', 'tn3270', 'tip', 'tv', 'urn', 'vemmi', 'ws', 'wss', 'xcon', 'xcon-userid', 'xmlrpc.beep', 'xmlrpc.beeps', 'xmpp', 'z39.50r', 'z39.50s', 'adiumxtra', 'afp', 'afs', 'aim', 'apt', 'attachment', 'aw', 'beshare', 'bitcoin', 'bolo', 'callto', 'chrome', 'chrome-extension', 'com-eventbrite-attendee', 'content', 'cvs', 'dlna-playsingle', 'dlna-playcontainer', 'dtn', 'dvb', 'ed2k', 'facetime', 'feed', 'finger', 'fish', 'gg', 'git', 'gizmoproject', 'gtalk', 'hcp', 'icon', 'ipn', 'irc', 'irc6', 'ircs', 'itms', 'jar', 'jms', 'keyparc', 'lastfm', 'ldaps', 'magnet', 'maps', 'market', 'message', 'mms', 'ms-help', 'msnim', 'mumble', 'mvn', 'notes', 'oid', 'palm', 'paparazzi', 'platform', 'proxy', 'psyc', 'query', 'res', 'resource', 'rmi', 'rsync', 'rtmp', 'secondlife', 'sftp', 'sgn', 'skype', 'smb', 'soldat', 'spotify', 'ssh', 'steam', 'svn', 'teamspeak', 'things', 'udp', 'unreal', 'ut2004', 'ventrilo', 'view-source', 'webcal', 'wtai', 'wyciwyg', 'xfire', 'xri', 'ymsgr'];","// Simple typographical replacements\n//\n'use strict'; // TODO:\n// - fractionals 1/2, 1/4, 3/4 -> ½, ¼, ¾\n// - miltiplication 2 x 4 -> 2 × 4\n\nvar RARE_RE = /\\+-|\\.\\.|\\?\\?\\?\\?|!!!!|,,|--/;\nvar SCOPED_ABBR_RE = /\\((c|tm|r|p)\\)/ig;\nvar SCOPED_ABBR = {\n  'c': '©',\n  'r': '®',\n  'p': '§',\n  'tm': '™'\n};\n\nfunction replaceScopedAbbr(str) {\n  if (str.indexOf('(') < 0) {\n    return str;\n  }\n\n  return str.replace(SCOPED_ABBR_RE, function (match, name) {\n    return SCOPED_ABBR[name.toLowerCase()];\n  });\n}\n\nmodule.exports = function replace(state) {\n  var i, token, text, inlineTokens, blkIdx;\n\n  if (!state.options.typographer) {\n    return;\n  }\n\n  for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {\n    if (state.tokens[blkIdx].type !== 'inline') {\n      continue;\n    }\n\n    inlineTokens = state.tokens[blkIdx].children;\n\n    for (i = inlineTokens.length - 1; i >= 0; i--) {\n      token = inlineTokens[i];\n\n      if (token.type === 'text') {\n        text = token.content;\n        text = replaceScopedAbbr(text);\n\n        if (RARE_RE.test(text)) {\n          text = text.replace(/\\+-/g, '±') // .., ..., ....... -> …\n          // but ?..... & !..... -> ?.. & !..\n          .replace(/\\.{2,}/g, '…').replace(/([?!])…/g, '$1..').replace(/([?!]){4,}/g, '$1$1$1').replace(/,{2,}/g, ',') // em-dash\n          .replace(/(^|[^-])---([^-]|$)/mg, \"$1\\u2014$2\") // en-dash\n          .replace(/(^|\\s)--(\\s|$)/mg, \"$1\\u2013$2\").replace(/(^|[^-\\s])--([^-\\s]|$)/mg, \"$1\\u2013$2\");\n        }\n\n        token.content = text;\n      }\n    }\n  }\n};"],"sourceRoot":""}