component---src-pages-index-js-11622ab2dfcb321e8c00.js.map

{"version":3,"sources":["webpack:///./node_modules/vfile/core.js","webpack:///./node_modules/unist-util-stringify-position/index.js","webpack:///./static/media/biopunkkitchen-noBg-centered.svg","webpack:///./node_modules/remark-parse/lib/defaults.js","webpack:///./node_modules/unified/index.js","webpack:///./node_modules/is-alphabetical/index.js","webpack:///./src/components/ColorBar.js","webpack:///./src/components/Hero.js","webpack:///./node_modules/remark-parse/lib/tokenize/auto-link.js","webpack:///./node_modules/path-browserify/index.js","webpack:///./node_modules/trim-trailing-lines/index.js","webpack:///./src/components/hero.module.css","webpack:///./node_modules/react-markdown/lib/renderers.js","webpack:///./node_modules/remark-parse/lib/tokenize/break.js","webpack:///./node_modules/state-toggle/index.js","webpack:///./node_modules/unherit/index.js","webpack:///./node_modules/extend/index.js","webpack:///./node_modules/vfile-location/index.js","webpack:///./node_modules/react-markdown/lib/wrap-table-rows.js","webpack:///./node_modules/remark-parse/lib/tokenizer.js","webpack:///./node_modules/is-buffer/index.js","webpack:///./node_modules/remark-parse/lib/locate/strong.js","webpack:///./node_modules/remark-parse/lib/locate/code-inline.js","webpack:///./src/components/sticky.module.css","webpack:///./node_modules/remark-parse/lib/locate/emphasis.js","webpack:///./node_modules/trough/wrap.js","webpack:///./node_modules/remark-parse/lib/unescape.js","webpack:///./node_modules/remark-parse/lib/tokenize/newline.js","webpack:///./node_modules/remark-parse/lib/locate/link.js","webpack:///./node_modules/vfile/index.js","webpack:///./node_modules/bail/index.js","webpack:///./node_modules/remark-parse/lib/tokenize/code-fenced.js","webpack:///./node_modules/remark-parse/lib/tokenize/definition.js","webpack:///./node_modules/is-whitespace-character/index.js","webpack:///./node_modules/x-is-string/index.js","webpack:///./node_modules/react-markdown/lib/get-definitions.js","webpack:///./node_modules/react-markdown/lib/react-markdown.js","webpack:///./node_modules/is-alphanumerical/index.js","webpack:///./node_modules/remark-parse/lib/tokenize/code-inline.js","webpack:///./node_modules/collapse-white-space/index.js","webpack:///./node_modules/remark-parse/lib/tokenize/code-indented.js","webpack:///./src/components/colorBar.module.css","webpack:///./node_modules/node-libs-browser/node_modules/process/browser.js","webpack:///./node_modules/remark-parse/lib/util/interrupt.js","webpack:///./node_modules/remark-parse/lib/tokenize/strong.js","webpack:///./node_modules/remark-parse/lib/tokenize/heading-atx.js","webpack:///./node_modules/markdown-escapes/index.js","webpack:///./node_modules/remark-parse/lib/locate/delete.js","webpack:///./node_modules/remark-parse/lib/locate/escape.js","webpack:///./node_modules/remark-parse/lib/tokenize/heading-setext.js","webpack:///./node_modules/is-plain-obj/index.js","webpack:///./node_modules/react-markdown/lib/uri-transformer.js","webpack:///./node_modules/remark-parse/lib/decode.js","webpack:///./node_modules/inherits/inherits_browser.js","webpack:///./node_modules/remark-parse/lib/tokenize/blockquote.js","webpack:///./node_modules/unist-util-is/index.js","webpack:///./node_modules/remark-parse/lib/tokenize/paragraph.js","webpack:///./src/components/social/Instagram.js","webpack:///./src/components/social/Facebook.js","webpack:///./src/components/social/Discourse.js","webpack:///./src/components/Sticky.js","webpack:///./src/components/Button.js","webpack:///./src/pages/index.js","webpack:///./node_modules/repeat-string/index.js","webpack:///./node_modules/trim/index.js","webpack:///./node_modules/remark-parse/lib/tokenize/text.js","webpack:///./node_modules/remark-parse/lib/util/html.js","webpack:///./node_modules/xtend/immutable.js","webpack:///./node_modules/remark-parse/lib/tokenize/url.js","webpack:///./node_modules/remark-parse/lib/tokenize/delete.js","webpack:///./node_modules/react-markdown/lib/ast-to-react.js","webpack:///./node_modules/mdast-add-list-metadata/node_modules/unist-util-visit-parents/index.js","webpack:///./node_modules/remark-parse/lib/tokenize/html-inline.js","webpack:///./node_modules/remark-parse/lib/locate/url.js","webpack:///./node_modules/parse-entities/decode-entity.browser.js","webpack:///./node_modules/remark-parse/lib/tokenize/html-block.js","webpack:///./node_modules/is-decimal/index.js","webpack:///./node_modules/parse-entities/index.js","webpack:///./node_modules/unist-util-visit/index.js","webpack:///./node_modules/remark-parse/lib/util/remove-indentation.js","webpack:///./node_modules/vfile-message/index.js","webpack:///./node_modules/remark-parse/lib/locate/break.js","webpack:///./node_modules/remark-parse/lib/locate/tag.js","webpack:///./node_modules/remark-parse/lib/tokenize/emphasis.js","webpack:///./node_modules/unist-util-remove-position/index.js","webpack:///./node_modules/react-markdown/lib/plugins/naive-html.js","webpack:///./node_modules/remark-parse/lib/tokenize/footnote-definition.js","webpack:///./node_modules/remark-parse/index.js","webpack:///./node_modules/remark-parse/lib/parser.js","webpack:///./node_modules/is-hexadecimal/index.js","webpack:///./node_modules/react-markdown/lib/symbols.js","webpack:///./node_modules/remark-parse/lib/tokenize/link.js","webpack:///./src/components/social/social.module.css","webpack:///./node_modules/remark-parse/lib/util/normalize.js","webpack:///./node_modules/vfile/node_modules/replace-ext/index.js","webpack:///./src/components/button.module.css","webpack:///./node_modules/remark-parse/lib/util/get-indentation.js","webpack:///./node_modules/remark-parse/lib/set-options.js","webpack:///./node_modules/is-word-character/index.js","webpack:///./static/media/Meetup_Large_white.svg","webpack:///./node_modules/remark-parse/lib/tokenize/thematic-break.js","webpack:///./node_modules/remark-parse/lib/tokenize/list.js","webpack:///./node_modules/remark-parse/lib/tokenize/escape.js","webpack:///./node_modules/react-markdown/lib/plugins/disallow-node.js","webpack:///./node_modules/remark-parse/lib/tokenize/table.js","webpack:///./node_modules/unist-util-visit-parents/index.js","webpack:///./src/pages/index.module.css","webpack:///./node_modules/remark-parse/lib/tokenize/reference.js","webpack:///./node_modules/mdast-add-list-metadata/index.js","webpack:///./node_modules/trough/index.js","webpack:///./node_modules/remark-parse/lib/parse.js"],"names":["path","replace","buffer","module","exports","VFile","own","hasOwnProperty","proto","prototype","toString","encoding","value","this","contents","String","order","options","prop","index","length","data","messages","history","cwd","process","call","indexOf","assertPart","part","name","sep","Error","assertNonEmpty","assertPath","Object","defineProperty","get","set","push","dirname","undefined","join","basename","extname","ext","charAt","stem","point","line","column","position","pos","start","end","gfm","commonmark","footnotes","pedantic","blocks","extend","bail","vfile","trough","string","plain","unified","attachers","transformers","namespace","frozen","freezeIndex","processor","key","arguments","assertUnfrozen","freeze","use","settings","addPlugin","apply","addList","addPreset","result","plugins","add","plugin","entry","find","slice","parse","doc","Parser","file","assertParser","newable","stringify","node","Compiler","assertCompiler","assertNode","compile","run","runSync","complete","err","tree","assertDone","processSync","destination","values","transformer","Infinity","cb","Promise","executor","resolve","reject","pipeline","p","ctx","next","keys","type","asyncName","character","code","charCodeAt","colors","blue","darkBlue","orange","pink","ColorBar","props","className","styles","colorBar","style","background","color","Hero","imageStyle","homeHeroImage","previewHeroImage","pageHeroImage","titleStyle","homeHeroTitle","previewHeroTitle","pageHeroTitle","hero","backgroundImage","image","title","whitespace","decode","locate","autoLink","locator","notInLink","MAILTO_LENGTH","eat","silent","subvalue","queue","hasAtCharacter","link","now","content","tokenizers","exit","offset","toLowerCase","substr","inlineTokenizers","text","enterLink","tokenizeInline","url","nonTerminated","children","normalizeArray","parts","allowAboveRoot","up","i","last","splice","unshift","filter","xs","f","res","resolvedPath","resolvedAbsolute","TypeError","split","normalize","isAbsolute","trailingSlash","paths","Array","relative","from","to","trim","arr","fromParts","toParts","Math","min","samePartsLength","outputParts","concat","delimiter","hasRoot","matchedSlash","startDot","startPart","preDotState","str","len","val","xtend","React","supportsStringRender","parseInt","version","createElement","SimpleRenderer","tag","getCoreProps","break","paragraph","emphasis","strong","thematicBreak","blockquote","delete","linkReference","imageReference","table","bind","tableHead","tableBody","tableRow","tableCell","align","textAlign","coreProps","isHeader","root","useFragment","Fragment","list","attrs","ordered","listItem","checkbox","checked","readOnly","definition","heading","level","inlineCode","language","html","skipHtml","isBlock","escapeHtml","comp","nodeProps","dangerouslySetInnerHTML","__html","virtualHtml","parsedHtml","cloneElement","element","hardBreak","state","context","current","inherits","Super","Of","From","parameters","hasOwn","toStr","gOPD","getOwnPropertyDescriptor","isArray","isPlainObject","obj","hasOwnConstructor","hasIsPrototypeOf","constructor","setProperty","target","enumerable","configurable","newValue","writable","getProperty","src","copy","copyIsArray","clone","deep","offsetToPositionFactory","indices","positionToOffsetFactory","isNaN","toPosition","toOffset","visit","wrap","location","method","matched","valueLength","self","tokens","methods","updatePosition","onlyAtStart","atStart","notInList","inList","notInBlock","inBlock","inLink","fail","eof","lastIndex","Position","before","indent","indentation","getOffset","prev","combined","n","l","substring","validateEat","reset","test","parent","MERGEABLE_NODES","mergeable","exitStart","isBuffer","readFloatLE","isSlowBuffer","_isBuffer","fromIndex","asterisk","underscore","fn","callback","invoked","params","done","then","escape","VMessage","message","reason","origin","filePath","fatal","info","warn","fenceCount","marker","flag","exdentedContent","closing","exdentedClosing","raw","unescape","lang","beforeURL","beforeTitle","identifier","isEnclosedURLCharacter","isUnclosedURLCharacter","re","fromCode","fromCharCode","getDefinitions","defs","reduce","definitions","child","href","_toConsumableArray","arr2","_arrayWithoutHoles","iter","Symbol","iterator","_iterableToArray","_nonIterableSpread","PropTypes","addListMetadata","naiveHtml","disallowNode","astToReact","wrapTableRows","uriTransformer","defaultRenderers","symbols","allTypes","ReactMarkdown","source","allowedTypes","disallowedTypes","renderers","rawAst","applyParserPlugin","renderProps","ast","removalMethod","unwrapDisallowed","ofType","allowNode","ifNotMatch","renderHtml","hasHtmlParser","astPlugins","some","item","identity","HtmlParser","determineAstPlugins","parser","defaultProps","sourcePos","rawSourcePos","transformLinkUri","propTypes","bool","func","arrayOf","oneOf","oneOfType","linkTarget","transformImageUri","object","array","types","alphabetical","decimal","contentQueue","subqueue","count","openingCount","found","tickQueue","repeat","blankQueue","subvalueQueue","CODE_INDENT","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","setTimeout","e","clearTimeout","currentQueue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","runClearTimeout","Item","noop","nextTick","args","browser","env","argv","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","chdir","dir","umask","interruptors","interruptor","config","ignore","bools","depth","escapes","defaults","default","SETEXT_MARKERS","x","getPrototypeOf","protocols","uri","first","colon","protocol","entities","decoder","warning","handleWarning","offsets","handler","reference","textContext","referenceContext","create","ctor","superCtor","super_","TempCtor","interrupt","rest","nextIndex","startIndex","prefixed","blockTokenizers","interruptBlockquote","currentLine","indents","enterBlock","tokenizeBlock","convert","Boolean","typeFactory","ok","anyFactory","matchesFactory","tests","checks","results","convertAll","is","hasParent","hasIndex","check","trimTrailingLines","size","interruptParagraph","left","Instagram","xmlns","viewBox","instagram","id","x2","y1","x1","y2","stopColor","transform","d","fill","Facebook","facebook","stroke","stroke-width","fill-rule","Discourse","discourse","Sticky","sticky","MeetupLarge","Button","button","label","Link","Section","section","markdownRemark","frontmatter","tagline","sections","Layout","topSection","Logo","social","map","cache","num","max","right","tokenizer","inlineMethods","openTag","closeTag","openCloseTag","RegExp","PROTOCOLS","PROTOCOLS_LENGTH","match","parenCount","nextCharacter","strikethrough","previous","preceding","renderer","isReactFragment","getNodeProps","resolveChildren","childNode","opts","isTagRenderer","sourcePosition","includeNodeIndex","parentChildCount","ref","assignDefined","nodeKey","tight","loose","unwrapParagraphs","getListItemChildren","inline","alt","columnAlignment","parsedChildren","el","mergeNodeChildren","visitor","stack","one","pop","all","inlineHTML","EXPRESSION_HTML_LINK_OPEN","EXPRESSION_HTML_LINK_CLOSE","characters","char","entity","document","innerHTML","textContent","sequence","sequences","legacy","invalid","hexadecimal","alphanumerical","decodeEntity","option","entityCharacters","namedEntity","terminated","following","output","begin","diff","additional","handleText","handleReference","warningContext","lines","MESSAGES","at","flush","TESTS","attribute","BASE","disallowed","Function","visitParents","CONTINUE","SKIP","EXIT","reverse","parents","getIndent","maximum","stops","padding","minIndent","matrix","shift","VMessagePrototype","range","parseOrigin","ruleId","word","hard","soft","force","selfClosingRe","simpleTagRe","open","currentParent","selfClosing","getSelfClosing","opening","getSimpleTag","matching","matchingTag","findAndPull","fromNode","toNode","toIndex","virtual","footnoteDefinition","EXPRESSION_INITIAL_TAB","C_BRACKET_OPEN","unherit","Local","toggle","vfileLocation","setOptions","enterList","interruptList","newline","indentedCode","fencedCode","atxHeading","setextHeading","footnote","deletion","blockMethods","tokenizeFactory","LINK_MARKERS","COMMONMARK_LINK_MARKERS","closed","hasMarker","markers","isImage","collapseWhiteSpace","npath","nFileName","floor","markerCount","removeIndent","currentMarker","prevEmpty","empty","items","allLines","emptyLines","enterTop","exitBlockquote","isLoose","indented","interuptors","LIST_ORDERED_COMMONMARK_MARKERS","LIST_ORDERED_MARKERS","LIST_UNORDERED_MARKERS","TAB_SIZE","trail","EXPRESSION_LOOSE_LIST_ITEM","EXPRESSION_TASK_ITEM","EXPRESSION_BULLET","EXPRESSION_PEDANTIC_BULLET","EXPRESSION_INITIAL_INDENT","task","pedanticListItem","normalListItem","replacer","$0","bullet","trimmedLines","$1","$2","$3","$4","Number","untangle","mode","forEach","disallow","alignments","alignment","row","hasDash","cell","preamble","lineCount","rows","lineIndex","pipeIndex","step","bracketed","intro","referenceType","visitWithParents","listNode","fns","middleware","input","removePosition","EXPRESSION_LINE_BREAKS"],"mappings":"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","file":"component---src-pages-index-js-11622ab2dfcb321e8c00.js","sourcesContent":["'use strict';\n\nvar path = require('path');\n\nvar replace = require('replace-ext');\n\nvar buffer = require('is-buffer');\n\nmodule.exports = VFile;\nvar own = {}.hasOwnProperty;\nvar proto = VFile.prototype;\nproto.toString = toString;\n/* Order of setting (least specific to most), we need this because\n * otherwise `{stem: 'a', path: '~/b.js'}` would throw, as a path\n * is needed before a stem can be set. */\n\nvar order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname'];\n/* Construct a new file. */\n\nfunction VFile(options) {\n  var prop;\n  var index;\n  var length;\n\n  if (!options) {\n    options = {};\n  } else if (typeof options === 'string' || buffer(options)) {\n    options = {\n      contents: options\n    };\n  } else if ('message' in options && 'messages' in options) {\n    return options;\n  }\n\n  if (!(this instanceof VFile)) {\n    return new VFile(options);\n  }\n\n  this.data = {};\n  this.messages = [];\n  this.history = [];\n  this.cwd = process.cwd();\n  /* Set path related properties in the correct order. */\n\n  index = -1;\n  length = order.length;\n\n  while (++index < length) {\n    prop = order[index];\n\n    if (own.call(options, prop)) {\n      this[prop] = options[prop];\n    }\n  }\n  /* Set non-path related properties. */\n\n\n  for (prop in options) {\n    if (order.indexOf(prop) === -1) {\n      this[prop] = options[prop];\n    }\n  }\n}\n/* Access full path (`~/index.min.js`). */\n\n\nObject.defineProperty(proto, 'path', {\n  get: function get() {\n    return this.history[this.history.length - 1];\n  },\n  set: function set(path) {\n    assertNonEmpty(path, 'path');\n\n    if (path !== this.path) {\n      this.history.push(path);\n    }\n  }\n});\n/* Access parent path (`~`). */\n\nObject.defineProperty(proto, 'dirname', {\n  get: function get() {\n    return typeof this.path === 'string' ? path.dirname(this.path) : undefined;\n  },\n  set: function set(dirname) {\n    assertPath(this.path, 'dirname');\n    this.path = path.join(dirname || '', this.basename);\n  }\n});\n/* Access basename (`index.min.js`). */\n\nObject.defineProperty(proto, 'basename', {\n  get: function get() {\n    return typeof this.path === 'string' ? path.basename(this.path) : undefined;\n  },\n  set: function set(basename) {\n    assertNonEmpty(basename, 'basename');\n    assertPart(basename, 'basename');\n    this.path = path.join(this.dirname || '', basename);\n  }\n});\n/* Access extname (`.js`). */\n\nObject.defineProperty(proto, 'extname', {\n  get: function get() {\n    return typeof this.path === 'string' ? path.extname(this.path) : undefined;\n  },\n  set: function set(extname) {\n    var ext = extname || '';\n    assertPart(ext, 'extname');\n    assertPath(this.path, 'extname');\n\n    if (ext) {\n      if (ext.charAt(0) !== '.') {\n        throw new Error('`extname` must start with `.`');\n      }\n\n      if (ext.indexOf('.', 1) !== -1) {\n        throw new Error('`extname` cannot contain multiple dots');\n      }\n    }\n\n    this.path = replace(this.path, ext);\n  }\n});\n/* Access stem (`index.min`). */\n\nObject.defineProperty(proto, 'stem', {\n  get: function get() {\n    return typeof this.path === 'string' ? path.basename(this.path, this.extname) : undefined;\n  },\n  set: function set(stem) {\n    assertNonEmpty(stem, 'stem');\n    assertPart(stem, 'stem');\n    this.path = path.join(this.dirname || '', stem + (this.extname || ''));\n  }\n});\n/* Get the value of the file. */\n\nfunction toString(encoding) {\n  var value = this.contents || '';\n  return buffer(value) ? value.toString(encoding) : String(value);\n}\n/* Assert that `part` is not a path (i.e., does\n * not contain `path.sep`). */\n\n\nfunction assertPart(part, name) {\n  if (part.indexOf(path.sep) !== -1) {\n    throw new Error('`' + name + '` cannot be a path: did not expect `' + path.sep + '`');\n  }\n}\n/* Assert that `part` is not empty. */\n\n\nfunction assertNonEmpty(part, name) {\n  if (!part) {\n    throw new Error('`' + name + '` cannot be empty');\n  }\n}\n/* Assert `path` exists. */\n\n\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too');\n  }\n}","'use strict';\n\nvar own = {}.hasOwnProperty;\nmodule.exports = stringify;\n\nfunction stringify(value) {\n  /* Nothing. */\n  if (!value || typeof value !== 'object') {\n    return null;\n  }\n  /* Node. */\n\n\n  if (own.call(value, 'position') || own.call(value, 'type')) {\n    return position(value.position);\n  }\n  /* Position. */\n\n\n  if (own.call(value, 'start') || own.call(value, 'end')) {\n    return position(value);\n  }\n  /* Point. */\n\n\n  if (own.call(value, 'line') || own.call(value, 'column')) {\n    return point(value);\n  }\n  /* ? */\n\n\n  return null;\n}\n\nfunction point(point) {\n  if (!point || typeof point !== 'object') {\n    point = {};\n  }\n\n  return index(point.line) + ':' + index(point.column);\n}\n\nfunction position(pos) {\n  if (!pos || typeof pos !== 'object') {\n    pos = {};\n  }\n\n  return point(pos.start) + '-' + point(pos.end);\n}\n\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1;\n}","module.exports = __webpack_public_path__ + \"static/biopunkkitchen-noBg-centered-80a04083b56a95089d1241beb16d5b63.svg\";","'use strict';\n\nmodule.exports = {\n  position: true,\n  gfm: true,\n  commonmark: false,\n  footnotes: false,\n  pedantic: false,\n  blocks: require('./block-elements.json')\n};","'use strict';\n/* Dependencies. */\n\nvar extend = require('extend');\n\nvar bail = require('bail');\n\nvar vfile = require('vfile');\n\nvar trough = require('trough');\n\nvar string = require('x-is-string');\n\nvar plain = require('is-plain-obj');\n/* Expose a frozen processor. */\n\n\nmodule.exports = unified().freeze();\nvar slice = [].slice;\nvar own = {}.hasOwnProperty;\n/* Process pipeline. */\n\nvar pipeline = trough().use(pipelineParse).use(pipelineRun).use(pipelineStringify);\n\nfunction pipelineParse(p, ctx) {\n  ctx.tree = p.parse(ctx.file);\n}\n\nfunction pipelineRun(p, ctx, next) {\n  p.run(ctx.tree, ctx.file, done);\n\n  function done(err, tree, file) {\n    if (err) {\n      next(err);\n    } else {\n      ctx.tree = tree;\n      ctx.file = file;\n      next();\n    }\n  }\n}\n\nfunction pipelineStringify(p, ctx) {\n  ctx.file.contents = p.stringify(ctx.tree, ctx.file);\n}\n/* Function to create the first processor. */\n\n\nfunction unified() {\n  var attachers = [];\n  var transformers = trough();\n  var namespace = {};\n  var frozen = false;\n  var freezeIndex = -1;\n  /* Data management. */\n\n  processor.data = data;\n  /* Lock. */\n\n  processor.freeze = freeze;\n  /* Plug-ins. */\n\n  processor.attachers = attachers;\n  processor.use = use;\n  /* API. */\n\n  processor.parse = parse;\n  processor.stringify = stringify;\n  processor.run = run;\n  processor.runSync = runSync;\n  processor.process = process;\n  processor.processSync = processSync;\n  /* Expose. */\n\n  return processor;\n  /* Create a new processor based on the processor\n   * in the current scope. */\n\n  function processor() {\n    var destination = unified();\n    var length = attachers.length;\n    var index = -1;\n\n    while (++index < length) {\n      destination.use.apply(null, attachers[index]);\n    }\n\n    destination.data(extend(true, {}, namespace));\n    return destination;\n  }\n  /* Freeze: used to signal a processor that has finished\n   * configuration.\n   *\n   * For example, take unified itself.  It’s frozen.\n   * Plug-ins should not be added to it.  Rather, it should\n   * be extended, by invoking it, before modifying it.\n   *\n   * In essence, always invoke this when exporting a\n   * processor. */\n\n\n  function freeze() {\n    var values;\n    var plugin;\n    var options;\n    var transformer;\n\n    if (frozen) {\n      return processor;\n    }\n\n    while (++freezeIndex < attachers.length) {\n      values = attachers[freezeIndex];\n      plugin = values[0];\n      options = values[1];\n      transformer = null;\n\n      if (options === false) {\n        continue;\n      }\n\n      if (options === true) {\n        values[1] = undefined;\n      }\n\n      transformer = plugin.apply(processor, values.slice(1));\n\n      if (typeof transformer === 'function') {\n        transformers.use(transformer);\n      }\n    }\n\n    frozen = true;\n    freezeIndex = Infinity;\n    return processor;\n  }\n  /* Data management.\n   * Getter / setter for processor-specific informtion. */\n\n\n  function data(key, value) {\n    if (string(key)) {\n      /* Set `key`. */\n      if (arguments.length === 2) {\n        assertUnfrozen('data', frozen);\n        namespace[key] = value;\n        return processor;\n      }\n      /* Get `key`. */\n\n\n      return own.call(namespace, key) && namespace[key] || null;\n    }\n    /* Set space. */\n\n\n    if (key) {\n      assertUnfrozen('data', frozen);\n      namespace = key;\n      return processor;\n    }\n    /* Get space. */\n\n\n    return namespace;\n  }\n  /* Plug-in management.\n   *\n   * Pass it:\n   * *   an attacher and options,\n   * *   a preset,\n   * *   a list of presets, attachers, and arguments (list\n   *     of attachers and options). */\n\n\n  function use(value) {\n    var settings;\n    assertUnfrozen('use', frozen);\n\n    if (value === null || value === undefined) {\n      /* Empty */\n    } else if (typeof value === 'function') {\n      addPlugin.apply(null, arguments);\n    } else if (typeof value === 'object') {\n      if ('length' in value) {\n        addList(value);\n      } else {\n        addPreset(value);\n      }\n    } else {\n      throw new Error('Expected usable value, not `' + value + '`');\n    }\n\n    if (settings) {\n      namespace.settings = extend(namespace.settings || {}, settings);\n    }\n\n    return processor;\n\n    function addPreset(result) {\n      addList(result.plugins);\n\n      if (result.settings) {\n        settings = extend(settings || {}, result.settings);\n      }\n    }\n\n    function add(value) {\n      if (typeof value === 'function') {\n        addPlugin(value);\n      } else if (typeof value === 'object') {\n        if ('length' in value) {\n          addPlugin.apply(null, value);\n        } else {\n          addPreset(value);\n        }\n      } else {\n        throw new Error('Expected usable value, not `' + value + '`');\n      }\n    }\n\n    function addList(plugins) {\n      var length;\n      var index;\n\n      if (plugins === null || plugins === undefined) {\n        /* Empty */\n      } else if (typeof plugins === 'object' && 'length' in plugins) {\n        length = plugins.length;\n        index = -1;\n\n        while (++index < length) {\n          add(plugins[index]);\n        }\n      } else {\n        throw new Error('Expected a list of plugins, not `' + plugins + '`');\n      }\n    }\n\n    function addPlugin(plugin, value) {\n      var entry = find(plugin);\n\n      if (entry) {\n        if (plain(entry[1]) && plain(value)) {\n          value = extend(entry[1], value);\n        }\n\n        entry[1] = value;\n      } else {\n        attachers.push(slice.call(arguments));\n      }\n    }\n  }\n\n  function find(plugin) {\n    var length = attachers.length;\n    var index = -1;\n    var entry;\n\n    while (++index < length) {\n      entry = attachers[index];\n\n      if (entry[0] === plugin) {\n        return entry;\n      }\n    }\n  }\n  /* Parse a file (in string or VFile representation)\n   * into a Unist node using the `Parser` on the\n   * processor. */\n\n\n  function parse(doc) {\n    var file = vfile(doc);\n    var Parser;\n    freeze();\n    Parser = processor.Parser;\n    assertParser('parse', Parser);\n\n    if (newable(Parser)) {\n      return new Parser(String(file), file).parse();\n    }\n\n    return Parser(String(file), file); // eslint-disable-line new-cap\n  }\n  /* Run transforms on a Unist node representation of a file\n   * (in string or VFile representation), async. */\n\n\n  function run(node, file, cb) {\n    assertNode(node);\n    freeze();\n\n    if (!cb && typeof file === 'function') {\n      cb = file;\n      file = null;\n    }\n\n    if (!cb) {\n      return new Promise(executor);\n    }\n\n    executor(null, cb);\n\n    function executor(resolve, reject) {\n      transformers.run(node, vfile(file), done);\n\n      function done(err, tree, file) {\n        tree = tree || node;\n\n        if (err) {\n          reject(err);\n        } else if (resolve) {\n          resolve(tree);\n        } else {\n          cb(null, tree, file);\n        }\n      }\n    }\n  }\n  /* Run transforms on a Unist node representation of a file\n   * (in string or VFile representation), sync. */\n\n\n  function runSync(node, file) {\n    var complete = false;\n    var result;\n    run(node, file, done);\n    assertDone('runSync', 'run', complete);\n    return result;\n\n    function done(err, tree) {\n      complete = true;\n      bail(err);\n      result = tree;\n    }\n  }\n  /* Stringify a Unist node representation of a file\n   * (in string or VFile representation) into a string\n   * using the `Compiler` on the processor. */\n\n\n  function stringify(node, doc) {\n    var file = vfile(doc);\n    var Compiler;\n    freeze();\n    Compiler = processor.Compiler;\n    assertCompiler('stringify', Compiler);\n    assertNode(node);\n\n    if (newable(Compiler)) {\n      return new Compiler(node, file).compile();\n    }\n\n    return Compiler(node, file); // eslint-disable-line new-cap\n  }\n  /* Parse a file (in string or VFile representation)\n   * into a Unist node using the `Parser` on the processor,\n   * then run transforms on that node, and compile the\n   * resulting node using the `Compiler` on the processor,\n   * and store that result on the VFile. */\n\n\n  function process(doc, cb) {\n    freeze();\n    assertParser('process', processor.Parser);\n    assertCompiler('process', processor.Compiler);\n\n    if (!cb) {\n      return new Promise(executor);\n    }\n\n    executor(null, cb);\n\n    function executor(resolve, reject) {\n      var file = vfile(doc);\n      pipeline.run(processor, {\n        file: file\n      }, done);\n\n      function done(err) {\n        if (err) {\n          reject(err);\n        } else if (resolve) {\n          resolve(file);\n        } else {\n          cb(null, file);\n        }\n      }\n    }\n  }\n  /* Process the given document (in string or VFile\n   * representation), sync. */\n\n\n  function processSync(doc) {\n    var complete = false;\n    var file;\n    freeze();\n    assertParser('processSync', processor.Parser);\n    assertCompiler('processSync', processor.Compiler);\n    file = vfile(doc);\n    process(file, done);\n    assertDone('processSync', 'process', complete);\n    return file;\n\n    function done(err) {\n      complete = true;\n      bail(err);\n    }\n  }\n}\n/* Check if `func` is a constructor. */\n\n\nfunction newable(value) {\n  return typeof value === 'function' && keys(value.prototype);\n}\n/* Check if `value` is an object with keys. */\n\n\nfunction keys(value) {\n  var key;\n\n  for (key in value) {\n    return true;\n  }\n\n  return false;\n}\n/* Assert a parser is available. */\n\n\nfunction assertParser(name, Parser) {\n  if (typeof Parser !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Parser`');\n  }\n}\n/* Assert a compiler is available. */\n\n\nfunction assertCompiler(name, Compiler) {\n  if (typeof Compiler !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Compiler`');\n  }\n}\n/* Assert the processor is not frozen. */\n\n\nfunction assertUnfrozen(name, frozen) {\n  if (frozen) {\n    throw new Error(['Cannot invoke `' + name + '` on a frozen processor.\\nCreate a new ', 'processor first, by invoking it: use `processor()` instead of ', '`processor`.'].join(''));\n  }\n}\n/* Assert `node` is a Unist node. */\n\n\nfunction assertNode(node) {\n  if (!node || !string(node.type)) {\n    throw new Error('Expected node, got `' + node + '`');\n  }\n}\n/* Assert that `complete` is `true`. */\n\n\nfunction assertDone(name, asyncName, complete) {\n  if (!complete) {\n    throw new Error('`' + name + '` finished async. Use `' + asyncName + '` instead');\n  }\n}","'use strict';\n\nmodule.exports = alphabetical;\n/* Check if the given character code, or the character\n * code at the first character, is alphabetical. */\n\nfunction alphabetical(character) {\n  var code = typeof character === 'string' ? character.charCodeAt(0) : character;\n  return code >= 97 && code <= 122\n  /* a-z */\n  || code >= 65 && code <= 90\n  /* A-Z */\n  ;\n}","import React from 'react';\nimport styles from './colorBar.module.css';\n\nconst colors = {\n    blue: '#00ccff',\n    darkBlue: '#0055d4',\n    orange: '#ff6600',\n    pink: '#ff00cc'\n};\n\nconst ColorBar = ( props ) => (\n    <div className={styles.colorBar} style={{ background: `linear-gradient(to bottom, transparent, ${colors[ props.color ]})` }} >\n    </div>\n);\n\nexport default ColorBar;\n","import React from 'react';\nimport ColorBar from './ColorBar';\nimport styles from './hero.module.css';\n\nconst Hero = ( props ) => {\n\n    const imageStyle = props.style == 'home' ? styles.homeHeroImage :\n        props.style === 'preview' ? styles.previewHeroImage :\n            styles.pageHeroImage;\n    const titleStyle = props.style == 'home' ? styles.homeHeroTitle :\n        props.style === 'preview' ? styles.previewHeroTitle :\n            styles.pageHeroTitle;\n\n    return (\n        <div className={styles.hero}>\n            <div className={imageStyle} style={{ backgroundImage: `url(${props.image})` }}>\n                {props.title && <h1 className={titleStyle} >{props.title} </h1>}\n            </div>\n            <ColorBar color={props.color}/>\n        </div>\n    );\n};\n\nexport default Hero;\n","'use strict';\n\nvar whitespace = require('is-whitespace-character');\n\nvar decode = require('parse-entities');\n\nvar locate = require('../locate/tag');\n\nmodule.exports = autoLink;\nautoLink.locator = locate;\nautoLink.notInLink = true;\nvar C_LT = '<';\nvar C_GT = '>';\nvar C_AT_SIGN = '@';\nvar C_SLASH = '/';\nvar MAILTO = 'mailto:';\nvar MAILTO_LENGTH = MAILTO.length;\n/* Tokenise a link. */\n\nfunction autoLink(eat, value, silent) {\n  var self;\n  var subvalue;\n  var length;\n  var index;\n  var queue;\n  var character;\n  var hasAtCharacter;\n  var link;\n  var now;\n  var content;\n  var tokenizers;\n  var exit;\n\n  if (value.charAt(0) !== C_LT) {\n    return;\n  }\n\n  self = this;\n  subvalue = '';\n  length = value.length;\n  index = 0;\n  queue = '';\n  hasAtCharacter = false;\n  link = '';\n  index++;\n  subvalue = C_LT;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (whitespace(character) || character === C_GT || character === C_AT_SIGN || character === ':' && value.charAt(index + 1) === C_SLASH) {\n      break;\n    }\n\n    queue += character;\n    index++;\n  }\n\n  if (!queue) {\n    return;\n  }\n\n  link += queue;\n  queue = '';\n  character = value.charAt(index);\n  link += character;\n  index++;\n\n  if (character === C_AT_SIGN) {\n    hasAtCharacter = true;\n  } else {\n    if (character !== ':' || value.charAt(index + 1) !== C_SLASH) {\n      return;\n    }\n\n    link += C_SLASH;\n    index++;\n  }\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (whitespace(character) || character === C_GT) {\n      break;\n    }\n\n    queue += character;\n    index++;\n  }\n\n  character = value.charAt(index);\n\n  if (!queue || character !== C_GT) {\n    return;\n  }\n  /* istanbul ignore if - never used (yet) */\n\n\n  if (silent) {\n    return true;\n  }\n\n  link += queue;\n  content = link;\n  subvalue += link + character;\n  now = eat.now();\n  now.column++;\n  now.offset++;\n\n  if (hasAtCharacter) {\n    if (link.slice(0, MAILTO_LENGTH).toLowerCase() === MAILTO) {\n      content = content.substr(MAILTO_LENGTH);\n      now.column += MAILTO_LENGTH;\n      now.offset += MAILTO_LENGTH;\n    } else {\n      link = MAILTO + link;\n    }\n  }\n  /* Temporarily remove all tokenizers except text in autolinks. */\n\n\n  tokenizers = self.inlineTokenizers;\n  self.inlineTokenizers = {\n    text: tokenizers.text\n  };\n  exit = self.enterLink();\n  content = self.tokenizeInline(content, now);\n  self.inlineTokenizers = tokenizers;\n  exit();\n  return eat(subvalue)({\n    type: 'link',\n    title: null,\n    url: decode(link, {\n      nonTerminated: false\n    }),\n    children: content\n  });\n}","// .dirname, .basename, and .extname methods are extracted from Node.js v8.11.1,\n// backported and transplited with Babel, with backwards-compat fixes\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// resolves . and .. elements in a path array with directory names there\n// must be no slashes, empty elements, or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\nfunction normalizeArray(parts, allowAboveRoot) {\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n\n  for (var i = parts.length - 1; i >= 0; i--) {\n    var last = parts[i];\n\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  } // if the path is allowed to go above the root, restore leading ..s\n\n\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n} // path.resolve([from ...], to)\n// posix version\n\n\nexports.resolve = function () {\n  var resolvedPath = '',\n      resolvedAbsolute = false;\n\n  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    var path = i >= 0 ? arguments[i] : process.cwd(); // Skip empty and invalid entries\n\n    if (typeof path !== 'string') {\n      throw new TypeError('Arguments to path.resolve must be strings');\n    } else if (!path) {\n      continue;\n    }\n\n    resolvedPath = path + '/' + resolvedPath;\n    resolvedAbsolute = path.charAt(0) === '/';\n  } // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n  // Normalize the path\n\n\n  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function (p) {\n    return !!p;\n  }), !resolvedAbsolute).join('/');\n  return (resolvedAbsolute ? '/' : '') + resolvedPath || '.';\n}; // path.normalize(path)\n// posix version\n\n\nexports.normalize = function (path) {\n  var isAbsolute = exports.isAbsolute(path),\n      trailingSlash = substr(path, -1) === '/'; // Normalize the path\n\n  path = normalizeArray(filter(path.split('/'), function (p) {\n    return !!p;\n  }), !isAbsolute).join('/');\n\n  if (!path && !isAbsolute) {\n    path = '.';\n  }\n\n  if (path && trailingSlash) {\n    path += '/';\n  }\n\n  return (isAbsolute ? '/' : '') + path;\n}; // posix version\n\n\nexports.isAbsolute = function (path) {\n  return path.charAt(0) === '/';\n}; // posix version\n\n\nexports.join = function () {\n  var paths = Array.prototype.slice.call(arguments, 0);\n  return exports.normalize(filter(paths, function (p, index) {\n    if (typeof p !== 'string') {\n      throw new TypeError('Arguments to path.join must be strings');\n    }\n\n    return p;\n  }).join('/'));\n}; // path.relative(from, to)\n// posix version\n\n\nexports.relative = function (from, to) {\n  from = exports.resolve(from).substr(1);\n  to = exports.resolve(to).substr(1);\n\n  function trim(arr) {\n    var start = 0;\n\n    for (; start < arr.length; start++) {\n      if (arr[start] !== '') break;\n    }\n\n    var end = arr.length - 1;\n\n    for (; end >= 0; end--) {\n      if (arr[end] !== '') break;\n    }\n\n    if (start > end) return [];\n    return arr.slice(start, end - start + 1);\n  }\n\n  var fromParts = trim(from.split('/'));\n  var toParts = trim(to.split('/'));\n  var length = Math.min(fromParts.length, toParts.length);\n  var samePartsLength = length;\n\n  for (var i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  var outputParts = [];\n\n  for (var i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n  return outputParts.join('/');\n};\n\nexports.sep = '/';\nexports.delimiter = ':';\n\nexports.dirname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  if (path.length === 0) return '.';\n  var code = path.charCodeAt(0);\n  var hasRoot = code === 47\n  /*/*/\n  ;\n  var end = -1;\n  var matchedSlash = true;\n\n  for (var i = path.length - 1; i >= 1; --i) {\n    code = path.charCodeAt(i);\n\n    if (code === 47\n    /*/*/\n    ) {\n      if (!matchedSlash) {\n        end = i;\n        break;\n      }\n    } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) return hasRoot ? '/' : '.';\n\n  if (hasRoot && end === 1) {\n    // return '//';\n    // Backwards-compat fix:\n    return '/';\n  }\n\n  return path.slice(0, end);\n};\n\nfunction basename(path) {\n  if (typeof path !== 'string') path = path + '';\n  var start = 0;\n  var end = -1;\n  var matchedSlash = true;\n  var i;\n\n  for (i = path.length - 1; i >= 0; --i) {\n    if (path.charCodeAt(i) === 47\n    /*/*/\n    ) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now\n      if (!matchedSlash) {\n        start = i + 1;\n        break;\n      }\n    } else if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // path component\n      matchedSlash = false;\n      end = i + 1;\n    }\n  }\n\n  if (end === -1) return '';\n  return path.slice(start, end);\n} // Uses a mixed approach for backwards-compatibility, as ext behavior changed\n// in new Node.js versions, so only basename() above is backported here\n\n\nexports.basename = function (path, ext) {\n  var f = basename(path);\n\n  if (ext && f.substr(-1 * ext.length) === ext) {\n    f = f.substr(0, f.length - ext.length);\n  }\n\n  return f;\n};\n\nexports.extname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  var startDot = -1;\n  var startPart = 0;\n  var end = -1;\n  var matchedSlash = true; // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n\n  var preDotState = 0;\n\n  for (var i = path.length - 1; i >= 0; --i) {\n    var code = path.charCodeAt(i);\n\n    if (code === 47\n    /*/*/\n    ) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now\n      if (!matchedSlash) {\n        startPart = i + 1;\n        break;\n      }\n\n      continue;\n    }\n\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n\n    if (code === 46\n    /*.*/\n    ) {\n      // If this is our first dot, mark it as the start of our extension\n      if (startDot === -1) startDot = i;else if (preDotState !== 1) preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot\n  preDotState === 0 || // The (right-most) trimmed path component is exactly '..'\n  preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n    return '';\n  }\n\n  return path.slice(startDot, end);\n};\n\nfunction filter(xs, f) {\n  if (xs.filter) return xs.filter(f);\n  var res = [];\n\n  for (var i = 0; i < xs.length; i++) {\n    if (f(xs[i], i, xs)) res.push(xs[i]);\n  }\n\n  return res;\n} // String.prototype.substr - negative index don't work in IE8\n\n\nvar substr = 'ab'.substr(-1) === 'b' ? function (str, start, len) {\n  return str.substr(start, len);\n} : function (str, start, len) {\n  if (start < 0) start = str.length + start;\n  return str.substr(start, len);\n};","'use strict';\n\nmodule.exports = trimTrailingLines;\nvar line = '\\n';\n/* Remove final newline characters from `value`. */\n\nfunction trimTrailingLines(value) {\n  var val = String(value);\n  var index = val.length;\n\n  while (val.charAt(--index) === line) {\n    /* Empty */\n  }\n\n  return val.slice(0, index + 1);\n}","// extracted by mini-css-extract-plugin\nmodule.exports = {\"variables\":\"\\\"../layouts/variables.css\\\"\",\"padding\":\"40px\",\"contentPadding\":\"120px\",\"contentPaddingTablet\":\"80px\",\"breakTablet\":\"767px\",\"contentPaddingMobile\":\"40px\",\"breakMobile\":\"419px\",\"breakColumns\":\"639px\",\"maxContentWidth\":\"1600px\",\"blue\":\"#00ccff\",\"grey\":\"#9c9c9c\",\"gradient\":\"linear-gradient(-45deg, #00ccff, #ff00cc, #ff6600, #0055d4)\",\"gradientSize\":\"200% 200%\",\"gradientPosition\":\"100% 30%\",\"hero\":\"hero-module--hero--S__gH\",\"heroImage\":\"hero-module--heroImage--DciWV\",\"homeHeroImage\":\"hero-module--homeHeroImage--2HGn_ hero-module--heroImage--DciWV\",\"pageHeroImage\":\"hero-module--pageHeroImage--2axNo hero-module--heroImage--DciWV\",\"previewHeroImage\":\"hero-module--previewHeroImage--1Dq9J hero-module--heroImage--DciWV\",\"heroTitle\":\"hero-module--heroTitle--2LulU\",\"homeHeroTitle\":\"hero-module--homeHeroTitle--21TB_ hero-module--heroTitle--2LulU\",\"pageHeroTitle\":\"hero-module--pageHeroTitle--39fQv hero-module--heroTitle--2LulU\",\"previewHeroTitle\":\"hero-module--previewHeroTitle--12RDO hero-module--heroTitle--2LulU\"};","/* eslint-disable react/prop-types, react/no-multi-comp */\n'use strict';\n\nvar xtend = require('xtend');\n\nvar React = require('react');\n\nvar supportsStringRender = parseInt((React.version || '16').slice(0, 2), 10) >= 16;\nvar createElement = React.createElement;\nmodule.exports = {\n  break: 'br',\n  paragraph: 'p',\n  emphasis: 'em',\n  strong: 'strong',\n  thematicBreak: 'hr',\n  blockquote: 'blockquote',\n  delete: 'del',\n  link: 'a',\n  image: 'img',\n  linkReference: 'a',\n  imageReference: 'img',\n  table: SimpleRenderer.bind(null, 'table'),\n  tableHead: SimpleRenderer.bind(null, 'thead'),\n  tableBody: SimpleRenderer.bind(null, 'tbody'),\n  tableRow: SimpleRenderer.bind(null, 'tr'),\n  tableCell: TableCell,\n  root: Root,\n  text: TextRenderer,\n  list: List,\n  listItem: ListItem,\n  definition: NullRenderer,\n  heading: Heading,\n  inlineCode: InlineCode,\n  code: CodeBlock,\n  html: Html,\n  virtualHtml: VirtualHtml,\n  parsedHtml: ParsedHtml\n};\n\nfunction TextRenderer(props) {\n  return supportsStringRender ? props.children : createElement('span', null, props.children);\n}\n\nfunction Root(props) {\n  var useFragment = !props.className;\n  var root = useFragment ? React.Fragment || 'div' : 'div';\n  return createElement(root, useFragment ? null : props, props.children);\n}\n\nfunction SimpleRenderer(tag, props) {\n  return createElement(tag, getCoreProps(props), props.children);\n}\n\nfunction TableCell(props) {\n  var style = props.align ? {\n    textAlign: props.align\n  } : undefined;\n  var coreProps = getCoreProps(props);\n  return createElement(props.isHeader ? 'th' : 'td', style ? xtend({\n    style: style\n  }, coreProps) : coreProps, props.children);\n}\n\nfunction Heading(props) {\n  return createElement(\"h\".concat(props.level), getCoreProps(props), props.children);\n}\n\nfunction List(props) {\n  var attrs = getCoreProps(props);\n\n  if (props.start !== null && props.start !== 1) {\n    attrs.start = props.start.toString();\n  }\n\n  return createElement(props.ordered ? 'ol' : 'ul', attrs, props.children);\n}\n\nfunction ListItem(props) {\n  var checkbox = null;\n\n  if (props.checked !== null) {\n    var checked = props.checked;\n    checkbox = createElement('input', {\n      type: 'checkbox',\n      checked: checked,\n      readOnly: true\n    });\n  }\n\n  return createElement('li', getCoreProps(props), checkbox, props.children);\n}\n\nfunction CodeBlock(props) {\n  var className = props.language && \"language-\".concat(props.language);\n  var code = createElement('code', className ? {\n    className: className\n  } : null, props.value);\n  return createElement('pre', getCoreProps(props), code);\n}\n\nfunction InlineCode(props) {\n  return createElement('code', getCoreProps(props), props.children);\n}\n\nfunction Html(props) {\n  if (props.skipHtml) {\n    return null;\n  }\n\n  var tag = props.isBlock ? 'div' : 'span';\n\n  if (props.escapeHtml) {\n    var comp = React.Fragment || tag;\n    return createElement(comp, null, props.value);\n  }\n\n  var nodeProps = {\n    dangerouslySetInnerHTML: {\n      __html: props.value\n    }\n  };\n  return createElement(tag, nodeProps);\n}\n\nfunction ParsedHtml(props) {\n  return props['data-sourcepos'] ? React.cloneElement(props.element, {\n    'data-sourcepos': props['data-sourcepos']\n  }) : props.element;\n}\n\nfunction VirtualHtml(props) {\n  return createElement(props.tag, getCoreProps(props), props.children);\n}\n\nfunction NullRenderer() {\n  return null;\n}\n\nfunction getCoreProps(props) {\n  return props['data-sourcepos'] ? {\n    'data-sourcepos': props['data-sourcepos']\n  } : {};\n}","'use strict';\n\nvar locate = require('../locate/break');\n\nmodule.exports = hardBreak;\nhardBreak.locator = locate;\nvar MIN_BREAK_LENGTH = 2;\n\nfunction hardBreak(eat, value, silent) {\n  var length = value.length;\n  var index = -1;\n  var queue = '';\n  var character;\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character === '\\n') {\n      if (index < MIN_BREAK_LENGTH) {\n        return;\n      }\n      /* istanbul ignore if - never used (yet) */\n\n\n      if (silent) {\n        return true;\n      }\n\n      queue += character;\n      return eat(queue)({\n        type: 'break'\n      });\n    }\n\n    if (character !== ' ') {\n      return;\n    }\n\n    queue += character;\n  }\n}","'use strict';\n\nmodule.exports = factory;\n/* Construct a state `toggler`: a function which inverses\n * `property` in context based on its current value.\n * The by `toggler` returned function restores that value. */\n\nfunction factory(key, state, ctx) {\n  return enter;\n\n  function enter() {\n    var context = ctx || this;\n    var current = context[key];\n    context[key] = !state;\n    return exit;\n\n    function exit() {\n      context[key] = current;\n    }\n  }\n}","'use strict';\n\nvar xtend = require('xtend');\n\nvar inherits = require('inherits');\n\nmodule.exports = unherit;\n/* Create a custom constructor which can be modified\n * without affecting the original class. */\n\nfunction unherit(Super) {\n  var result;\n  var key;\n  var value;\n  inherits(Of, Super);\n  inherits(From, Of);\n  /* Clone values. */\n\n  result = Of.prototype;\n\n  for (key in result) {\n    value = result[key];\n\n    if (value && typeof value === 'object') {\n      result[key] = 'concat' in value ? value.concat() : xtend(value);\n    }\n  }\n\n  return Of;\n  /* Constructor accepting a single argument,\n   * which itself is an `arguments` object. */\n\n  function From(parameters) {\n    return Super.apply(this, parameters);\n  }\n  /* Constructor accepting variadic arguments. */\n\n\n  function Of() {\n    if (!(this instanceof Of)) {\n      return new From(arguments);\n    }\n\n    return Super.apply(this, arguments);\n  }\n}","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n  if (typeof Array.isArray === 'function') {\n    return Array.isArray(arr);\n  }\n\n  return toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n  if (!obj || toStr.call(obj) !== '[object Object]') {\n    return false;\n  }\n\n  var hasOwnConstructor = hasOwn.call(obj, 'constructor');\n  var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf'); // Not own constructor property must be Object\n\n  if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n    return false;\n  } // Own properties are enumerated firstly, so to speed up,\n  // if last one is own, then all properties are own.\n\n\n  var key;\n\n  for (key in obj) {\n    /**/\n  }\n\n  return typeof key === 'undefined' || hasOwn.call(obj, key);\n}; // If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\n\n\nvar setProperty = function setProperty(target, options) {\n  if (defineProperty && options.name === '__proto__') {\n    defineProperty(target, options.name, {\n      enumerable: true,\n      configurable: true,\n      value: options.newValue,\n      writable: true\n    });\n  } else {\n    target[options.name] = options.newValue;\n  }\n}; // Return undefined instead of __proto__ if '__proto__' is not an own property\n\n\nvar getProperty = function getProperty(obj, name) {\n  if (name === '__proto__') {\n    if (!hasOwn.call(obj, name)) {\n      return void 0;\n    } else if (gOPD) {\n      // In early versions of node, obj['__proto__'] is buggy when obj has\n      // __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n      return gOPD(obj, name).value;\n    }\n  }\n\n  return obj[name];\n};\n\nmodule.exports = function extend() {\n  var options, name, src, copy, copyIsArray, clone;\n  var target = arguments[0];\n  var i = 1;\n  var length = arguments.length;\n  var deep = false; // Handle a deep copy situation\n\n  if (typeof target === 'boolean') {\n    deep = target;\n    target = arguments[1] || {}; // skip the boolean and the target\n\n    i = 2;\n  }\n\n  if (target == null || typeof target !== 'object' && typeof target !== 'function') {\n    target = {};\n  }\n\n  for (; i < length; ++i) {\n    options = arguments[i]; // Only deal with non-null/undefined values\n\n    if (options != null) {\n      // Extend the base object\n      for (name in options) {\n        src = getProperty(target, name);\n        copy = getProperty(options, name); // Prevent never-ending loop\n\n        if (target !== copy) {\n          // Recurse if we're merging plain objects or arrays\n          if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n            if (copyIsArray) {\n              copyIsArray = false;\n              clone = src && isArray(src) ? src : [];\n            } else {\n              clone = src && isPlainObject(src) ? src : {};\n            } // Never move original objects, clone them\n\n\n            setProperty(target, {\n              name: name,\n              newValue: extend(deep, clone, copy)\n            }); // Don't bring in undefined values\n          } else if (typeof copy !== 'undefined') {\n            setProperty(target, {\n              name: name,\n              newValue: copy\n            });\n          }\n        }\n      }\n    }\n  } // Return the modified object\n\n\n  return target;\n};","'use strict';\n\nmodule.exports = factory;\n\nfunction factory(file) {\n  var contents = indices(String(file));\n  return {\n    toPosition: offsetToPositionFactory(contents),\n    toOffset: positionToOffsetFactory(contents)\n  };\n} // Factory to get the line and column-based `position` for `offset` in the bound\n// indices.\n\n\nfunction offsetToPositionFactory(indices) {\n  return offsetToPosition; // Get the line and column-based `position` for `offset` in the bound indices.\n\n  function offsetToPosition(offset) {\n    var index = -1;\n    var length = indices.length;\n\n    if (offset < 0) {\n      return {};\n    }\n\n    while (++index < length) {\n      if (indices[index] > offset) {\n        return {\n          line: index + 1,\n          column: offset - (indices[index - 1] || 0) + 1,\n          offset: offset\n        };\n      }\n    }\n\n    return {};\n  }\n} // Factory to get the `offset` for a line and column-based `position` in the\n// bound indices.\n\n\nfunction positionToOffsetFactory(indices) {\n  return positionToOffset; // Get the `offset` for a line and column-based `position` in the bound\n  // indices.\n\n  function positionToOffset(position) {\n    var line = position && position.line;\n    var column = position && position.column;\n\n    if (!isNaN(line) && !isNaN(column) && line - 1 in indices) {\n      return (indices[line - 2] || 0) + column - 1 || 0;\n    }\n\n    return -1;\n  }\n} // Get indices of line-breaks in `value`.\n\n\nfunction indices(value) {\n  var result = [];\n  var index = value.indexOf('\\n');\n\n  while (index !== -1) {\n    result.push(index + 1);\n    index = value.indexOf('\\n', index + 1);\n  }\n\n  result.push(value.length + 1);\n  return result;\n}","'use strict';\n\nvar visit = require('unist-util-visit');\n\nmodule.exports = function (node) {\n  visit(node, 'table', wrap);\n  return node;\n};\n\nfunction wrap(table) {\n  var children = table.children;\n  table.children = [{\n    type: 'tableHead',\n    align: table.align,\n    children: [children[0]],\n    position: children[0].position\n  }];\n\n  if (children.length > 1) {\n    table.children.push({\n      type: 'tableBody',\n      align: table.align,\n      children: children.slice(1),\n      position: {\n        start: children[1].position.start,\n        end: children[children.length - 1].position.end\n      }\n    });\n  }\n}","'use strict';\n\nmodule.exports = factory;\nvar MERGEABLE_NODES = {\n  text: mergeText,\n  blockquote: mergeBlockquote\n};\n/* Check whether a node is mergeable with adjacent nodes. */\n\nfunction mergeable(node) {\n  var start;\n  var end;\n\n  if (node.type !== 'text' || !node.position) {\n    return true;\n  }\n\n  start = node.position.start;\n  end = node.position.end;\n  /* Only merge nodes which occupy the same size as their\n   * `value`. */\n\n  return start.line !== end.line || end.column - start.column === node.value.length;\n}\n/* Merge two text nodes: `node` into `prev`. */\n\n\nfunction mergeText(prev, node) {\n  prev.value += node.value;\n  return prev;\n}\n/* Merge two blockquotes: `node` into `prev`, unless in\n * CommonMark mode. */\n\n\nfunction mergeBlockquote(prev, node) {\n  if (this.options.commonmark) {\n    return node;\n  }\n\n  prev.children = prev.children.concat(node.children);\n  return prev;\n}\n/* Construct a tokenizer.  This creates both\n * `tokenizeInline` and `tokenizeBlock`. */\n\n\nfunction factory(type) {\n  return tokenize;\n  /* Tokenizer for a bound `type`. */\n\n  function tokenize(value, location) {\n    var self = this;\n    var offset = self.offset;\n    var tokens = [];\n    var methods = self[type + 'Methods'];\n    var tokenizers = self[type + 'Tokenizers'];\n    var line = location.line;\n    var column = location.column;\n    var index;\n    var length;\n    var method;\n    var name;\n    var matched;\n    var valueLength;\n    /* Trim white space only lines. */\n\n    if (!value) {\n      return tokens;\n    }\n    /* Expose on `eat`. */\n\n\n    eat.now = now;\n    eat.file = self.file;\n    /* Sync initial offset. */\n\n    updatePosition('');\n    /* Iterate over `value`, and iterate over all\n     * tokenizers.  When one eats something, re-iterate\n     * with the remaining value.  If no tokenizer eats,\n     * something failed (should not happen) and an\n     * exception is thrown. */\n\n    while (value) {\n      index = -1;\n      length = methods.length;\n      matched = false;\n\n      while (++index < length) {\n        name = methods[index];\n        method = tokenizers[name];\n\n        if (method && (\n        /* istanbul ignore next */\n        !method.onlyAtStart || self.atStart) && (!method.notInList || !self.inList) && (!method.notInBlock || !self.inBlock) && (!method.notInLink || !self.inLink)) {\n          valueLength = value.length;\n          method.apply(self, [eat, value]);\n          matched = valueLength !== value.length;\n\n          if (matched) {\n            break;\n          }\n        }\n      }\n      /* istanbul ignore if */\n\n\n      if (!matched) {\n        self.file.fail(new Error('Infinite loop'), eat.now());\n      }\n    }\n\n    self.eof = now();\n    return tokens;\n    /* Update line, column, and offset based on\n     * `value`. */\n\n    function updatePosition(subvalue) {\n      var lastIndex = -1;\n      var index = subvalue.indexOf('\\n');\n\n      while (index !== -1) {\n        line++;\n        lastIndex = index;\n        index = subvalue.indexOf('\\n', index + 1);\n      }\n\n      if (lastIndex === -1) {\n        column += subvalue.length;\n      } else {\n        column = subvalue.length - lastIndex;\n      }\n\n      if (line in offset) {\n        if (lastIndex !== -1) {\n          column += offset[line];\n        } else if (column <= offset[line]) {\n          column = offset[line] + 1;\n        }\n      }\n    }\n    /* Get offset.  Called before the first character is\n     * eaten to retrieve the range's offsets. */\n\n\n    function getOffset() {\n      var indentation = [];\n      var pos = line + 1;\n      /* Done.  Called when the last character is\n       * eaten to retrieve the range’s offsets. */\n\n      return function () {\n        var last = line + 1;\n\n        while (pos < last) {\n          indentation.push((offset[pos] || 0) + 1);\n          pos++;\n        }\n\n        return indentation;\n      };\n    }\n    /* Get the current position. */\n\n\n    function now() {\n      var pos = {\n        line: line,\n        column: column\n      };\n      pos.offset = self.toOffset(pos);\n      return pos;\n    }\n    /* Store position information for a node. */\n\n\n    function Position(start) {\n      this.start = start;\n      this.end = now();\n    }\n    /* Throw when a value is incorrectly eaten.\n     * This shouldn’t happen but will throw on new,\n     * incorrect rules. */\n\n\n    function validateEat(subvalue) {\n      /* istanbul ignore if */\n      if (value.substring(0, subvalue.length) !== subvalue) {\n        /* Capture stack-trace. */\n        self.file.fail(new Error('Incorrectly eaten value: please report this ' + 'warning on http://git.io/vg5Ft'), now());\n      }\n    }\n    /* Mark position and patch `node.position`. */\n\n\n    function position() {\n      var before = now();\n      return update;\n      /* Add the position to a node. */\n\n      function update(node, indent) {\n        var prev = node.position;\n        var start = prev ? prev.start : before;\n        var combined = [];\n        var n = prev && prev.end.line;\n        var l = before.line;\n        node.position = new Position(start);\n        /* If there was already a `position`, this\n         * node was merged.  Fixing `start` wasn’t\n         * hard, but the indent is different.\n         * Especially because some information, the\n         * indent between `n` and `l` wasn’t\n         * tracked.  Luckily, that space is\n         * (should be?) empty, so we can safely\n         * check for it now. */\n\n        if (prev && indent && prev.indent) {\n          combined = prev.indent;\n\n          if (n < l) {\n            while (++n < l) {\n              combined.push((offset[n] || 0) + 1);\n            }\n\n            combined.push(before.column);\n          }\n\n          indent = combined.concat(indent);\n        }\n\n        node.position.indent = indent || [];\n        return node;\n      }\n    }\n    /* Add `node` to `parent`s children or to `tokens`.\n     * Performs merges where possible. */\n\n\n    function add(node, parent) {\n      var children = parent ? parent.children : tokens;\n      var prev = children[children.length - 1];\n\n      if (prev && node.type === prev.type && node.type in MERGEABLE_NODES && mergeable(prev) && mergeable(node)) {\n        node = MERGEABLE_NODES[node.type].call(self, prev, node);\n      }\n\n      if (node !== prev) {\n        children.push(node);\n      }\n\n      if (self.atStart && tokens.length !== 0) {\n        self.exitStart();\n      }\n\n      return node;\n    }\n    /* Remove `subvalue` from `value`.\n     * `subvalue` must be at the start of `value`. */\n\n\n    function eat(subvalue) {\n      var indent = getOffset();\n      var pos = position();\n      var current = now();\n      validateEat(subvalue);\n      apply.reset = reset;\n      reset.test = test;\n      apply.test = test;\n      value = value.substring(subvalue.length);\n      updatePosition(subvalue);\n      indent = indent();\n      return apply;\n      /* Add the given arguments, add `position` to\n       * the returned node, and return the node. */\n\n      function apply(node, parent) {\n        return pos(add(pos(node), parent), indent);\n      }\n      /* Functions just like apply, but resets the\n       * content:  the line and column are reversed,\n       * and the eaten value is re-added.\n       * This is useful for nodes with a single\n       * type of content, such as lists and tables.\n       * See `apply` above for what parameters are\n       * expected. */\n\n\n      function reset() {\n        var node = apply.apply(null, arguments);\n        line = current.line;\n        column = current.column;\n        value = subvalue + value;\n        return node;\n      }\n      /* Test the position, after eating, and reverse\n       * to a not-eaten state. */\n\n\n      function test() {\n        var result = pos({});\n        line = current.line;\n        column = current.column;\n        value = subvalue + value;\n        return result.position;\n      }\n    }\n  }\n}","/*!\n * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n// The _isBuffer check is for Safari 5-7 support, because it's missing\n// Object.prototype.constructor. Remove this eventually\nmodule.exports = function (obj) {\n  return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer);\n};\n\nfunction isBuffer(obj) {\n  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj);\n} // For Node v0.10 support. Remove this eventually.\n\n\nfunction isSlowBuffer(obj) {\n  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0));\n}","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  var asterisk = value.indexOf('**', fromIndex);\n  var underscore = value.indexOf('__', fromIndex);\n\n  if (underscore === -1) {\n    return asterisk;\n  }\n\n  if (asterisk === -1) {\n    return underscore;\n  }\n\n  return underscore < asterisk ? underscore : asterisk;\n}","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  return value.indexOf('`', fromIndex);\n}","// extracted by mini-css-extract-plugin\nmodule.exports = {\"variables\":\"\\\"../layouts/variables.css\\\"\",\"blue\":\"#00ccff\",\"gradient\":\"linear-gradient(-45deg, #00ccff, #ff00cc, #ff6600, #0055d4)\",\"gradientSize\":\"200% 200%\",\"gradientPosition\":\"100% 30%\",\"breakMobile\":\"419px\",\"sticky\":\"sticky-module--sticky--3p77d\"};","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  var asterisk = value.indexOf('*', fromIndex);\n  var underscore = value.indexOf('_', fromIndex);\n\n  if (underscore === -1) {\n    return asterisk;\n  }\n\n  if (asterisk === -1) {\n    return underscore;\n  }\n\n  return underscore < asterisk ? underscore : asterisk;\n}","'use strict';\n\nvar slice = [].slice;\nmodule.exports = wrap;\n/* Wrap `fn`.  Can be sync or async; return a promise,\n * receive a completion handler, return new values and\n * errors. */\n\nfunction wrap(fn, callback) {\n  var invoked;\n  return wrapped;\n\n  function wrapped() {\n    var params = slice.call(arguments, 0);\n    var callback = fn.length > params.length;\n    var result;\n\n    if (callback) {\n      params.push(done);\n    }\n\n    try {\n      result = fn.apply(null, params);\n    } catch (err) {\n      /* Well, this is quite the pickle.  `fn` received\n       * a callback and invoked it (thus continuing the\n       * pipeline), but later also threw an error.\n       * We’re not about to restart the pipeline again,\n       * so the only thing left to do is to throw the\n       * thing instea. */\n      if (callback && invoked) {\n        throw err;\n      }\n\n      return done(err);\n    }\n\n    if (!callback) {\n      if (result && typeof result.then === 'function') {\n        result.then(then, done);\n      } else if (result instanceof Error) {\n        done(result);\n      } else {\n        then(result);\n      }\n    }\n  }\n  /* Invoke `next`, only once. */\n\n\n  function done() {\n    if (!invoked) {\n      invoked = true;\n      callback.apply(null, arguments);\n    }\n  }\n  /* Invoke `done` with one value.\n   * Tracks if an error is passed, too. */\n\n\n  function then(value) {\n    done(null, value);\n  }\n}","'use strict';\n\nmodule.exports = factory;\n/* Factory to de-escape a value, based on a list at `key`\n * in `ctx`. */\n\nfunction factory(ctx, key) {\n  return unescape;\n  /* De-escape a string using the expression at `key`\n   * in `ctx`. */\n\n  function unescape(value) {\n    var prev = 0;\n    var index = value.indexOf('\\\\');\n    var escape = ctx[key];\n    var queue = [];\n    var character;\n\n    while (index !== -1) {\n      queue.push(value.slice(prev, index));\n      prev = index + 1;\n      character = value.charAt(prev);\n      /* If the following character is not a valid escape,\n       * add the slash. */\n\n      if (!character || escape.indexOf(character) === -1) {\n        queue.push('\\\\');\n      }\n\n      index = value.indexOf('\\\\', prev);\n    }\n\n    queue.push(value.slice(prev));\n    return queue.join('');\n  }\n}","'use strict';\n\nvar whitespace = require('is-whitespace-character');\n\nmodule.exports = newline;\n/* Tokenise newline. */\n\nfunction newline(eat, value, silent) {\n  var character = value.charAt(0);\n  var length;\n  var subvalue;\n  var queue;\n  var index;\n\n  if (character !== '\\n') {\n    return;\n  }\n  /* istanbul ignore if - never used (yet) */\n\n\n  if (silent) {\n    return true;\n  }\n\n  index = 1;\n  length = value.length;\n  subvalue = character;\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (!whitespace(character)) {\n      break;\n    }\n\n    queue += character;\n\n    if (character === '\\n') {\n      subvalue += queue;\n      queue = '';\n    }\n\n    index++;\n  }\n\n  eat(subvalue);\n}","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  var link = value.indexOf('[', fromIndex);\n  var image = value.indexOf('![', fromIndex);\n\n  if (image === -1) {\n    return link;\n  }\n  /* Link can never be `-1` if an image is found, so we don’t need\n   * to check for that :) */\n\n\n  return link < image ? link : image;\n}","'use strict';\n\nvar VMessage = require('vfile-message');\n\nvar VFile = require('./core.js');\n\nmodule.exports = VFile;\nvar proto = VFile.prototype;\nproto.message = message;\nproto.info = info;\nproto.fail = fail;\n/* Slight backwards compatibility.  Remove in the future. */\n\nproto.warn = message;\n/* Create a message with `reason` at `position`.\n * When an error is passed in as `reason`, copies the stack. */\n\nfunction message(reason, position, origin) {\n  var filePath = this.path;\n  var message = new VMessage(reason, position, origin);\n\n  if (filePath) {\n    message.name = filePath + ':' + message.name;\n    message.file = filePath;\n  }\n\n  message.fatal = false;\n  this.messages.push(message);\n  return message;\n}\n/* Fail. Creates a vmessage, associates it with the file,\n * and throws it. */\n\n\nfunction fail() {\n  var message = this.message.apply(this, arguments);\n  message.fatal = true;\n  throw message;\n}\n/* Info. Creates a vmessage, associates it with the file,\n * and marks the fatality as null. */\n\n\nfunction info() {\n  var message = this.message.apply(this, arguments);\n  message.fatal = null;\n  return message;\n}","'use strict';\n\nmodule.exports = bail;\n\nfunction bail(err) {\n  if (err) {\n    throw err;\n  }\n}","'use strict';\n\nvar trim = require('trim-trailing-lines');\n\nmodule.exports = fencedCode;\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_TILDE = '~';\nvar C_TICK = '`';\nvar MIN_FENCE_COUNT = 3;\nvar CODE_INDENT_COUNT = 4;\n\nfunction fencedCode(eat, value, silent) {\n  var self = this;\n  var settings = self.options;\n  var length = value.length + 1;\n  var index = 0;\n  var subvalue = '';\n  var fenceCount;\n  var marker;\n  var character;\n  var flag;\n  var queue;\n  var content;\n  var exdentedContent;\n  var closing;\n  var exdentedClosing;\n  var indent;\n  var now;\n\n  if (!settings.gfm) {\n    return;\n  }\n  /* Eat initial spacing. */\n\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_SPACE && character !== C_TAB) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  indent = index;\n  /* Eat the fence. */\n\n  character = value.charAt(index);\n\n  if (character !== C_TILDE && character !== C_TICK) {\n    return;\n  }\n\n  index++;\n  marker = character;\n  fenceCount = 1;\n  subvalue += character;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== marker) {\n      break;\n    }\n\n    subvalue += character;\n    fenceCount++;\n    index++;\n  }\n\n  if (fenceCount < MIN_FENCE_COUNT) {\n    return;\n  }\n  /* Eat spacing before flag. */\n\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_SPACE && character !== C_TAB) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n  /* Eat flag. */\n\n\n  flag = '';\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character === C_NEWLINE || character === C_TILDE || character === C_TICK) {\n      break;\n    }\n\n    if (character === C_SPACE || character === C_TAB) {\n      queue += character;\n    } else {\n      flag += queue + character;\n      queue = '';\n    }\n\n    index++;\n  }\n\n  character = value.charAt(index);\n\n  if (character && character !== C_NEWLINE) {\n    return;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  now = eat.now();\n  now.column += subvalue.length;\n  now.offset += subvalue.length;\n  subvalue += flag;\n  flag = self.decode.raw(self.unescape(flag), now);\n\n  if (queue) {\n    subvalue += queue;\n  }\n\n  queue = '';\n  closing = '';\n  exdentedClosing = '';\n  content = '';\n  exdentedContent = '';\n  /* Eat content. */\n\n  while (index < length) {\n    character = value.charAt(index);\n    content += closing;\n    exdentedContent += exdentedClosing;\n    closing = '';\n    exdentedClosing = '';\n\n    if (character !== C_NEWLINE) {\n      content += character;\n      exdentedClosing += character;\n      index++;\n      continue;\n    }\n    /* Add the newline to `subvalue` if its the first\n     * character.  Otherwise, add it to the `closing`\n     * queue. */\n\n\n    if (content) {\n      closing += character;\n      exdentedClosing += character;\n    } else {\n      subvalue += character;\n    }\n\n    queue = '';\n    index++;\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character !== C_SPACE) {\n        break;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    closing += queue;\n    exdentedClosing += queue.slice(indent);\n\n    if (queue.length >= CODE_INDENT_COUNT) {\n      continue;\n    }\n\n    queue = '';\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character !== marker) {\n        break;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    closing += queue;\n    exdentedClosing += queue;\n\n    if (queue.length < fenceCount) {\n      continue;\n    }\n\n    queue = '';\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character !== C_SPACE && character !== C_TAB) {\n        break;\n      }\n\n      closing += character;\n      exdentedClosing += character;\n      index++;\n    }\n\n    if (!character || character === C_NEWLINE) {\n      break;\n    }\n  }\n\n  subvalue += content + closing;\n  return eat(subvalue)({\n    type: 'code',\n    lang: flag || null,\n    value: trim(exdentedContent)\n  });\n}","'use strict';\n\nvar whitespace = require('is-whitespace-character');\n\nvar normalize = require('../util/normalize');\n\nmodule.exports = definition;\ndefinition.notInList = true;\ndefinition.notInBlock = true;\nvar C_DOUBLE_QUOTE = '\"';\nvar C_SINGLE_QUOTE = '\\'';\nvar C_BACKSLASH = '\\\\';\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_BRACKET_OPEN = '[';\nvar C_BRACKET_CLOSE = ']';\nvar C_PAREN_OPEN = '(';\nvar C_PAREN_CLOSE = ')';\nvar C_COLON = ':';\nvar C_LT = '<';\nvar C_GT = '>';\n\nfunction definition(eat, value, silent) {\n  var self = this;\n  var commonmark = self.options.commonmark;\n  var index = 0;\n  var length = value.length;\n  var subvalue = '';\n  var beforeURL;\n  var beforeTitle;\n  var queue;\n  var character;\n  var test;\n  var identifier;\n  var url;\n  var title;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_SPACE && character !== C_TAB) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  character = value.charAt(index);\n\n  if (character !== C_BRACKET_OPEN) {\n    return;\n  }\n\n  index++;\n  subvalue += character;\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character === C_BRACKET_CLOSE) {\n      break;\n    } else if (character === C_BACKSLASH) {\n      queue += character;\n      index++;\n      character = value.charAt(index);\n    }\n\n    queue += character;\n    index++;\n  }\n\n  if (!queue || value.charAt(index) !== C_BRACKET_CLOSE || value.charAt(index + 1) !== C_COLON) {\n    return;\n  }\n\n  identifier = queue;\n  subvalue += queue + C_BRACKET_CLOSE + C_COLON;\n  index = subvalue.length;\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_TAB && character !== C_SPACE && character !== C_NEWLINE) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  character = value.charAt(index);\n  queue = '';\n  beforeURL = subvalue;\n\n  if (character === C_LT) {\n    index++;\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (!isEnclosedURLCharacter(character)) {\n        break;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    character = value.charAt(index);\n\n    if (character === isEnclosedURLCharacter.delimiter) {\n      subvalue += C_LT + queue + character;\n      index++;\n    } else {\n      if (commonmark) {\n        return;\n      }\n\n      index -= queue.length + 1;\n      queue = '';\n    }\n  }\n\n  if (!queue) {\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (!isUnclosedURLCharacter(character)) {\n        break;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    subvalue += queue;\n  }\n\n  if (!queue) {\n    return;\n  }\n\n  url = queue;\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_TAB && character !== C_SPACE && character !== C_NEWLINE) {\n      break;\n    }\n\n    queue += character;\n    index++;\n  }\n\n  character = value.charAt(index);\n  test = null;\n\n  if (character === C_DOUBLE_QUOTE) {\n    test = C_DOUBLE_QUOTE;\n  } else if (character === C_SINGLE_QUOTE) {\n    test = C_SINGLE_QUOTE;\n  } else if (character === C_PAREN_OPEN) {\n    test = C_PAREN_CLOSE;\n  }\n\n  if (!test) {\n    queue = '';\n    index = subvalue.length;\n  } else if (queue) {\n    subvalue += queue + character;\n    index = subvalue.length;\n    queue = '';\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character === test) {\n        break;\n      }\n\n      if (character === C_NEWLINE) {\n        index++;\n        character = value.charAt(index);\n\n        if (character === C_NEWLINE || character === test) {\n          return;\n        }\n\n        queue += C_NEWLINE;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    character = value.charAt(index);\n\n    if (character !== test) {\n      return;\n    }\n\n    beforeTitle = subvalue;\n    subvalue += queue + character;\n    index++;\n    title = queue;\n    queue = '';\n  } else {\n    return;\n  }\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_TAB && character !== C_SPACE) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  character = value.charAt(index);\n\n  if (!character || character === C_NEWLINE) {\n    if (silent) {\n      return true;\n    }\n\n    beforeURL = eat(beforeURL).test().end;\n    url = self.decode.raw(self.unescape(url), beforeURL, {\n      nonTerminated: false\n    });\n\n    if (title) {\n      beforeTitle = eat(beforeTitle).test().end;\n      title = self.decode.raw(self.unescape(title), beforeTitle);\n    }\n\n    return eat(subvalue)({\n      type: 'definition',\n      identifier: normalize(identifier),\n      title: title || null,\n      url: url\n    });\n  }\n}\n/* Check if `character` can be inside an enclosed URI. */\n\n\nfunction isEnclosedURLCharacter(character) {\n  return character !== C_GT && character !== C_BRACKET_OPEN && character !== C_BRACKET_CLOSE;\n}\n\nisEnclosedURLCharacter.delimiter = C_GT;\n/* Check if `character` can be inside an unclosed URI. */\n\nfunction isUnclosedURLCharacter(character) {\n  return character !== C_BRACKET_OPEN && character !== C_BRACKET_CLOSE && !whitespace(character);\n}","'use strict';\n\nmodule.exports = whitespace;\nvar fromCode = String.fromCharCode;\nvar re = /\\s/;\n/* Check if the given character code, or the character\n * code at the first character, is a whitespace character. */\n\nfunction whitespace(character) {\n  return re.test(typeof character === 'number' ? fromCode(character) : character.charAt(0));\n}","var toString = Object.prototype.toString;\nmodule.exports = isString;\n\nfunction isString(obj) {\n  return toString.call(obj) === \"[object String]\";\n}","'use strict';\n\nrequire(\"core-js/modules/es.array.reduce.js\");\n\nmodule.exports = function getDefinitions(node) {\n  var defs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  return (node.children || []).reduce(function (definitions, child) {\n    if (child.type === 'definition') {\n      definitions[child.identifier] = {\n        href: child.url,\n        title: child.title\n      };\n    }\n\n    return getDefinitions(child, definitions);\n  }, defs);\n};","'use strict';\n\nrequire(\"core-js/modules/es.array.reduce.js\");\n\nfunction _toConsumableArray(arr) {\n  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();\n}\n\nfunction _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n}\n\nfunction _iterableToArray(iter) {\n  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n}\n\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {\n      arr2[i] = arr[i];\n    }\n\n    return arr2;\n  }\n}\n\nvar xtend = require('xtend');\n\nvar unified = require('unified');\n\nvar parse = require('remark-parse');\n\nvar PropTypes = require('prop-types');\n\nvar addListMetadata = require('mdast-add-list-metadata');\n\nvar naiveHtml = require('./plugins/naive-html');\n\nvar disallowNode = require('./plugins/disallow-node');\n\nvar astToReact = require('./ast-to-react');\n\nvar wrapTableRows = require('./wrap-table-rows');\n\nvar getDefinitions = require('./get-definitions');\n\nvar uriTransformer = require('./uri-transformer');\n\nvar defaultRenderers = require('./renderers');\n\nvar symbols = require('./symbols');\n\nvar allTypes = Object.keys(defaultRenderers);\n\nvar ReactMarkdown = function ReactMarkdown(props) {\n  var src = props.source || props.children || '';\n\n  if (props.allowedTypes && props.disallowedTypes) {\n    throw new Error('Only one of `allowedTypes` and `disallowedTypes` should be defined');\n  }\n\n  var renderers = xtend(defaultRenderers, props.renderers);\n  var plugins = [parse].concat(props.plugins || []);\n  var parser = plugins.reduce(applyParserPlugin, unified());\n  var rawAst = parser.parse(src);\n  var renderProps = xtend(props, {\n    renderers: renderers,\n    definitions: getDefinitions(rawAst)\n  });\n  var astPlugins = determineAstPlugins(props);\n  var ast = astPlugins.reduce(function (node, plugin) {\n    return plugin(node, renderProps);\n  }, rawAst);\n  return astToReact(ast, renderProps);\n};\n\nfunction applyParserPlugin(parser, plugin) {\n  return Array.isArray(plugin) ? parser.use.apply(parser, _toConsumableArray(plugin)) : parser.use(plugin);\n}\n\nfunction determineAstPlugins(props) {\n  var plugins = [wrapTableRows, addListMetadata()];\n  var disallowedTypes = props.disallowedTypes;\n\n  if (props.allowedTypes) {\n    disallowedTypes = allTypes.filter(function (type) {\n      return type !== 'root' && props.allowedTypes.indexOf(type) === -1;\n    });\n  }\n\n  var removalMethod = props.unwrapDisallowed ? 'unwrap' : 'remove';\n\n  if (disallowedTypes && disallowedTypes.length > 0) {\n    plugins.push(disallowNode.ofType(disallowedTypes, removalMethod));\n  }\n\n  if (props.allowNode) {\n    plugins.push(disallowNode.ifNotMatch(props.allowNode, removalMethod));\n  }\n\n  var renderHtml = !props.escapeHtml && !props.skipHtml;\n  var hasHtmlParser = (props.astPlugins || []).some(function (item) {\n    var plugin = Array.isArray(item) ? item[0] : item;\n    return plugin.identity === symbols.HtmlParser;\n  });\n\n  if (renderHtml && !hasHtmlParser) {\n    plugins.push(naiveHtml);\n  }\n\n  return props.astPlugins ? plugins.concat(props.astPlugins) : plugins;\n}\n\nReactMarkdown.defaultProps = {\n  renderers: {},\n  escapeHtml: true,\n  skipHtml: false,\n  sourcePos: false,\n  rawSourcePos: false,\n  transformLinkUri: uriTransformer,\n  astPlugins: [],\n  plugins: []\n};\nReactMarkdown.propTypes = {\n  className: PropTypes.string,\n  source: PropTypes.string,\n  children: PropTypes.string,\n  sourcePos: PropTypes.bool,\n  rawSourcePos: PropTypes.bool,\n  escapeHtml: PropTypes.bool,\n  skipHtml: PropTypes.bool,\n  allowNode: PropTypes.func,\n  allowedTypes: PropTypes.arrayOf(PropTypes.oneOf(allTypes)),\n  disallowedTypes: PropTypes.arrayOf(PropTypes.oneOf(allTypes)),\n  transformLinkUri: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),\n  linkTarget: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  transformImageUri: PropTypes.func,\n  astPlugins: PropTypes.arrayOf(PropTypes.func),\n  unwrapDisallowed: PropTypes.bool,\n  renderers: PropTypes.object,\n  plugins: PropTypes.array\n};\nReactMarkdown.types = allTypes;\nReactMarkdown.renderers = defaultRenderers;\nReactMarkdown.uriTransformer = uriTransformer;\nmodule.exports = ReactMarkdown;","'use strict';\n\nvar alphabetical = require('is-alphabetical');\n\nvar decimal = require('is-decimal');\n\nmodule.exports = alphanumerical;\n/* Check if the given character code, or the character\n * code at the first character, is alphanumerical. */\n\nfunction alphanumerical(character) {\n  return alphabetical(character) || decimal(character);\n}","'use strict';\n\nvar whitespace = require('is-whitespace-character');\n\nvar locate = require('../locate/code-inline');\n\nmodule.exports = inlineCode;\ninlineCode.locator = locate;\nvar C_TICK = '`';\n/* Tokenise inline code. */\n\nfunction inlineCode(eat, value, silent) {\n  var length = value.length;\n  var index = 0;\n  var queue = '';\n  var tickQueue = '';\n  var contentQueue;\n  var subqueue;\n  var count;\n  var openingCount;\n  var subvalue;\n  var character;\n  var found;\n  var next;\n\n  while (index < length) {\n    if (value.charAt(index) !== C_TICK) {\n      break;\n    }\n\n    queue += C_TICK;\n    index++;\n  }\n\n  if (!queue) {\n    return;\n  }\n\n  subvalue = queue;\n  openingCount = index;\n  queue = '';\n  next = value.charAt(index);\n  count = 0;\n\n  while (index < length) {\n    character = next;\n    next = value.charAt(index + 1);\n\n    if (character === C_TICK) {\n      count++;\n      tickQueue += character;\n    } else {\n      count = 0;\n      queue += character;\n    }\n\n    if (count && next !== C_TICK) {\n      if (count === openingCount) {\n        subvalue += queue + tickQueue;\n        found = true;\n        break;\n      }\n\n      queue += tickQueue;\n      tickQueue = '';\n    }\n\n    index++;\n  }\n\n  if (!found) {\n    if (openingCount % 2 !== 0) {\n      return;\n    }\n\n    queue = '';\n  }\n  /* istanbul ignore if - never used (yet) */\n\n\n  if (silent) {\n    return true;\n  }\n\n  contentQueue = '';\n  subqueue = '';\n  length = queue.length;\n  index = -1;\n\n  while (++index < length) {\n    character = queue.charAt(index);\n\n    if (whitespace(character)) {\n      subqueue += character;\n      continue;\n    }\n\n    if (subqueue) {\n      if (contentQueue) {\n        contentQueue += subqueue;\n      }\n\n      subqueue = '';\n    }\n\n    contentQueue += character;\n  }\n\n  return eat(subvalue)({\n    type: 'inlineCode',\n    value: contentQueue\n  });\n}","'use strict';\n\nmodule.exports = collapse;\n/* collapse(' \\t\\nbar \\nbaz\\t'); // ' bar baz ' */\n\nfunction collapse(value) {\n  return String(value).replace(/\\s+/g, ' ');\n}","'use strict';\n\nvar repeat = require('repeat-string');\n\nvar trim = require('trim-trailing-lines');\n\nmodule.exports = indentedCode;\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar CODE_INDENT_COUNT = 4;\nvar CODE_INDENT = repeat(C_SPACE, CODE_INDENT_COUNT);\n/* Tokenise indented code. */\n\nfunction indentedCode(eat, value, silent) {\n  var index = -1;\n  var length = value.length;\n  var subvalue = '';\n  var content = '';\n  var subvalueQueue = '';\n  var contentQueue = '';\n  var character;\n  var blankQueue;\n  var indent;\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (indent) {\n      indent = false;\n      subvalue += subvalueQueue;\n      content += contentQueue;\n      subvalueQueue = '';\n      contentQueue = '';\n\n      if (character === C_NEWLINE) {\n        subvalueQueue = character;\n        contentQueue = character;\n      } else {\n        subvalue += character;\n        content += character;\n\n        while (++index < length) {\n          character = value.charAt(index);\n\n          if (!character || character === C_NEWLINE) {\n            contentQueue = character;\n            subvalueQueue = character;\n            break;\n          }\n\n          subvalue += character;\n          content += character;\n        }\n      }\n    } else if (character === C_SPACE && value.charAt(index + 1) === character && value.charAt(index + 2) === character && value.charAt(index + 3) === character) {\n      subvalueQueue += CODE_INDENT;\n      index += 3;\n      indent = true;\n    } else if (character === C_TAB) {\n      subvalueQueue += character;\n      indent = true;\n    } else {\n      blankQueue = '';\n\n      while (character === C_TAB || character === C_SPACE) {\n        blankQueue += character;\n        character = value.charAt(++index);\n      }\n\n      if (character !== C_NEWLINE) {\n        break;\n      }\n\n      subvalueQueue += blankQueue + character;\n      contentQueue += character;\n    }\n  }\n\n  if (content) {\n    if (silent) {\n      return true;\n    }\n\n    return eat(subvalue)({\n      type: 'code',\n      lang: null,\n      value: trim(content)\n    });\n  }\n}","// extracted by mini-css-extract-plugin\nmodule.exports = {\"colorBar\":\"colorBar-module--colorBar--P85CT\"};","// shim for using process in browser\nvar process = module.exports = {}; // cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n  throw new Error('setTimeout has not been defined');\n}\n\nfunction defaultClearTimeout() {\n  throw new Error('clearTimeout has not been defined');\n}\n\n(function () {\n  try {\n    if (typeof setTimeout === 'function') {\n      cachedSetTimeout = setTimeout;\n    } else {\n      cachedSetTimeout = defaultSetTimout;\n    }\n  } catch (e) {\n    cachedSetTimeout = defaultSetTimout;\n  }\n\n  try {\n    if (typeof clearTimeout === 'function') {\n      cachedClearTimeout = clearTimeout;\n    } else {\n      cachedClearTimeout = defaultClearTimeout;\n    }\n  } catch (e) {\n    cachedClearTimeout = defaultClearTimeout;\n  }\n})();\n\nfunction runTimeout(fun) {\n  if (cachedSetTimeout === setTimeout) {\n    //normal enviroments in sane situations\n    return setTimeout(fun, 0);\n  } // if setTimeout wasn't available but was latter defined\n\n\n  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n    cachedSetTimeout = setTimeout;\n    return setTimeout(fun, 0);\n  }\n\n  try {\n    // when when somebody has screwed with setTimeout but no I.E. maddness\n    return cachedSetTimeout(fun, 0);\n  } catch (e) {\n    try {\n      // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n      return cachedSetTimeout.call(null, fun, 0);\n    } catch (e) {\n      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n      return cachedSetTimeout.call(this, fun, 0);\n    }\n  }\n}\n\nfunction runClearTimeout(marker) {\n  if (cachedClearTimeout === clearTimeout) {\n    //normal enviroments in sane situations\n    return clearTimeout(marker);\n  } // if clearTimeout wasn't available but was latter defined\n\n\n  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n    cachedClearTimeout = clearTimeout;\n    return clearTimeout(marker);\n  }\n\n  try {\n    // when when somebody has screwed with setTimeout but no I.E. maddness\n    return cachedClearTimeout(marker);\n  } catch (e) {\n    try {\n      // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n      return cachedClearTimeout.call(null, marker);\n    } catch (e) {\n      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n      // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n      return cachedClearTimeout.call(this, marker);\n    }\n  }\n}\n\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n  if (!draining || !currentQueue) {\n    return;\n  }\n\n  draining = false;\n\n  if (currentQueue.length) {\n    queue = currentQueue.concat(queue);\n  } else {\n    queueIndex = -1;\n  }\n\n  if (queue.length) {\n    drainQueue();\n  }\n}\n\nfunction drainQueue() {\n  if (draining) {\n    return;\n  }\n\n  var timeout = runTimeout(cleanUpNextTick);\n  draining = true;\n  var len = queue.length;\n\n  while (len) {\n    currentQueue = queue;\n    queue = [];\n\n    while (++queueIndex < len) {\n      if (currentQueue) {\n        currentQueue[queueIndex].run();\n      }\n    }\n\n    queueIndex = -1;\n    len = queue.length;\n  }\n\n  currentQueue = null;\n  draining = false;\n  runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n  var args = new Array(arguments.length - 1);\n\n  if (arguments.length > 1) {\n    for (var i = 1; i < arguments.length; i++) {\n      args[i - 1] = arguments[i];\n    }\n  }\n\n  queue.push(new Item(fun, args));\n\n  if (queue.length === 1 && !draining) {\n    runTimeout(drainQueue);\n  }\n}; // v8 likes predictible objects\n\n\nfunction Item(fun, array) {\n  this.fun = fun;\n  this.array = array;\n}\n\nItem.prototype.run = function () {\n  this.fun.apply(null, this.array);\n};\n\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\n\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) {\n  return [];\n};\n\nprocess.binding = function (name) {\n  throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () {\n  return '/';\n};\n\nprocess.chdir = function (dir) {\n  throw new Error('process.chdir is not supported');\n};\n\nprocess.umask = function () {\n  return 0;\n};","'use strict';\n\nmodule.exports = interrupt;\n\nfunction interrupt(interruptors, tokenizers, ctx, params) {\n  var bools = ['pedantic', 'commonmark'];\n  var count = bools.length;\n  var length = interruptors.length;\n  var index = -1;\n  var interruptor;\n  var config;\n  var fn;\n  var offset;\n  var bool;\n  var ignore;\n\n  while (++index < length) {\n    interruptor = interruptors[index];\n    config = interruptor[1] || {};\n    fn = interruptor[0];\n    offset = -1;\n    ignore = false;\n\n    while (++offset < count) {\n      bool = bools[offset];\n\n      if (config[bool] !== undefined && config[bool] !== ctx.options[bool]) {\n        ignore = true;\n        break;\n      }\n    }\n\n    if (ignore) {\n      continue;\n    }\n\n    if (tokenizers[fn].apply(ctx, params)) {\n      return true;\n    }\n  }\n\n  return false;\n}","'use strict';\n\nvar trim = require('trim');\n\nvar whitespace = require('is-whitespace-character');\n\nvar locate = require('../locate/strong');\n\nmodule.exports = strong;\nstrong.locator = locate;\nvar C_ASTERISK = '*';\nvar C_UNDERSCORE = '_';\n\nfunction strong(eat, value, silent) {\n  var self = this;\n  var index = 0;\n  var character = value.charAt(index);\n  var now;\n  var pedantic;\n  var marker;\n  var queue;\n  var subvalue;\n  var length;\n  var prev;\n\n  if (character !== C_ASTERISK && character !== C_UNDERSCORE || value.charAt(++index) !== character) {\n    return;\n  }\n\n  pedantic = self.options.pedantic;\n  marker = character;\n  subvalue = marker + marker;\n  length = value.length;\n  index++;\n  queue = '';\n  character = '';\n\n  if (pedantic && whitespace(value.charAt(index))) {\n    return;\n  }\n\n  while (index < length) {\n    prev = character;\n    character = value.charAt(index);\n\n    if (character === marker && value.charAt(index + 1) === marker && (!pedantic || !whitespace(prev))) {\n      character = value.charAt(index + 2);\n\n      if (character !== marker) {\n        if (!trim(queue)) {\n          return;\n        }\n        /* istanbul ignore if - never used (yet) */\n\n\n        if (silent) {\n          return true;\n        }\n\n        now = eat.now();\n        now.column += 2;\n        now.offset += 2;\n        return eat(subvalue + queue + subvalue)({\n          type: 'strong',\n          children: self.tokenizeInline(queue, now)\n        });\n      }\n    }\n\n    if (!pedantic && character === '\\\\') {\n      queue += character;\n      character = value.charAt(++index);\n    }\n\n    queue += character;\n    index++;\n  }\n}","'use strict';\n\nmodule.exports = atxHeading;\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_HASH = '#';\nvar MAX_ATX_COUNT = 6;\n\nfunction atxHeading(eat, value, silent) {\n  var self = this;\n  var settings = self.options;\n  var length = value.length + 1;\n  var index = -1;\n  var now = eat.now();\n  var subvalue = '';\n  var content = '';\n  var character;\n  var queue;\n  var depth;\n  /* Eat initial spacing. */\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_SPACE && character !== C_TAB) {\n      index--;\n      break;\n    }\n\n    subvalue += character;\n  }\n  /* Eat hashes. */\n\n\n  depth = 0;\n\n  while (++index <= length) {\n    character = value.charAt(index);\n\n    if (character !== C_HASH) {\n      index--;\n      break;\n    }\n\n    subvalue += character;\n    depth++;\n  }\n\n  if (depth > MAX_ATX_COUNT) {\n    return;\n  }\n\n  if (!depth || !settings.pedantic && value.charAt(index + 1) === C_HASH) {\n    return;\n  }\n\n  length = value.length + 1;\n  /* Eat intermediate white-space. */\n\n  queue = '';\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_SPACE && character !== C_TAB) {\n      index--;\n      break;\n    }\n\n    queue += character;\n  }\n  /* Exit when not in pedantic mode without spacing. */\n\n\n  if (!settings.pedantic && queue.length === 0 && character && character !== C_NEWLINE) {\n    return;\n  }\n\n  if (silent) {\n    return true;\n  }\n  /* Eat content. */\n\n\n  subvalue += queue;\n  queue = '';\n  content = '';\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (!character || character === C_NEWLINE) {\n      break;\n    }\n\n    if (character !== C_SPACE && character !== C_TAB && character !== C_HASH) {\n      content += queue + character;\n      queue = '';\n      continue;\n    }\n\n    while (character === C_SPACE || character === C_TAB) {\n      queue += character;\n      character = value.charAt(++index);\n    }\n\n    while (character === C_HASH) {\n      queue += character;\n      character = value.charAt(++index);\n    }\n\n    while (character === C_SPACE || character === C_TAB) {\n      queue += character;\n      character = value.charAt(++index);\n    }\n\n    index--;\n  }\n\n  now.column += subvalue.length;\n  now.offset += subvalue.length;\n  subvalue += content + queue;\n  return eat(subvalue)({\n    type: 'heading',\n    depth: depth,\n    children: self.tokenizeInline(content, now)\n  });\n}","'use strict';\n\nmodule.exports = escapes;\nvar defaults = ['\\\\', '`', '*', '{', '}', '[', ']', '(', ')', '#', '+', '-', '.', '!', '_', '>'];\nvar gfm = defaults.concat(['~', '|']);\nvar commonmark = gfm.concat(['\\n', '\"', '$', '%', '&', \"'\", ',', '/', ':', ';', '<', '=', '?', '@', '^']);\nescapes.default = defaults;\nescapes.gfm = gfm;\nescapes.commonmark = commonmark;\n/* Get markdown escapes. */\n\nfunction escapes(options) {\n  var settings = options || {};\n\n  if (settings.commonmark) {\n    return commonmark;\n  }\n\n  return settings.gfm ? gfm : defaults;\n}","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  return value.indexOf('~~', fromIndex);\n}","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  return value.indexOf('\\\\', fromIndex);\n}","'use strict';\n\nmodule.exports = setextHeading;\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_EQUALS = '=';\nvar C_DASH = '-';\nvar MAX_HEADING_INDENT = 3;\n/* Map of characters which can be used to mark setext\n * headers, mapping to their corresponding depth. */\n\nvar SETEXT_MARKERS = {};\nSETEXT_MARKERS[C_EQUALS] = 1;\nSETEXT_MARKERS[C_DASH] = 2;\n\nfunction setextHeading(eat, value, silent) {\n  var self = this;\n  var now = eat.now();\n  var length = value.length;\n  var index = -1;\n  var subvalue = '';\n  var content;\n  var queue;\n  var character;\n  var marker;\n  var depth;\n  /* Eat initial indentation. */\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_SPACE || index >= MAX_HEADING_INDENT) {\n      index--;\n      break;\n    }\n\n    subvalue += character;\n  }\n  /* Eat content. */\n\n\n  content = '';\n  queue = '';\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character === C_NEWLINE) {\n      index--;\n      break;\n    }\n\n    if (character === C_SPACE || character === C_TAB) {\n      queue += character;\n    } else {\n      content += queue + character;\n      queue = '';\n    }\n  }\n\n  now.column += subvalue.length;\n  now.offset += subvalue.length;\n  subvalue += content + queue;\n  /* Ensure the content is followed by a newline and a\n   * valid marker. */\n\n  character = value.charAt(++index);\n  marker = value.charAt(++index);\n\n  if (character !== C_NEWLINE || !SETEXT_MARKERS[marker]) {\n    return;\n  }\n\n  subvalue += character;\n  /* Eat Setext-line. */\n\n  queue = marker;\n  depth = SETEXT_MARKERS[marker];\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character !== marker) {\n      if (character !== C_NEWLINE) {\n        return;\n      }\n\n      index--;\n      break;\n    }\n\n    queue += character;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  return eat(subvalue + queue)({\n    type: 'heading',\n    depth: depth,\n    children: self.tokenizeInline(content, now)\n  });\n}","'use strict';\n\nvar toString = Object.prototype.toString;\n\nmodule.exports = function (x) {\n  var prototype;\n  return toString.call(x) === '[object Object]' && (prototype = Object.getPrototypeOf(x), prototype === null || prototype === Object.getPrototypeOf({}));\n};","\"use strict\";\n\nvar protocols = ['http', 'https', 'mailto', 'tel'];\n\nmodule.exports = function uriTransformer(uri) {\n  var url = (uri || '').trim();\n  var first = url.charAt(0);\n\n  if (first === '#' || first === '/') {\n    return url;\n  }\n\n  var colon = url.indexOf(':');\n\n  if (colon === -1) {\n    return url;\n  }\n\n  var length = protocols.length;\n  var index = -1;\n\n  while (++index < length) {\n    var protocol = protocols[index];\n\n    if (colon === protocol.length && url.slice(0, protocol.length).toLowerCase() === protocol) {\n      return url;\n    }\n  }\n\n  index = url.indexOf('?');\n\n  if (index !== -1 && colon > index) {\n    return url;\n  }\n\n  index = url.indexOf('#');\n\n  if (index !== -1 && colon > index) {\n    return url;\n  } // eslint-disable-next-line no-script-url\n\n\n  return 'javascript:void(0)';\n};","'use strict';\n\nvar xtend = require('xtend');\n\nvar entities = require('parse-entities');\n\nmodule.exports = factory;\n/* Factory to create an entity decoder. */\n\nfunction factory(ctx) {\n  decoder.raw = decodeRaw;\n  return decoder;\n  /* Normalize `position` to add an `indent`. */\n\n  function normalize(position) {\n    var offsets = ctx.offset;\n    var line = position.line;\n    var result = [];\n\n    while (++line) {\n      if (!(line in offsets)) {\n        break;\n      }\n\n      result.push((offsets[line] || 0) + 1);\n    }\n\n    return {\n      start: position,\n      indent: result\n    };\n  }\n  /* Handle a warning.\n   * See https://github.com/wooorm/parse-entities\n   * for the warnings. */\n\n\n  function handleWarning(reason, position, code) {\n    if (code === 3) {\n      return;\n    }\n\n    ctx.file.message(reason, position);\n  }\n  /* Decode `value` (at `position`) into text-nodes. */\n\n\n  function decoder(value, position, handler) {\n    entities(value, {\n      position: normalize(position),\n      warning: handleWarning,\n      text: handler,\n      reference: handler,\n      textContext: ctx,\n      referenceContext: ctx\n    });\n  }\n  /* Decode `value` (at `position`) into a string. */\n\n\n  function decodeRaw(value, position, options) {\n    return entities(value, xtend(options, {\n      position: normalize(position),\n      warning: handleWarning\n    }));\n  }\n}","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor;\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      });\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor;\n\n      var TempCtor = function TempCtor() {};\n\n      TempCtor.prototype = superCtor.prototype;\n      ctor.prototype = new TempCtor();\n      ctor.prototype.constructor = ctor;\n    }\n  };\n}","'use strict';\n\nvar trim = require('trim');\n\nvar interrupt = require('../util/interrupt');\n\nmodule.exports = blockquote;\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_GT = '>';\n/* Tokenise a blockquote. */\n\nfunction blockquote(eat, value, silent) {\n  var self = this;\n  var offsets = self.offset;\n  var tokenizers = self.blockTokenizers;\n  var interruptors = self.interruptBlockquote;\n  var now = eat.now();\n  var currentLine = now.line;\n  var length = value.length;\n  var values = [];\n  var contents = [];\n  var indents = [];\n  var add;\n  var index = 0;\n  var character;\n  var rest;\n  var nextIndex;\n  var content;\n  var line;\n  var startIndex;\n  var prefixed;\n  var exit;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_SPACE && character !== C_TAB) {\n      break;\n    }\n\n    index++;\n  }\n\n  if (value.charAt(index) !== C_GT) {\n    return;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  index = 0;\n\n  while (index < length) {\n    nextIndex = value.indexOf(C_NEWLINE, index);\n    startIndex = index;\n    prefixed = false;\n\n    if (nextIndex === -1) {\n      nextIndex = length;\n    }\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character !== C_SPACE && character !== C_TAB) {\n        break;\n      }\n\n      index++;\n    }\n\n    if (value.charAt(index) === C_GT) {\n      index++;\n      prefixed = true;\n\n      if (value.charAt(index) === C_SPACE) {\n        index++;\n      }\n    } else {\n      index = startIndex;\n    }\n\n    content = value.slice(index, nextIndex);\n\n    if (!prefixed && !trim(content)) {\n      index = startIndex;\n      break;\n    }\n\n    if (!prefixed) {\n      rest = value.slice(index);\n      /* Check if the following code contains a possible\n       * block. */\n\n      if (interrupt(interruptors, tokenizers, self, [eat, rest, true])) {\n        break;\n      }\n    }\n\n    line = startIndex === index ? content : value.slice(startIndex, nextIndex);\n    indents.push(index - startIndex);\n    values.push(line);\n    contents.push(content);\n    index = nextIndex + 1;\n  }\n\n  index = -1;\n  length = indents.length;\n  add = eat(values.join(C_NEWLINE));\n\n  while (++index < length) {\n    offsets[currentLine] = (offsets[currentLine] || 0) + indents[index];\n    currentLine++;\n  }\n\n  exit = self.enterBlock();\n  contents = self.tokenizeBlock(contents.join(C_NEWLINE), now);\n  exit();\n  return add({\n    type: 'blockquote',\n    children: contents\n  });\n}","'use strict';\n/* eslint-disable max-params */\n\n/* Expose. */\n\nmodule.exports = is;\n/* Assert if `test` passes for `node`.\n * When a `parent` node is known the `index` of node */\n\nfunction is(test, node, index, parent, context) {\n  var hasParent = parent !== null && parent !== undefined;\n  var hasIndex = index !== null && index !== undefined;\n  var check = convert(test);\n\n  if (hasIndex && (typeof index !== 'number' || index < 0 || index === Infinity)) {\n    throw new Error('Expected positive finite index or child node');\n  }\n\n  if (hasParent && (!is(null, parent) || !parent.children)) {\n    throw new Error('Expected parent node');\n  }\n\n  if (!node || !node.type || typeof node.type !== 'string') {\n    return false;\n  }\n\n  if (hasParent !== hasIndex) {\n    throw new Error('Expected both parent and index');\n  }\n\n  return Boolean(check.call(context, node, index, parent));\n}\n\nfunction convert(test) {\n  if (typeof test === 'string') {\n    return typeFactory(test);\n  }\n\n  if (test === null || test === undefined) {\n    return ok;\n  }\n\n  if (typeof test === 'object') {\n    return ('length' in test ? anyFactory : matchesFactory)(test);\n  }\n\n  if (typeof test === 'function') {\n    return test;\n  }\n\n  throw new Error('Expected function, string, or object as test');\n}\n\nfunction convertAll(tests) {\n  var results = [];\n  var length = tests.length;\n  var index = -1;\n\n  while (++index < length) {\n    results[index] = convert(tests[index]);\n  }\n\n  return results;\n}\n/* Utility assert each property in `test` is represented\n * in `node`, and each values are strictly equal. */\n\n\nfunction matchesFactory(test) {\n  return matches;\n\n  function matches(node) {\n    var key;\n\n    for (key in test) {\n      if (node[key] !== test[key]) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n}\n\nfunction anyFactory(tests) {\n  var checks = convertAll(tests);\n  var length = checks.length;\n  return matches;\n\n  function matches() {\n    var index = -1;\n\n    while (++index < length) {\n      if (checks[index].apply(this, arguments)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n}\n/* Utility to convert a string into a function which checks\n * a given node’s type for said string. */\n\n\nfunction typeFactory(test) {\n  return type;\n\n  function type(node) {\n    return Boolean(node && node.type === test);\n  }\n}\n/* Utility to return true. */\n\n\nfunction ok() {\n  return true;\n}","'use strict';\n\nvar trim = require('trim');\n\nvar decimal = require('is-decimal');\n\nvar trimTrailingLines = require('trim-trailing-lines');\n\nvar interrupt = require('../util/interrupt');\n\nmodule.exports = paragraph;\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar TAB_SIZE = 4;\n/* Tokenise paragraph. */\n\nfunction paragraph(eat, value, silent) {\n  var self = this;\n  var settings = self.options;\n  var commonmark = settings.commonmark;\n  var gfm = settings.gfm;\n  var tokenizers = self.blockTokenizers;\n  var interruptors = self.interruptParagraph;\n  var index = value.indexOf(C_NEWLINE);\n  var length = value.length;\n  var position;\n  var subvalue;\n  var character;\n  var size;\n  var now;\n\n  while (index < length) {\n    /* Eat everything if there’s no following newline. */\n    if (index === -1) {\n      index = length;\n      break;\n    }\n    /* Stop if the next character is NEWLINE. */\n\n\n    if (value.charAt(index + 1) === C_NEWLINE) {\n      break;\n    }\n    /* In commonmark-mode, following indented lines\n     * are part of the paragraph. */\n\n\n    if (commonmark) {\n      size = 0;\n      position = index + 1;\n\n      while (position < length) {\n        character = value.charAt(position);\n\n        if (character === C_TAB) {\n          size = TAB_SIZE;\n          break;\n        } else if (character === C_SPACE) {\n          size++;\n        } else {\n          break;\n        }\n\n        position++;\n      }\n\n      if (size >= TAB_SIZE) {\n        index = value.indexOf(C_NEWLINE, index + 1);\n        continue;\n      }\n    }\n\n    subvalue = value.slice(index + 1);\n    /* Check if the following code contains a possible\n     * block. */\n\n    if (interrupt(interruptors, tokenizers, self, [eat, subvalue, true])) {\n      break;\n    }\n    /* Break if the following line starts a list, when\n     * already in a list, or when in commonmark, or when\n     * in gfm mode and the bullet is *not* numeric. */\n\n\n    if (tokenizers.list.call(self, eat, subvalue, true) && (self.inList || commonmark || gfm && !decimal(trim.left(subvalue).charAt(0)))) {\n      break;\n    }\n\n    position = index;\n    index = value.indexOf(C_NEWLINE, index + 1);\n\n    if (index !== -1 && trim(value.slice(position, index)) === '') {\n      index = position;\n      break;\n    }\n  }\n\n  subvalue = value.slice(0, index);\n\n  if (trim(subvalue) === '') {\n    eat(subvalue);\n    return null;\n  }\n  /* istanbul ignore if - never used (yet) */\n\n\n  if (silent) {\n    return true;\n  }\n\n  now = eat.now();\n  subvalue = trimTrailingLines(subvalue);\n  return eat(subvalue)({\n    type: 'paragraph',\n    children: self.tokenizeInline(subvalue, now)\n  });\n}","import React from 'react';\nimport styles from './social.module.css';\n\nconst Instagram = () => (\n    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 130.07 130.02\" className={styles.instagram}>\n        {/* ORIGINAL GRADIENT\n        <defs id=\"defs4\">\n            <radialGradient id=\"c\" gradientUnits=\"userSpaceOnUse\" cy=\"578\" cx=\"158\" gradientTransform=\"matrix(0 -1.98 1.84 0 -1.03e3 454)\" r=\"65\">\n                <stop id=\"stop14\" stop-color=\"#fd5\" offset=\"0\"/>\n                <stop id=\"stop16\" stop-color=\"#fd5\" offset=\".1\"/>\n                <stop id=\"stop18\" stop-color=\"#ff543e\" offset=\".5\"/>\n                <stop id=\"stop20\" stop-color=\"#c837ab\" offset=\"1\"/>\n            </radialGradient>\n            <radialGradient id=\"d\" gradientUnits=\"userSpaceOnUse\" cy=\"473\" cx=\"148\" gradientTransform=\"matrix(.174 .869 -3.58 .717 1.65e3 -458)\" r=\"65\">\n                <stop id=\"stop7\" stop-color=\"#3771c8\" offset=\"0\"/>\n                <stop id=\"stop9\" stop-color=\"#3771c8\" offset=\".128\"/>\n                <stop id=\"stop11\" stop-color=\"#60f\" stop-opacity=\"0\" offset=\"1\"/>\n            </radialGradient>\n        </defs>\n        */}\n        <defs >\n            <linearGradient id=\"instaGradient\" x2=\"0.6667\" y1=\"0.2667\" x1=\"0.4167\" y2=\"0.75\">\n                <stop stopColor=\"#ff00cc\"  offset=\"0\"/>\n                <stop stopColor=\"#00ccff\"  offset=\"1\"/>\n            </linearGradient>\n        </defs>\n        <path id=\"path24\" transform=\"translate(1 1)\" d=\"m65 0c-27.1 0-35 0.028-36.6 0.156-5.57 0.463-9.04 1.34-12.8 3.22-2.91 1.44-5.2 3.12-7.47 5.47-4.1 4.25-6.6 9.55-7.5 15.8-0.44 3.04-0.568 3.66-0.594 19.2-0.01 5.18 0 12 0 21.1 0 27.1 0.03 35 0.16 36.6 0.45 5.42 1.3 8.83 3.1 12.6 3.44 7.14 10 12.5 17.8 14.5 2.68 0.69 5.64 1.07 9.44 1.25 1.61 0.07 18 0.12 34.4 0.12s32.8-0.02 34.4-0.1c4.4-0.207 6.96-0.55 9.78-1.28 7.79-2.01 14.2-7.29 17.8-14.5 1.76-3.64 2.66-7.18 3.06-12.3 0.088-1.12 0.125-19 0.125-36.8s-0.04-35.7-0.128-36.8c-0.41-5.22-1.3-8.73-3.13-12.4-1.5-3.04-3.16-5.3-5.56-7.62-4-4.2-9-6.7-16-7.6-3-0.443-3-0.573-18.8-0.6h-21.2z\" fill=\"url(#instaGraient)\"/>{/*original fill url(#c)*/}\n        <path id=\"path26\" transform=\"translate(1 1)\" d=\"m65 0c-27.1 0-35 0.028-36.6 0.156-5.57 0.463-9.04 1.34-12.8 3.22-2.91 1.44-5.2 3.12-7.47 5.47-4.1 4.25-6.6 9.55-7.5 15.8-0.44 3.04-0.568 3.66-0.594 19.2-0.01 5.18 0 12 0 21.1 0 27.1 0.03 35 0.16 36.6 0.45 5.42 1.3 8.83 3.1 12.6 3.44 7.14 10 12.5 17.8 14.5 2.68 0.69 5.64 1.07 9.44 1.25 1.61 0.07 18 0.12 34.4 0.12s32.8-0.02 34.4-0.1c4.4-0.207 6.96-0.55 9.78-1.28 7.79-2.01 14.2-7.29 17.8-14.5 1.76-3.64 2.66-7.18 3.06-12.3 0.088-1.12 0.125-19 0.125-36.8s-0.04-35.7-0.128-36.8c-0.41-5.22-1.3-8.73-3.13-12.4-1.5-3.04-3.16-5.3-5.56-7.62-4-4.2-9-6.7-16-7.6-3-0.443-3-0.573-18.8-0.6h-21.2z\" fill=\"url(#instaGradient)\"/>{/*original fill url(#d)*/}\n        <path id=\"path28\" d=\"m66 18c-13 0-14.7 0.057-19.8 0.29-5.11 0.234-8.6 1.04-11.6 2.23-3.16 1.23-5.84 2.87-8.5 5.54-2.67 2.67-4.31 5.35-5.54 8.5-1.19 3.05-2 6.54-2.23 11.6-0.3 5.1-0.4 6.8-0.4 19.8s0.058 14.7 0.29 19.8c0.235 5.11 1.04 8.6 2.23 11.6 1.23 3.16 2.87 5.84 5.54 8.5 2.67 2.67 5.34 4.31 8.5 5.54 3.05 1.19 6.54 2 11.7 2.23 5.12 0.233 6.76 0.29 19.8 0.29s14.7-0.057 19.8-0.29c5.11-0.234 8.6-1.04 11.7-2.23 3.16-1.23 5.83-2.87 8.5-5.54s4.31-5.35 5.54-8.5c1.18-3.05 1.99-6.54 2.23-11.6 0.23-5.12 0.29-6.75 0.29-19.8s-0.06-14.7-0.29-19.8c-0.24-5.11-1.05-8.6-2.23-11.6-1.23-3.16-2.87-5.84-5.54-8.5-2.67-2.67-5.34-4.31-8.5-5.54-3.06-1.19-6.55-2-11.7-2.23-5.12-0.233-6.75-0.29-19.8-0.29zm-4.31 8.65c1.28-0.002 2.7 0 4.31 0 12.8 0 14.3 0.046 19.4 0.276 4.68 0.214 7.22 0.996 8.91 1.65 2.24 0.87 3.84 1.91 5.52 3.59s2.72 3.28 3.59 5.52c0.657 1.69 1.44 4.23 1.65 8.91 0.23 5.06 0.28 6.58 0.28 19.4s-0.05 14.3-0.28 19.4c-0.214 4.68-0.996 7.22-1.65 8.91-0.87 2.24-1.91 3.84-3.59 5.51-1.68 1.68-3.28 2.72-5.52 3.59-1.69 0.66-4.23 1.44-8.91 1.65-5.06 0.23-6.58 0.28-19.4 0.28s-14.3-0.05-19.4-0.28c-4.68-0.216-7.22-0.998-8.91-1.66-2.24-0.87-3.84-1.91-5.52-3.59s-2.72-3.28-3.59-5.52c-0.657-1.69-1.44-4.23-1.65-8.91-0.23-5.06-0.276-6.58-0.276-19.4s0.046-14.3 0.276-19.4c0.214-4.68 0.996-7.22 1.65-8.91 0.87-2.24 1.91-3.84 3.59-5.52s3.28-2.72 5.52-3.59c1.69-0.66 4.23-1.44 8.91-1.66 4.43-0.2 6.14-0.26 15.1-0.27zm29.9 7.97c-3.18 0-5.76 2.58-5.76 5.76s2.58 5.76 5.76 5.76 5.76-2.58 5.76-5.76-2.58-5.76-5.76-5.76zm-25.6 6.73c-13.6 0-24.6 11-24.6 24.6s11 24.6 24.6 24.6c13.6 0.1 24.6-10.9 24.6-24.5s-11-24.6-24.6-24.6zm0 8.65c8.84 0 16 7.16 16 16s-7.16 16-16 16-16-7.16-16-16 7.16-16 16-16z\" />{/*original fill: white*/}\n    </svg>\n);\n\nexport default Instagram;\n","import React from 'react';\nimport styles from './social.module.css';\n\nconst Facebook = () => (\n    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" className={styles.facebook}>\n      <defs >\n          <linearGradient id=\"fbGradient\" x2=\"0.6667\" y1=\"0.2667\" x1=\"0.4167\" y2=\"0.75\">\n              <stop stopColor=\"#ff00cc\"  offset=\"0\"/>\n              <stop stopColor=\"#00ccff\"  offset=\"1\"/>\n          </linearGradient>\n      </defs>\n        <g id=\"Symbols\" stroke=\"none\" stroke-width=\"1\" fill=\"none\" fill-rule=\"evenodd\">\n            <g fill=\"url(#fbGradient)\" id=\"Footer,-Hover\" transform=\"translate(-1278.000000, -89.000000)\" >{/* original fill color: #214cbd*/}\n                <path d=\"M1278.66667,89 C1278.29778,89 1278,89.2977778 1278,89.6666667 L1278,104.333333 C1278,104.702222 1278.29778,105 1278.66667,105 L1286.5,105 L1286.5,99 L1284.5,99 L1284.5,96.5 L1286.5,96.5 L1286.5,94.5 C1286.5,92.4333333 1287.80889,91.4155556 1289.65111,91.4155556 C1290.53556,91.4155556 1291.29333,91.4822222 1291.51556,91.5111111 L1291.51556,93.6711111 L1290.23556,93.6711111 C1289.23333,93.6711111 1289,94.1488889 1289,94.8466667 L1289,96.5 L1291.5,96.5 L1291,99 L1289,99 L1289.04,105 L1293.33333,105 C1293.70222,105 1294,104.702222 1294,104.333333 L1294,89.6666667 C1294,89.2977778 1293.70222,89 1293.33333,89 L1278.66667,89 Z\" id=\"facebook\"></path>\n            </g>\n        </g>\n    </svg>\n);\n\nexport default Facebook;\n","import React from 'react';\nimport styles from './social.module.css';\n\nconst Discourse = () => (\n    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 308 311\" className={styles.discourse}>\n    <defs >\n        <linearGradient id=\"discourseGradient\" x2=\"0.6667\" y1=\"0.2667\" x1=\"0.4167\" y2=\"0.75\">\n            <stop stopColor=\"#ff00cc\"  offset=\"0\"/>\n            <stop stopColor=\"#00ccff\"  offset=\"1\"/>\n        </linearGradient>\n    </defs>\n        <g id=\"g8\" fill=\"none\">\n            <path id=\"path10\" d=\"m155 0c-84 0-155 68.4-155 153v158h155c85 0 153-71 153-156 0-83.9-68-155-153-155z\" fill=\"url(#discourseGradient)\"/>{/*original fill=\"#000000\"*/}\n            <path id=\"path12\" d=\"m75 105c-17.1 28.5-17.8 63.9-1.92 93.1l-17.1 55 61-14c35.2 15.8 76.5 8.7 104-17.9 27.9-26.6 36.7-67.5 22.3-103-13-35.6-48-59-87-59-33 0-63.9 17.5-81 46z\" fill=\"#f2e88f\"/>{/*original fill=\"#f2e88f\"*/}\n            <path id=\"path14\" d=\"m230 213c-26.9 33.8-73.3 45.2-113 27.5l-61 14 62.6-7.38c41.5 24.3 94.6 13.6 123-24.8 29-38 24-92-11-125 26.2 34.3 25.8 82.1-1.09 116z\" fill=\"#00aeef\"/>{/*original fill=\"#00aeef\"*/}\n            <path id=\"path16\" d=\"m225 195c-23.2 36.7-68.2 52.9-109 39.4l-60 21 61-14c43.8 19.9 95.4 3.6 120-37.8 25-41 15-95-23-124 29.7 31.6 34.2 79.4 11 116z\" fill=\"#00953a\"/>{/*original fill=\"#00953a\"*/}\n            <path id=\"path18\" d=\"m79 201c-17.3-42-3.1-90 34-115 37-25.5 87-21.5 120 9.5-30-39.6-86-49.2-128-22.2-41.8 26.7-55.6 81.7-31.7 126l-17.3 55 23-53z\" fill=\"#e63c2f\"/>{/*original fill=\"#e63c2f\"*/}\n            <path id=\"path20\" d=\"m73.2 201c-21.1-40-12-89 21.7-118 34.1-29.4 83.1-30.7 118-3.3-34-36.1-89-39.7-127-8.5-38.2 30.8-46.2 86.8-18.6 128l-11.1 57 16.9-55z\" fill=\"#d13239\"/>{/*original fill=\"#d13239\"*/}\n        </g>\n    </svg>\n);\n\nexport default Discourse;\n","import React from 'react';\nimport MeetupLarge from '../../static/media/Meetup_Large_white.svg';\nimport styles from './sticky.module.css';\n\nconst Sticky = () => (\n    <a href=\"https://www.meetup.com/BiopunX\" target=\"_blank\" className={styles.sticky}><img src={MeetupLarge}/></a>\n);\n\nexport default Sticky;\n","import React from 'react';\n\nimport styles from './button.module.css';\n\nconst Button = ( props ) => (\n    <a href={props.url} target=\"_blank\" className={styles.button}> {props.label} </a>\n);\n\nexport default Button;\n","import React from 'react';\nimport { graphql } from 'gatsby';\nimport ReactMarkdown from 'react-markdown';\nimport Layout from '../layouts/Layout';\nimport Instagram from '../components/social/Instagram';\nimport Facebook from '../components/social/Facebook';\nimport Discourse from '../components/social/Discourse';\nimport Logo from '../../static/media/biopunkkitchen-noBg-centered.svg';\nimport Hero from '../components/Hero';\nimport Sticky from '../components/Sticky';\nimport Button from '../components/Button';\nimport styles from './index.module.css';\n\n\n\nconst Link = ( props ) => {\n    return (\n        props.button && <Button label={props.label} url={props.url}/>\n\n    );\n    { /* <a href={props.url}>{props.label}</a>-->*/ }\n};\n\n\n\nconst Section = ( props ) => {\n    return ( <section className={styles.section} key={props.index}>\n        <Hero image={props.image} title={props.title} color={props.color} style=\"home\"/>\n        <ReactMarkdown source={props.text}/>\n        { props.button && <Button label={props.link.label}/>}\n        { props.link && <Link button={props.link.button} label={props.link.label} url={props.link.url}/>}\n    </section>\n    );\n};\n\n\n\nexport default ({ data }) => {\n\n    const { tagline, sections } = data.markdownRemark.frontmatter;\n\n    return (\n        <Layout type=\"home\">\n            <section className={styles.topSection}>\n                <img src={Logo} />\n                <p>{tagline}</p>\n                <div className={styles.social}>\n                    <a href=\"https://www.instagram.com/biopunx\" target=\"_blank\"><Instagram/></a>\n                    <a href=\"https://www.facebook.com/biopunx\" target=\"_blank\"><Facebook/></a>\n                    <a href=\"https://forum.wilap.de/c/kitchen\" target=\"_blank\"><Discourse/></a>\n                </div>\n                <Sticky/>\n            </section>\n\n            { sections.map(( section, index ) => (\n                <Section\n                    index={index}\n                    title={section.title}\n                    color={section.color}\n                    image={section.image}\n                    text={section.text}\n                    link={section.link}/>\n            ))}\n\n        </Layout>\n    );\n\n};\n\nexport const indeQuery = graphql`\n  query indeQuery ($path: String!) {\n    markdownRemark(fields: { slug: { eq: $path } }) {\n      frontmatter {\n        title\n        tagline\n        sections {\n          title\n          image\n          text\n          link {\n            label\n            url\n            button\n          }\n          color\n        }\n      }\n      html\n    }\n   }\n`;\n","/*!\n * repeat-string <https://github.com/jonschlinkert/repeat-string>\n *\n * Copyright (c) 2014-2015, Jon Schlinkert.\n * Licensed under the MIT License.\n */\n'use strict';\n/**\n * Results cache\n */\n\nvar res = '';\nvar cache;\n/**\n * Expose `repeat`\n */\n\nmodule.exports = repeat;\n/**\n * Repeat the given `string` the specified `number`\n * of times.\n *\n * **Example:**\n *\n * ```js\n * var repeat = require('repeat-string');\n * repeat('A', 5);\n * //=> AAAAA\n * ```\n *\n * @param {String} `string` The string to repeat\n * @param {Number} `number` The number of times to repeat the string\n * @return {String} Repeated string\n * @api public\n */\n\nfunction repeat(str, num) {\n  if (typeof str !== 'string') {\n    throw new TypeError('expected a string');\n  } // cover common, quick use cases\n\n\n  if (num === 1) return str;\n  if (num === 2) return str + str;\n  var max = str.length * num;\n\n  if (cache !== str || typeof cache === 'undefined') {\n    cache = str;\n    res = '';\n  } else if (res.length >= max) {\n    return res.substr(0, max);\n  }\n\n  while (max > res.length && num > 1) {\n    if (num & 1) {\n      res += str;\n    }\n\n    num >>= 1;\n    str += str;\n  }\n\n  res += str;\n  res = res.substr(0, max);\n  return res;\n}","exports = module.exports = trim;\n\nfunction trim(str) {\n  return str.replace(/^\\s*|\\s*$/g, '');\n}\n\nexports.left = function (str) {\n  return str.replace(/^\\s*/, '');\n};\n\nexports.right = function (str) {\n  return str.replace(/\\s*$/, '');\n};","'use strict';\n\nmodule.exports = text;\n\nfunction text(eat, value, silent) {\n  var self = this;\n  var methods;\n  var tokenizers;\n  var index;\n  var length;\n  var subvalue;\n  var position;\n  var tokenizer;\n  var name;\n  var min;\n  var now;\n  /* istanbul ignore if - never used (yet) */\n\n  if (silent) {\n    return true;\n  }\n\n  methods = self.inlineMethods;\n  length = methods.length;\n  tokenizers = self.inlineTokenizers;\n  index = -1;\n  min = value.length;\n\n  while (++index < length) {\n    name = methods[index];\n\n    if (name === 'text' || !tokenizers[name]) {\n      continue;\n    }\n\n    tokenizer = tokenizers[name].locator;\n\n    if (!tokenizer) {\n      eat.file.fail('Missing locator: `' + name + '`');\n    }\n\n    position = tokenizer.call(self, value, 1);\n\n    if (position !== -1 && position < min) {\n      min = position;\n    }\n  }\n\n  subvalue = value.slice(0, min);\n  now = eat.now();\n  self.decode(subvalue, now, function (content, position, source) {\n    eat(source || content)({\n      type: 'text',\n      value: content\n    });\n  });\n}","'use strict';\n\nvar attributeName = '[a-zA-Z_:][a-zA-Z0-9:._-]*';\nvar unquoted = \"[^\\\"'=<>`\\\\u0000-\\\\u0020]+\";\nvar singleQuoted = '\\'[^\\']*\\'';\nvar doubleQuoted = '\"[^\"]*\"';\nvar attributeValue = '(?:' + unquoted + '|' + singleQuoted + '|' + doubleQuoted + ')';\nvar attribute = '(?:\\\\s+' + attributeName + '(?:\\\\s*=\\\\s*' + attributeValue + ')?)';\nvar openTag = '<[A-Za-z][A-Za-z0-9\\\\-]*' + attribute + '*\\\\s*\\\\/?>';\nvar closeTag = '<\\\\/[A-Za-z][A-Za-z0-9\\\\-]*\\\\s*>';\nvar comment = '<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->';\nvar processing = '<[?].*?[?]>';\nvar declaration = '<![A-Za-z]+\\\\s+[^>]*>';\nvar cdata = '<!\\\\[CDATA\\\\[[\\\\s\\\\S]*?\\\\]\\\\]>';\nexports.openCloseTag = new RegExp('^(?:' + openTag + '|' + closeTag + ')');\nexports.tag = new RegExp('^(?:' + openTag + '|' + closeTag + '|' + comment + '|' + processing + '|' + declaration + '|' + cdata + ')');","module.exports = extend;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction extend() {\n  var target = {};\n\n  for (var i = 0; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n}","'use strict';\n\nvar decode = require('parse-entities');\n\nvar whitespace = require('is-whitespace-character');\n\nvar locate = require('../locate/url');\n\nmodule.exports = url;\nurl.locator = locate;\nurl.notInLink = true;\nvar C_BRACKET_OPEN = '[';\nvar C_BRACKET_CLOSE = ']';\nvar C_PAREN_OPEN = '(';\nvar C_PAREN_CLOSE = ')';\nvar C_LT = '<';\nvar C_AT_SIGN = '@';\nvar HTTP_PROTOCOL = 'http://';\nvar HTTPS_PROTOCOL = 'https://';\nvar MAILTO_PROTOCOL = 'mailto:';\nvar PROTOCOLS = [HTTP_PROTOCOL, HTTPS_PROTOCOL, MAILTO_PROTOCOL];\nvar PROTOCOLS_LENGTH = PROTOCOLS.length;\n\nfunction url(eat, value, silent) {\n  var self = this;\n  var subvalue;\n  var content;\n  var character;\n  var index;\n  var position;\n  var protocol;\n  var match;\n  var length;\n  var queue;\n  var parenCount;\n  var nextCharacter;\n  var exit;\n\n  if (!self.options.gfm) {\n    return;\n  }\n\n  subvalue = '';\n  index = -1;\n  length = PROTOCOLS_LENGTH;\n\n  while (++index < length) {\n    protocol = PROTOCOLS[index];\n    match = value.slice(0, protocol.length);\n\n    if (match.toLowerCase() === protocol) {\n      subvalue = match;\n      break;\n    }\n  }\n\n  if (!subvalue) {\n    return;\n  }\n\n  index = subvalue.length;\n  length = value.length;\n  queue = '';\n  parenCount = 0;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (whitespace(character) || character === C_LT) {\n      break;\n    }\n\n    if (character === '.' || character === ',' || character === ':' || character === ';' || character === '\"' || character === '\\'' || character === ')' || character === ']') {\n      nextCharacter = value.charAt(index + 1);\n\n      if (!nextCharacter || whitespace(nextCharacter)) {\n        break;\n      }\n    }\n\n    if (character === C_PAREN_OPEN || character === C_BRACKET_OPEN) {\n      parenCount++;\n    }\n\n    if (character === C_PAREN_CLOSE || character === C_BRACKET_CLOSE) {\n      parenCount--;\n\n      if (parenCount < 0) {\n        break;\n      }\n    }\n\n    queue += character;\n    index++;\n  }\n\n  if (!queue) {\n    return;\n  }\n\n  subvalue += queue;\n  content = subvalue;\n\n  if (protocol === MAILTO_PROTOCOL) {\n    position = queue.indexOf(C_AT_SIGN);\n\n    if (position === -1 || position === length - 1) {\n      return;\n    }\n\n    content = content.substr(MAILTO_PROTOCOL.length);\n  }\n  /* istanbul ignore if - never used (yet) */\n\n\n  if (silent) {\n    return true;\n  }\n\n  exit = self.enterLink();\n  content = self.tokenizeInline(content, eat.now());\n  exit();\n  return eat(subvalue)({\n    type: 'link',\n    title: null,\n    url: decode(subvalue, {\n      nonTerminated: false\n    }),\n    children: content\n  });\n}","'use strict';\n\nvar whitespace = require('is-whitespace-character');\n\nvar locate = require('../locate/delete');\n\nmodule.exports = strikethrough;\nstrikethrough.locator = locate;\nvar C_TILDE = '~';\nvar DOUBLE = '~~';\n\nfunction strikethrough(eat, value, silent) {\n  var self = this;\n  var character = '';\n  var previous = '';\n  var preceding = '';\n  var subvalue = '';\n  var index;\n  var length;\n  var now;\n\n  if (!self.options.gfm || value.charAt(0) !== C_TILDE || value.charAt(1) !== C_TILDE || whitespace(value.charAt(2))) {\n    return;\n  }\n\n  index = 1;\n  length = value.length;\n  now = eat.now();\n  now.column += 2;\n  now.offset += 2;\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character === C_TILDE && previous === C_TILDE && (!preceding || !whitespace(preceding))) {\n      /* istanbul ignore if - never used (yet) */\n      if (silent) {\n        return true;\n      }\n\n      return eat(DOUBLE + subvalue + DOUBLE)({\n        type: 'delete',\n        children: self.tokenizeInline(subvalue, now)\n      });\n    }\n\n    subvalue += previous;\n    preceding = previous;\n    previous = character;\n  }\n}","'use strict';\n\nrequire(\"core-js/modules/es.array.reduce.js\");\n\nvar React = require('react');\n\nvar xtend = require('xtend');\n\nfunction astToReact(node, options) {\n  var parent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;\n  var renderer = options.renderers[node.type];\n  var pos = node.position.start;\n  var key = [node.type, pos.line, pos.column].join('-');\n\n  if (typeof renderer !== 'function' && typeof renderer !== 'string' && !isReactFragment(renderer)) {\n    throw new Error(\"Renderer for type `\".concat(node.type, \"` not defined or is not renderable\"));\n  }\n\n  var nodeProps = getNodeProps(node, key, options, renderer, parent, index);\n  return React.createElement(renderer, nodeProps, nodeProps.children || resolveChildren() || undefined);\n\n  function resolveChildren() {\n    return node.children && node.children.map(function (childNode, i) {\n      return astToReact(childNode, options, {\n        node: node,\n        props: nodeProps\n      }, i);\n    });\n  }\n}\n\nfunction isReactFragment(renderer) {\n  return React.Fragment && React.Fragment === renderer;\n} // eslint-disable-next-line max-params, complexity\n\n\nfunction getNodeProps(node, key, opts, renderer, parent, index) {\n  var props = {\n    key: key\n  };\n  var isTagRenderer = typeof renderer === 'string'; // `sourcePos` is true if the user wants source information (line/column info from markdown source)\n\n  if (opts.sourcePos && node.position) {\n    props['data-sourcepos'] = flattenPosition(node.position);\n  }\n\n  if (opts.rawSourcePos && !isTagRenderer) {\n    props.sourcePosition = node.position;\n  } // If `includeNodeIndex` is true, pass node index info to all non-tag renderers\n\n\n  if (opts.includeNodeIndex && parent.node && parent.node.children && !isTagRenderer) {\n    props.index = parent.node.children.indexOf(node);\n    props.parentChildCount = parent.node.children.length;\n  }\n\n  var ref = node.identifier !== null && node.identifier !== undefined ? opts.definitions[node.identifier] || {} : null;\n\n  switch (node.type) {\n    case 'root':\n      assignDefined(props, {\n        className: opts.className\n      });\n      break;\n\n    case 'text':\n      props.nodeKey = key;\n      props.children = node.value;\n      break;\n\n    case 'heading':\n      props.level = node.depth;\n      break;\n\n    case 'list':\n      props.start = node.start;\n      props.ordered = node.ordered;\n      props.tight = !node.loose;\n      props.depth = node.depth;\n      break;\n\n    case 'listItem':\n      props.checked = node.checked;\n      props.tight = !node.loose;\n      props.ordered = node.ordered;\n      props.index = node.index;\n      props.children = getListItemChildren(node, parent).map(function (childNode, i) {\n        return astToReact(childNode, opts, {\n          node: node,\n          props: props\n        }, i);\n      });\n      break;\n\n    case 'definition':\n      assignDefined(props, {\n        identifier: node.identifier,\n        title: node.title,\n        url: node.url\n      });\n      break;\n\n    case 'code':\n      assignDefined(props, {\n        language: node.lang && node.lang.split(/\\s/, 1)[0]\n      });\n      break;\n\n    case 'inlineCode':\n      props.children = node.value;\n      props.inline = true;\n      break;\n\n    case 'link':\n      assignDefined(props, {\n        title: node.title || undefined,\n        target: typeof opts.linkTarget === 'function' ? opts.linkTarget(node.url, node.children, node.title) : opts.linkTarget,\n        href: opts.transformLinkUri ? opts.transformLinkUri(node.url, node.children, node.title) : node.url\n      });\n      break;\n\n    case 'image':\n      assignDefined(props, {\n        alt: node.alt || undefined,\n        title: node.title || undefined,\n        src: opts.transformImageUri ? opts.transformImageUri(node.url, node.children, node.title, node.alt) : node.url\n      });\n      break;\n\n    case 'linkReference':\n      assignDefined(props, xtend(ref, {\n        href: opts.transformLinkUri ? opts.transformLinkUri(ref.href) : ref.href\n      }));\n      break;\n\n    case 'imageReference':\n      assignDefined(props, {\n        src: opts.transformImageUri && ref.href ? opts.transformImageUri(ref.href, node.children, ref.title, node.alt) : ref.href,\n        title: ref.title || undefined,\n        alt: node.alt || undefined\n      });\n      break;\n\n    case 'table':\n    case 'tableHead':\n    case 'tableBody':\n      props.columnAlignment = node.align;\n      break;\n\n    case 'tableRow':\n      props.isHeader = parent.node.type === 'tableHead';\n      props.columnAlignment = parent.props.columnAlignment;\n      break;\n\n    case 'tableCell':\n      assignDefined(props, {\n        isHeader: parent.props.isHeader,\n        align: parent.props.columnAlignment[index]\n      });\n      break;\n\n    case 'virtualHtml':\n      props.tag = node.tag;\n      break;\n\n    case 'html':\n      // @todo find a better way than this\n      props.isBlock = node.position.start.line !== node.position.end.line;\n      props.escapeHtml = opts.escapeHtml;\n      props.skipHtml = opts.skipHtml;\n      break;\n\n    case 'parsedHtml':\n      props.escapeHtml = opts.escapeHtml;\n      props.skipHtml = opts.skipHtml;\n      props.element = mergeNodeChildren(node, (node.children || []).map(function (child, i) {\n        return astToReact(child, opts, {\n          node: node,\n          props: props\n        }, i);\n      }));\n      break;\n\n    default:\n      assignDefined(props, xtend(node, {\n        type: undefined,\n        position: undefined,\n        children: undefined\n      }));\n  }\n\n  if (!isTagRenderer && node.value) {\n    props.value = node.value;\n  }\n\n  return props;\n}\n\nfunction assignDefined(target, attrs) {\n  for (var key in attrs) {\n    if (typeof attrs[key] !== 'undefined') {\n      target[key] = attrs[key];\n    }\n  }\n}\n\nfunction mergeNodeChildren(node, parsedChildren) {\n  var el = node.element;\n\n  if (Array.isArray(el)) {\n    var Fragment = React.Fragment || 'div';\n    return React.createElement(Fragment, null, el);\n  }\n\n  var children = (el.props.children || []).concat(parsedChildren);\n  return React.cloneElement(el, null, children);\n}\n\nfunction flattenPosition(pos) {\n  return [pos.start.line, ':', pos.start.column, '-', pos.end.line, ':', pos.end.column].map(String).join('');\n}\n\nfunction getListItemChildren(node, parent) {\n  if (node.loose) {\n    return node.children;\n  }\n\n  if (parent.node && node.index > 0 && parent.node.children[node.index - 1].loose) {\n    return node.children;\n  }\n\n  return unwrapParagraphs(node);\n}\n\nfunction unwrapParagraphs(node) {\n  return node.children.reduce(function (array, child) {\n    return array.concat(child.type === 'paragraph' ? child.children || [] : [child]);\n  }, []);\n}\n\nmodule.exports = astToReact;","'use strict';\n/* Expose. */\n\nmodule.exports = visitParents;\n/* Visit. */\n\nfunction visitParents(tree, type, visitor) {\n  var stack = [];\n\n  if (typeof type === 'function') {\n    visitor = type;\n    type = null;\n  }\n\n  one(tree);\n  /* Visit a single node. */\n\n  function one(node) {\n    var result;\n\n    if (!type || node.type === type) {\n      result = visitor(node, stack.concat());\n    }\n\n    if (node.children && result !== false) {\n      return all(node.children, node);\n    }\n\n    return result;\n  }\n  /* Visit children in `parent`. */\n\n\n  function all(children, parent) {\n    var length = children.length;\n    var index = -1;\n    var child;\n    stack.push(parent);\n\n    while (++index < length) {\n      child = children[index];\n\n      if (child && one(child) === false) {\n        return false;\n      }\n    }\n\n    stack.pop();\n    return true;\n  }\n}","'use strict';\n\nvar alphabetical = require('is-alphabetical');\n\nvar locate = require('../locate/tag');\n\nvar tag = require('../util/html').tag;\n\nmodule.exports = inlineHTML;\ninlineHTML.locator = locate;\nvar EXPRESSION_HTML_LINK_OPEN = /^<a /i;\nvar EXPRESSION_HTML_LINK_CLOSE = /^<\\/a>/i;\n\nfunction inlineHTML(eat, value, silent) {\n  var self = this;\n  var length = value.length;\n  var character;\n  var subvalue;\n\n  if (value.charAt(0) !== '<' || length < 3) {\n    return;\n  }\n\n  character = value.charAt(1);\n\n  if (!alphabetical(character) && character !== '?' && character !== '!' && character !== '/') {\n    return;\n  }\n\n  subvalue = value.match(tag);\n\n  if (!subvalue) {\n    return;\n  }\n  /* istanbul ignore if - not used yet. */\n\n\n  if (silent) {\n    return true;\n  }\n\n  subvalue = subvalue[0];\n\n  if (!self.inLink && EXPRESSION_HTML_LINK_OPEN.test(subvalue)) {\n    self.inLink = true;\n  } else if (self.inLink && EXPRESSION_HTML_LINK_CLOSE.test(subvalue)) {\n    self.inLink = false;\n  }\n\n  return eat(subvalue)({\n    type: 'html',\n    value: subvalue\n  });\n}","'use strict';\n\nmodule.exports = locate;\nvar PROTOCOLS = ['https://', 'http://', 'mailto:'];\n\nfunction locate(value, fromIndex) {\n  var length = PROTOCOLS.length;\n  var index = -1;\n  var min = -1;\n  var position;\n\n  if (!this.options.gfm) {\n    return -1;\n  }\n\n  while (++index < length) {\n    position = value.indexOf(PROTOCOLS[index], fromIndex);\n\n    if (position !== -1 && (position < min || min === -1)) {\n      min = position;\n    }\n  }\n\n  return min;\n}","'use strict';\n/* eslint-env browser */\n\nvar el;\nmodule.exports = decodeEntity;\n\nfunction decodeEntity(characters) {\n  var entity = '&' + characters + ';';\n  var char;\n  el = el || document.createElement('i');\n  el.innerHTML = entity;\n  char = el.textContent; // Some entities do not require the closing semicolon (&not - for instance),\n  // which leads to situations where parsing the assumed entity of &notit; will\n  // result in the string `¬it;`.  When we encounter a trailing semicolon after\n  // parsing and the entity to decode was not a semicolon (&semi;), we can\n  // assume that the matching was incomplete\n\n  if (char.slice(-1) === ';' && characters !== 'semi') {\n    return false;\n  } // If the decoded string is equal to the input, the entity was not valid\n\n\n  return char === entity ? false : char;\n}","'use strict';\n\nvar openCloseTag = require('../util/html').openCloseTag;\n\nmodule.exports = blockHTML;\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_NEWLINE = '\\n';\nvar C_LT = '<';\n\nfunction blockHTML(eat, value, silent) {\n  var self = this;\n  var blocks = self.options.blocks;\n  var length = value.length;\n  var index = 0;\n  var next;\n  var line;\n  var offset;\n  var character;\n  var count;\n  var sequence;\n  var subvalue;\n  var sequences = [[/^<(script|pre|style)(?=(\\s|>|$))/i, /<\\/(script|pre|style)>/i, true], [/^<!--/, /-->/, true], [/^<\\?/, /\\?>/, true], [/^<![A-Za-z]/, />/, true], [/^<!\\[CDATA\\[/, /\\]\\]>/, true], [new RegExp('^</?(' + blocks.join('|') + ')(?=(\\\\s|/?>|$))', 'i'), /^$/, true], [new RegExp(openCloseTag.source + '\\\\s*$'), /^$/, false]];\n  /* Eat initial spacing. */\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_TAB && character !== C_SPACE) {\n      break;\n    }\n\n    index++;\n  }\n\n  if (value.charAt(index) !== C_LT) {\n    return;\n  }\n\n  next = value.indexOf(C_NEWLINE, index + 1);\n  next = next === -1 ? length : next;\n  line = value.slice(index, next);\n  offset = -1;\n  count = sequences.length;\n\n  while (++offset < count) {\n    if (sequences[offset][0].test(line)) {\n      sequence = sequences[offset];\n      break;\n    }\n  }\n\n  if (!sequence) {\n    return;\n  }\n\n  if (silent) {\n    return sequence[2];\n  }\n\n  index = next;\n\n  if (!sequence[1].test(line)) {\n    while (index < length) {\n      next = value.indexOf(C_NEWLINE, index + 1);\n      next = next === -1 ? length : next;\n      line = value.slice(index + 1, next);\n\n      if (sequence[1].test(line)) {\n        if (line) {\n          index = next;\n        }\n\n        break;\n      }\n\n      index = next;\n    }\n  }\n\n  subvalue = value.slice(0, index);\n  return eat(subvalue)({\n    type: 'html',\n    value: subvalue\n  });\n}","'use strict';\n\nmodule.exports = decimal;\n/* Check if the given character code, or the character\n * code at the first character, is decimal. */\n\nfunction decimal(character) {\n  var code = typeof character === 'string' ? character.charCodeAt(0) : character;\n  return code >= 48 && code <= 57;\n  /* 0-9 */\n}","'use strict';\n\nvar legacy = require('character-entities-legacy');\n\nvar invalid = require('character-reference-invalid');\n\nvar decimal = require('is-decimal');\n\nvar hexadecimal = require('is-hexadecimal');\n\nvar alphanumerical = require('is-alphanumerical');\n\nvar decodeEntity = require('./decode-entity');\n\nmodule.exports = parseEntities;\nvar own = {}.hasOwnProperty;\nvar fromCharCode = String.fromCharCode;\nvar noop = Function.prototype;\n/* Default settings. */\n\nvar defaults = {\n  warning: null,\n  reference: null,\n  text: null,\n  warningContext: null,\n  referenceContext: null,\n  textContext: null,\n  position: {},\n  additional: null,\n  attribute: false,\n  nonTerminated: true\n};\n/* Reference types. */\n\nvar NAMED = 'named';\nvar HEXADECIMAL = 'hexadecimal';\nvar DECIMAL = 'decimal';\n/* Map of bases. */\n\nvar BASE = {};\nBASE[HEXADECIMAL] = 16;\nBASE[DECIMAL] = 10;\n/* Map of types to tests. Each type of character reference\n * accepts different characters. This test is used to\n * detect whether a reference has ended (as the semicolon\n * is not strictly needed). */\n\nvar TESTS = {};\nTESTS[NAMED] = alphanumerical;\nTESTS[DECIMAL] = decimal;\nTESTS[HEXADECIMAL] = hexadecimal;\n/* Warning messages. */\n\nvar NAMED_NOT_TERMINATED = 1;\nvar NUMERIC_NOT_TERMINATED = 2;\nvar NAMED_EMPTY = 3;\nvar NUMERIC_EMPTY = 4;\nvar NAMED_UNKNOWN = 5;\nvar NUMERIC_DISALLOWED = 6;\nvar NUMERIC_PROHIBITED = 7;\nvar MESSAGES = {};\nMESSAGES[NAMED_NOT_TERMINATED] = 'Named character references must be terminated by a semicolon';\nMESSAGES[NUMERIC_NOT_TERMINATED] = 'Numeric character references must be terminated by a semicolon';\nMESSAGES[NAMED_EMPTY] = 'Named character references cannot be empty';\nMESSAGES[NUMERIC_EMPTY] = 'Numeric character references cannot be empty';\nMESSAGES[NAMED_UNKNOWN] = 'Named character references must be known';\nMESSAGES[NUMERIC_DISALLOWED] = 'Numeric character references cannot be disallowed';\nMESSAGES[NUMERIC_PROHIBITED] = 'Numeric character references cannot be outside the permissible Unicode range';\n/* Wrap to ensure clean parameters are given to `parse`. */\n\nfunction parseEntities(value, options) {\n  var settings = {};\n  var option;\n  var key;\n\n  if (!options) {\n    options = {};\n  }\n\n  for (key in defaults) {\n    option = options[key];\n    settings[key] = option === null || option === undefined ? defaults[key] : option;\n  }\n\n  if (settings.position.indent || settings.position.start) {\n    settings.indent = settings.position.indent || [];\n    settings.position = settings.position.start;\n  }\n\n  return parse(value, settings);\n}\n/* Parse entities. */\n\n\nfunction parse(value, settings) {\n  var additional = settings.additional;\n  var nonTerminated = settings.nonTerminated;\n  var handleText = settings.text;\n  var handleReference = settings.reference;\n  var handleWarning = settings.warning;\n  var textContext = settings.textContext;\n  var referenceContext = settings.referenceContext;\n  var warningContext = settings.warningContext;\n  var pos = settings.position;\n  var indent = settings.indent || [];\n  var length = value.length;\n  var index = 0;\n  var lines = -1;\n  var column = pos.column || 1;\n  var line = pos.line || 1;\n  var queue = '';\n  var result = [];\n  var entityCharacters;\n  var namedEntity;\n  var terminated;\n  var characters;\n  var character;\n  var reference;\n  var following;\n  var warning;\n  var reason;\n  var output;\n  var entity;\n  var begin;\n  var start;\n  var type;\n  var test;\n  var prev;\n  var next;\n  var diff;\n  var end;\n  /* Cache the current point. */\n\n  prev = now();\n  /* Wrap `handleWarning`. */\n\n  warning = handleWarning ? parseError : noop;\n  /* Ensure the algorithm walks over the first character\n   * and the end (inclusive). */\n\n  index--;\n  length++;\n\n  while (++index < length) {\n    /* If the previous character was a newline. */\n    if (character === '\\n') {\n      column = indent[lines] || 1;\n    }\n\n    character = at(index);\n    /* Handle anything other than an ampersand,\n     * including newlines and EOF. */\n\n    if (character !== '&') {\n      if (character === '\\n') {\n        line++;\n        lines++;\n        column = 0;\n      }\n\n      if (character) {\n        queue += character;\n        column++;\n      } else {\n        flush();\n      }\n    } else {\n      following = at(index + 1);\n      /* The behaviour depends on the identity of the next\n       * character. */\n\n      if (following === '\\t'\n      /* Tab */\n      || following === '\\n'\n      /* Newline */\n      || following === '\\f'\n      /* Form feed */\n      || following === ' '\n      /* Space */\n      || following === '<'\n      /* Less-than */\n      || following === '&'\n      /* Ampersand */\n      || following === '' || additional && following === additional) {\n        /* Not a character reference. No characters\n         * are consumed, and nothing is returned.\n         * This is not an error, either. */\n        queue += character;\n        column++;\n        continue;\n      }\n\n      start = index + 1;\n      begin = start;\n      end = start;\n      /* Numerical entity. */\n\n      if (following !== '#') {\n        type = NAMED;\n      } else {\n        end = ++begin;\n        /* The behaviour further depends on the\n         * character after the U+0023 NUMBER SIGN. */\n\n        following = at(end);\n\n        if (following === 'x' || following === 'X') {\n          /* ASCII hex digits. */\n          type = HEXADECIMAL;\n          end = ++begin;\n        } else {\n          /* ASCII digits. */\n          type = DECIMAL;\n        }\n      }\n\n      entityCharacters = '';\n      entity = '';\n      characters = '';\n      test = TESTS[type];\n      end--;\n\n      while (++end < length) {\n        following = at(end);\n\n        if (!test(following)) {\n          break;\n        }\n\n        characters += following;\n        /* Check if we can match a legacy named\n         * reference.  If so, we cache that as the\n         * last viable named reference.  This\n         * ensures we do not need to walk backwards\n         * later. */\n\n        if (type === NAMED && own.call(legacy, characters)) {\n          entityCharacters = characters;\n          entity = legacy[characters];\n        }\n      }\n\n      terminated = at(end) === ';';\n\n      if (terminated) {\n        end++;\n        namedEntity = type === NAMED ? decodeEntity(characters) : false;\n\n        if (namedEntity) {\n          entityCharacters = characters;\n          entity = namedEntity;\n        }\n      }\n\n      diff = 1 + end - start;\n\n      if (!terminated && !nonTerminated) {\n        /* Empty. */\n      } else if (!characters) {\n        /* An empty (possible) entity is valid, unless\n         * its numeric (thus an ampersand followed by\n         * an octothorp). */\n        if (type !== NAMED) {\n          warning(NUMERIC_EMPTY, diff);\n        }\n      } else if (type === NAMED) {\n        /* An ampersand followed by anything\n         * unknown, and not terminated, is invalid. */\n        if (terminated && !entity) {\n          warning(NAMED_UNKNOWN, 1);\n        } else {\n          /* If theres something after an entity\n           * name which is not known, cap the\n           * reference. */\n          if (entityCharacters !== characters) {\n            end = begin + entityCharacters.length;\n            diff = 1 + end - begin;\n            terminated = false;\n          }\n          /* If the reference is not terminated,\n           * warn. */\n\n\n          if (!terminated) {\n            reason = entityCharacters ? NAMED_NOT_TERMINATED : NAMED_EMPTY;\n\n            if (!settings.attribute) {\n              warning(reason, diff);\n            } else {\n              following = at(end);\n\n              if (following === '=') {\n                warning(reason, diff);\n                entity = null;\n              } else if (alphanumerical(following)) {\n                entity = null;\n              } else {\n                warning(reason, diff);\n              }\n            }\n          }\n        }\n\n        reference = entity;\n      } else {\n        if (!terminated) {\n          /* All non-terminated numeric entities are\n           * not rendered, and trigger a warning. */\n          warning(NUMERIC_NOT_TERMINATED, diff);\n        }\n        /* When terminated and number, parse as\n         * either hexadecimal or decimal. */\n\n\n        reference = parseInt(characters, BASE[type]);\n        /* Trigger a warning when the parsed number\n         * is prohibited, and replace with\n         * replacement character. */\n\n        if (prohibited(reference)) {\n          warning(NUMERIC_PROHIBITED, diff);\n          reference = \"\\uFFFD\";\n        } else if (reference in invalid) {\n          /* Trigger a warning when the parsed number\n           * is disallowed, and replace by an\n           * alternative. */\n          warning(NUMERIC_DISALLOWED, diff);\n          reference = invalid[reference];\n        } else {\n          /* Parse the number. */\n          output = '';\n          /* Trigger a warning when the parsed\n           * number should not be used. */\n\n          if (disallowed(reference)) {\n            warning(NUMERIC_DISALLOWED, diff);\n          }\n          /* Stringify the number. */\n\n\n          if (reference > 0xffff) {\n            reference -= 0x10000;\n            output += fromCharCode(reference >>> (10 & 0x3ff) | 0xd800);\n            reference = 0xdc00 | reference & 0x3ff;\n          }\n\n          reference = output + fromCharCode(reference);\n        }\n      }\n      /* If we could not find a reference, queue the\n       * checked characters (as normal characters),\n       * and move the pointer to their end. This is\n       * possible because we can be certain neither\n       * newlines nor ampersands are included. */\n\n\n      if (!reference) {\n        characters = value.slice(start - 1, end);\n        queue += characters;\n        column += characters.length;\n        index = end - 1;\n      } else {\n        /* Found it! First eat the queued\n         * characters as normal text, then eat\n         * an entity. */\n        flush();\n        prev = now();\n        index = end - 1;\n        column += end - start + 1;\n        result.push(reference);\n        next = now();\n        next.offset++;\n\n        if (handleReference) {\n          handleReference.call(referenceContext, reference, {\n            start: prev,\n            end: next\n          }, value.slice(start - 1, end));\n        }\n\n        prev = next;\n      }\n    }\n  }\n  /* Return the reduced nodes, and any possible warnings. */\n\n\n  return result.join('');\n  /* Get current position. */\n\n  function now() {\n    return {\n      line: line,\n      column: column,\n      offset: index + (pos.offset || 0)\n    };\n  }\n  /* “Throw” a parse-error: a warning. */\n\n\n  function parseError(code, offset) {\n    var position = now();\n    position.column += offset;\n    position.offset += offset;\n    handleWarning.call(warningContext, MESSAGES[code], position, code);\n  }\n  /* Get character at position. */\n\n\n  function at(position) {\n    return value.charAt(position);\n  }\n  /* Flush `queue` (normal text). Macro invoked before\n   * each entity and at the end of `value`.\n   * Does nothing when `queue` is empty. */\n\n\n  function flush() {\n    if (queue) {\n      result.push(queue);\n\n      if (handleText) {\n        handleText.call(textContext, queue, {\n          start: prev,\n          end: now()\n        });\n      }\n\n      queue = '';\n    }\n  }\n}\n/* Check if `character` is outside the permissible unicode range. */\n\n\nfunction prohibited(code) {\n  return code >= 0xd800 && code <= 0xdfff || code > 0x10ffff;\n}\n/* Check if `character` is disallowed. */\n\n\nfunction disallowed(code) {\n  return code >= 0x0001 && code <= 0x0008 || code === 0x000b || code >= 0x000d && code <= 0x001f || code >= 0x007f && code <= 0x009f || code >= 0xfdd0 && code <= 0xfdef || (code & 0xffff) === 0xffff || (code & 0xffff) === 0xfffe;\n}","'use strict';\n\nmodule.exports = visit;\n\nvar visitParents = require('unist-util-visit-parents');\n\nvar CONTINUE = visitParents.CONTINUE;\nvar SKIP = visitParents.SKIP;\nvar EXIT = visitParents.EXIT;\nvisit.CONTINUE = CONTINUE;\nvisit.SKIP = SKIP;\nvisit.EXIT = EXIT;\n\nfunction visit(tree, test, visitor, reverse) {\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor;\n    visitor = test;\n    test = null;\n  }\n\n  visitParents(tree, test, overload, reverse);\n\n  function overload(node, parents) {\n    var parent = parents[parents.length - 1];\n    var index = parent ? parent.children.indexOf(node) : null;\n    return visitor(node, index, parent);\n  }\n}","'use strict';\n\nvar trim = require('trim');\n\nvar repeat = require('repeat-string');\n\nvar getIndent = require('./get-indentation');\n\nmodule.exports = indentation;\nvar C_SPACE = ' ';\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\n/* Remove the minimum indent from every line in `value`.\n * Supports both tab, spaced, and mixed indentation (as\n * well as possible). */\n\nfunction indentation(value, maximum) {\n  var values = value.split(C_NEWLINE);\n  var position = values.length + 1;\n  var minIndent = Infinity;\n  var matrix = [];\n  var index;\n  var indentation;\n  var stops;\n  var padding;\n  values.unshift(repeat(C_SPACE, maximum) + '!');\n\n  while (position--) {\n    indentation = getIndent(values[position]);\n    matrix[position] = indentation.stops;\n\n    if (trim(values[position]).length === 0) {\n      continue;\n    }\n\n    if (indentation.indent) {\n      if (indentation.indent > 0 && indentation.indent < minIndent) {\n        minIndent = indentation.indent;\n      }\n    } else {\n      minIndent = Infinity;\n      break;\n    }\n  }\n\n  if (minIndent !== Infinity) {\n    position = values.length;\n\n    while (position--) {\n      stops = matrix[position];\n      index = minIndent;\n\n      while (index && !(index in stops)) {\n        index--;\n      }\n\n      if (trim(values[position]).length !== 0 && minIndent && index !== minIndent) {\n        padding = C_TAB;\n      } else {\n        padding = '';\n      }\n\n      values[position] = padding + values[position].slice(index in stops ? stops[index] + 1 : 0);\n    }\n  }\n\n  values.shift();\n  return values.join(C_NEWLINE);\n}","'use strict';\n\nvar stringify = require('unist-util-stringify-position');\n\nmodule.exports = VMessage; // Inherit from `Error#`.\n\nfunction VMessagePrototype() {}\n\nVMessagePrototype.prototype = Error.prototype;\nVMessage.prototype = new VMessagePrototype(); // Message properties.\n\nvar proto = VMessage.prototype;\nproto.file = '';\nproto.name = '';\nproto.reason = '';\nproto.message = '';\nproto.stack = '';\nproto.fatal = null;\nproto.column = null;\nproto.line = null; // Construct a new VMessage.\n//\n// Note: We cannot invoke `Error` on the created context, as that adds readonly\n// `line` and `column` attributes on Safari 9, thus throwing and failing the\n// data.\n\nfunction VMessage(reason, position, origin) {\n  var parts;\n  var range;\n  var location;\n\n  if (typeof position === 'string') {\n    origin = position;\n    position = null;\n  }\n\n  parts = parseOrigin(origin);\n  range = stringify(position) || '1:1';\n  location = {\n    start: {\n      line: null,\n      column: null\n    },\n    end: {\n      line: null,\n      column: null\n    }\n  }; // Node.\n\n  if (position && position.position) {\n    position = position.position;\n  }\n\n  if (position) {\n    // Position.\n    if (position.start) {\n      location = position;\n      position = position.start;\n    } else {\n      // Point.\n      location.start = position;\n    }\n  }\n\n  if (reason.stack) {\n    this.stack = reason.stack;\n    reason = reason.message;\n  }\n\n  this.message = reason;\n  this.name = range;\n  this.reason = reason;\n  this.line = position ? position.line : null;\n  this.column = position ? position.column : null;\n  this.location = location;\n  this.source = parts[0];\n  this.ruleId = parts[1];\n}\n\nfunction parseOrigin(origin) {\n  var result = [null, null];\n  var index;\n\n  if (typeof origin === 'string') {\n    index = origin.indexOf(':');\n\n    if (index === -1) {\n      result[1] = origin;\n    } else {\n      result[0] = origin.slice(0, index);\n      result[1] = origin.slice(index + 1);\n    }\n  }\n\n  return result;\n}","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  var index = value.indexOf('\\n', fromIndex);\n\n  while (index > fromIndex) {\n    if (value.charAt(index - 1) !== ' ') {\n      break;\n    }\n\n    index--;\n  }\n\n  return index;\n}","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  return value.indexOf('<', fromIndex);\n}","'use strict';\n\nvar trim = require('trim');\n\nvar word = require('is-word-character');\n\nvar whitespace = require('is-whitespace-character');\n\nvar locate = require('../locate/emphasis');\n\nmodule.exports = emphasis;\nemphasis.locator = locate;\nvar C_ASTERISK = '*';\nvar C_UNDERSCORE = '_';\n\nfunction emphasis(eat, value, silent) {\n  var self = this;\n  var index = 0;\n  var character = value.charAt(index);\n  var now;\n  var pedantic;\n  var marker;\n  var queue;\n  var subvalue;\n  var length;\n  var prev;\n\n  if (character !== C_ASTERISK && character !== C_UNDERSCORE) {\n    return;\n  }\n\n  pedantic = self.options.pedantic;\n  subvalue = character;\n  marker = character;\n  length = value.length;\n  index++;\n  queue = '';\n  character = '';\n\n  if (pedantic && whitespace(value.charAt(index))) {\n    return;\n  }\n\n  while (index < length) {\n    prev = character;\n    character = value.charAt(index);\n\n    if (character === marker && (!pedantic || !whitespace(prev))) {\n      character = value.charAt(++index);\n\n      if (character !== marker) {\n        if (!trim(queue) || prev === marker) {\n          return;\n        }\n\n        if (!pedantic && marker === C_UNDERSCORE && word(character)) {\n          queue += marker;\n          continue;\n        }\n        /* istanbul ignore if - never used (yet) */\n\n\n        if (silent) {\n          return true;\n        }\n\n        now = eat.now();\n        now.column++;\n        now.offset++;\n        return eat(subvalue + queue + marker)({\n          type: 'emphasis',\n          children: self.tokenizeInline(queue, now)\n        });\n      }\n\n      queue += marker;\n    }\n\n    if (!pedantic && character === '\\\\') {\n      queue += character;\n      character = value.charAt(++index);\n    }\n\n    queue += character;\n    index++;\n  }\n}","'use strict';\n\nvar visit = require('unist-util-visit');\n\nmodule.exports = removePosition;\n/* Remove `position`s from `tree`. */\n\nfunction removePosition(node, force) {\n  visit(node, force ? hard : soft);\n  return node;\n}\n\nfunction hard(node) {\n  delete node.position;\n}\n\nfunction soft(node) {\n  node.position = undefined;\n}","\"use strict\";\n/**\n * Naive, simple plugin to match inline nodes without attributes\n * This allows say <strong>foo</strong>, but not <strong class=\"very\">foo</strong>\n * For proper HTML support, you'll want a different plugin\n **/\n\nvar visit = require('unist-util-visit');\n\nvar type = 'virtualHtml';\nvar selfClosingRe = /^<(area|base|br|col|embed|hr|img|input|keygen|link|meta|param|source|track|wbr)\\s*\\/?>$/i;\nvar simpleTagRe = /^<(\\/?)([a-z]+)\\s*>$/;\n\nmodule.exports = function (tree) {\n  var open;\n  var currentParent;\n  visit(tree, 'html', function (node, index, parent) {\n    if (currentParent !== parent) {\n      open = [];\n      currentParent = parent;\n    }\n\n    var selfClosing = getSelfClosing(node);\n\n    if (selfClosing) {\n      parent.children.splice(index, 1, {\n        type: type,\n        tag: selfClosing,\n        position: node.position\n      });\n      return true;\n    }\n\n    var current = getSimpleTag(node, parent);\n\n    if (!current) {\n      return true;\n    }\n\n    var matching = findAndPull(open, current.tag);\n\n    if (matching) {\n      parent.children.splice(index, 0, virtual(current, matching, parent));\n    } else if (!current.opening) {\n      open.push(current);\n    }\n\n    return true;\n  }, true // Iterate in reverse\n  );\n  return tree;\n};\n\nfunction findAndPull(open, matchingTag) {\n  var i = open.length;\n\n  while (i--) {\n    if (open[i].tag === matchingTag) {\n      return open.splice(i, 1)[0];\n    }\n  }\n\n  return false;\n}\n\nfunction getSimpleTag(node, parent) {\n  var match = node.value.match(simpleTagRe);\n  return match ? {\n    tag: match[2],\n    opening: !match[1],\n    node: node\n  } : false;\n}\n\nfunction getSelfClosing(node) {\n  var match = node.value.match(selfClosingRe);\n  return match ? match[1] : false;\n}\n\nfunction virtual(fromNode, toNode, parent) {\n  var fromIndex = parent.children.indexOf(fromNode.node);\n  var toIndex = parent.children.indexOf(toNode.node);\n  var extracted = parent.children.splice(fromIndex, toIndex - fromIndex + 1);\n  var children = extracted.slice(1, -1);\n  return {\n    type: type,\n    children: children,\n    tag: fromNode.tag,\n    position: {\n      start: fromNode.node.position.start,\n      end: toNode.node.position.end,\n      indent: []\n    }\n  };\n}","'use strict';\n\nvar whitespace = require('is-whitespace-character');\n\nvar normalize = require('../util/normalize');\n\nmodule.exports = footnoteDefinition;\nfootnoteDefinition.notInList = true;\nfootnoteDefinition.notInBlock = true;\nvar C_BACKSLASH = '\\\\';\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_BRACKET_OPEN = '[';\nvar C_BRACKET_CLOSE = ']';\nvar C_CARET = '^';\nvar C_COLON = ':';\nvar EXPRESSION_INITIAL_TAB = /^( {4}|\\t)?/gm;\n\nfunction footnoteDefinition(eat, value, silent) {\n  var self = this;\n  var offsets = self.offset;\n  var index;\n  var length;\n  var subvalue;\n  var now;\n  var currentLine;\n  var content;\n  var queue;\n  var subqueue;\n  var character;\n  var identifier;\n  var add;\n  var exit;\n\n  if (!self.options.footnotes) {\n    return;\n  }\n\n  index = 0;\n  length = value.length;\n  subvalue = '';\n  now = eat.now();\n  currentLine = now.line;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (!whitespace(character)) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  if (value.charAt(index) !== C_BRACKET_OPEN || value.charAt(index + 1) !== C_CARET) {\n    return;\n  }\n\n  subvalue += C_BRACKET_OPEN + C_CARET;\n  index = subvalue.length;\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character === C_BRACKET_CLOSE) {\n      break;\n    } else if (character === C_BACKSLASH) {\n      queue += character;\n      index++;\n      character = value.charAt(index);\n    }\n\n    queue += character;\n    index++;\n  }\n\n  if (!queue || value.charAt(index) !== C_BRACKET_CLOSE || value.charAt(index + 1) !== C_COLON) {\n    return;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  identifier = normalize(queue);\n  subvalue += queue + C_BRACKET_CLOSE + C_COLON;\n  index = subvalue.length;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_TAB && character !== C_SPACE) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  now.column += subvalue.length;\n  now.offset += subvalue.length;\n  queue = '';\n  content = '';\n  subqueue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character === C_NEWLINE) {\n      subqueue = character;\n      index++;\n\n      while (index < length) {\n        character = value.charAt(index);\n\n        if (character !== C_NEWLINE) {\n          break;\n        }\n\n        subqueue += character;\n        index++;\n      }\n\n      queue += subqueue;\n      subqueue = '';\n\n      while (index < length) {\n        character = value.charAt(index);\n\n        if (character !== C_SPACE) {\n          break;\n        }\n\n        subqueue += character;\n        index++;\n      }\n\n      if (subqueue.length === 0) {\n        break;\n      }\n\n      queue += subqueue;\n    }\n\n    if (queue) {\n      content += queue;\n      queue = '';\n    }\n\n    content += character;\n    index++;\n  }\n\n  subvalue += content;\n  content = content.replace(EXPRESSION_INITIAL_TAB, function (line) {\n    offsets[currentLine] = (offsets[currentLine] || 0) + line.length;\n    currentLine++;\n    return '';\n  });\n  add = eat(subvalue);\n  exit = self.enterBlock();\n  content = self.tokenizeBlock(content, now);\n  exit();\n  return add({\n    type: 'footnoteDefinition',\n    identifier: identifier,\n    children: content\n  });\n}","'use strict';\n\nvar unherit = require('unherit');\n\nvar xtend = require('xtend');\n\nvar Parser = require('./lib/parser.js');\n\nmodule.exports = parse;\nparse.Parser = Parser;\n\nfunction parse(options) {\n  var Local = unherit(Parser);\n  Local.prototype.options = xtend(Local.prototype.options, this.data('settings'), options);\n  this.Parser = Local;\n}","'use strict';\n\nvar xtend = require('xtend');\n\nvar toggle = require('state-toggle');\n\nvar vfileLocation = require('vfile-location');\n\nvar unescape = require('./unescape');\n\nvar decode = require('./decode');\n\nvar tokenizer = require('./tokenizer');\n\nmodule.exports = Parser;\n\nfunction Parser(doc, file) {\n  this.file = file;\n  this.offset = {};\n  this.options = xtend(this.options);\n  this.setOptions({});\n  this.inList = false;\n  this.inBlock = false;\n  this.inLink = false;\n  this.atStart = true;\n  this.toOffset = vfileLocation(file).toOffset;\n  this.unescape = unescape(this, 'escape');\n  this.decode = decode(this);\n}\n\nvar proto = Parser.prototype;\n/* Expose core. */\n\nproto.setOptions = require('./set-options');\nproto.parse = require('./parse');\n/* Expose `defaults`. */\n\nproto.options = require('./defaults');\n/* Enter and exit helpers. */\n\nproto.exitStart = toggle('atStart', true);\nproto.enterList = toggle('inList', false);\nproto.enterLink = toggle('inLink', false);\nproto.enterBlock = toggle('inBlock', false);\n/* Nodes that can interupt a paragraph:\n *\n * ```markdown\n * A paragraph, followed by a thematic break.\n * ___\n * ```\n *\n * In the above example, the thematic break “interupts”\n * the paragraph. */\n\nproto.interruptParagraph = [['thematicBreak'], ['atxHeading'], ['fencedCode'], ['blockquote'], ['html'], ['setextHeading', {\n  commonmark: false\n}], ['definition', {\n  commonmark: false\n}], ['footnote', {\n  commonmark: false\n}]];\n/* Nodes that can interupt a list:\n *\n * ```markdown\n * - One\n * ___\n * ```\n *\n * In the above example, the thematic break “interupts”\n * the list. */\n\nproto.interruptList = [['atxHeading', {\n  pedantic: false\n}], ['fencedCode', {\n  pedantic: false\n}], ['thematicBreak', {\n  pedantic: false\n}], ['definition', {\n  commonmark: false\n}], ['footnote', {\n  commonmark: false\n}]];\n/* Nodes that can interupt a blockquote:\n *\n * ```markdown\n * > A paragraph.\n * ___\n * ```\n *\n * In the above example, the thematic break “interupts”\n * the blockquote. */\n\nproto.interruptBlockquote = [['indentedCode', {\n  commonmark: true\n}], ['fencedCode', {\n  commonmark: true\n}], ['atxHeading', {\n  commonmark: true\n}], ['setextHeading', {\n  commonmark: true\n}], ['thematicBreak', {\n  commonmark: true\n}], ['html', {\n  commonmark: true\n}], ['list', {\n  commonmark: true\n}], ['definition', {\n  commonmark: false\n}], ['footnote', {\n  commonmark: false\n}]];\n/* Handlers. */\n\nproto.blockTokenizers = {\n  newline: require('./tokenize/newline'),\n  indentedCode: require('./tokenize/code-indented'),\n  fencedCode: require('./tokenize/code-fenced'),\n  blockquote: require('./tokenize/blockquote'),\n  atxHeading: require('./tokenize/heading-atx'),\n  thematicBreak: require('./tokenize/thematic-break'),\n  list: require('./tokenize/list'),\n  setextHeading: require('./tokenize/heading-setext'),\n  html: require('./tokenize/html-block'),\n  footnote: require('./tokenize/footnote-definition'),\n  definition: require('./tokenize/definition'),\n  table: require('./tokenize/table'),\n  paragraph: require('./tokenize/paragraph')\n};\nproto.inlineTokenizers = {\n  escape: require('./tokenize/escape'),\n  autoLink: require('./tokenize/auto-link'),\n  url: require('./tokenize/url'),\n  html: require('./tokenize/html-inline'),\n  link: require('./tokenize/link'),\n  reference: require('./tokenize/reference'),\n  strong: require('./tokenize/strong'),\n  emphasis: require('./tokenize/emphasis'),\n  deletion: require('./tokenize/delete'),\n  code: require('./tokenize/code-inline'),\n  break: require('./tokenize/break'),\n  text: require('./tokenize/text')\n};\n/* Expose precedence. */\n\nproto.blockMethods = keys(proto.blockTokenizers);\nproto.inlineMethods = keys(proto.inlineTokenizers);\n/* Tokenizers. */\n\nproto.tokenizeBlock = tokenizer('block');\nproto.tokenizeInline = tokenizer('inline');\nproto.tokenizeFactory = tokenizer;\n/* Get all keys in `value`. */\n\nfunction keys(value) {\n  var result = [];\n  var key;\n\n  for (key in value) {\n    result.push(key);\n  }\n\n  return result;\n}","'use strict';\n\nmodule.exports = hexadecimal;\n/* Check if the given character code, or the character\n * code at the first character, is hexadecimal. */\n\nfunction hexadecimal(character) {\n  var code = typeof character === 'string' ? character.charCodeAt(0) : character;\n  return code >= 97\n  /* a */\n  && code <= 102\n  /* z */\n  || code >= 65\n  /* A */\n  && code <= 70\n  /* Z */\n  || code >= 48\n  /* A */\n  && code <= 57\n  /* Z */\n  ;\n}","\"use strict\";\n\nvar HtmlParser = '__RMD_HTML_PARSER__';\nexports.HtmlParser = typeof Symbol === 'undefined' ? HtmlParser : Symbol(HtmlParser);","'use strict';\n\nvar whitespace = require('is-whitespace-character');\n\nvar locate = require('../locate/link');\n\nmodule.exports = link;\nlink.locator = locate;\nvar own = {}.hasOwnProperty;\nvar C_BACKSLASH = '\\\\';\nvar C_BRACKET_OPEN = '[';\nvar C_BRACKET_CLOSE = ']';\nvar C_PAREN_OPEN = '(';\nvar C_PAREN_CLOSE = ')';\nvar C_LT = '<';\nvar C_GT = '>';\nvar C_TICK = '`';\nvar C_DOUBLE_QUOTE = '\"';\nvar C_SINGLE_QUOTE = '\\'';\n/* Map of characters, which can be used to mark link\n * and image titles. */\n\nvar LINK_MARKERS = {};\nLINK_MARKERS[C_DOUBLE_QUOTE] = C_DOUBLE_QUOTE;\nLINK_MARKERS[C_SINGLE_QUOTE] = C_SINGLE_QUOTE;\n/* Map of characters, which can be used to mark link\n * and image titles in commonmark-mode. */\n\nvar COMMONMARK_LINK_MARKERS = {};\nCOMMONMARK_LINK_MARKERS[C_DOUBLE_QUOTE] = C_DOUBLE_QUOTE;\nCOMMONMARK_LINK_MARKERS[C_SINGLE_QUOTE] = C_SINGLE_QUOTE;\nCOMMONMARK_LINK_MARKERS[C_PAREN_OPEN] = C_PAREN_CLOSE;\n\nfunction link(eat, value, silent) {\n  var self = this;\n  var subvalue = '';\n  var index = 0;\n  var character = value.charAt(0);\n  var pedantic = self.options.pedantic;\n  var commonmark = self.options.commonmark;\n  var gfm = self.options.gfm;\n  var closed;\n  var count;\n  var opening;\n  var beforeURL;\n  var beforeTitle;\n  var subqueue;\n  var hasMarker;\n  var markers;\n  var isImage;\n  var content;\n  var marker;\n  var length;\n  var title;\n  var depth;\n  var queue;\n  var url;\n  var now;\n  var exit;\n  var node;\n  /* Detect whether this is an image. */\n\n  if (character === '!') {\n    isImage = true;\n    subvalue = character;\n    character = value.charAt(++index);\n  }\n  /* Eat the opening. */\n\n\n  if (character !== C_BRACKET_OPEN) {\n    return;\n  }\n  /* Exit when this is a link and we’re already inside\n   * a link. */\n\n\n  if (!isImage && self.inLink) {\n    return;\n  }\n\n  subvalue += character;\n  queue = '';\n  index++;\n  /* Eat the content. */\n\n  length = value.length;\n  now = eat.now();\n  depth = 0;\n  now.column += index;\n  now.offset += index;\n\n  while (index < length) {\n    character = value.charAt(index);\n    subqueue = character;\n\n    if (character === C_TICK) {\n      /* Inline-code in link content. */\n      count = 1;\n\n      while (value.charAt(index + 1) === C_TICK) {\n        subqueue += character;\n        index++;\n        count++;\n      }\n\n      if (!opening) {\n        opening = count;\n      } else if (count >= opening) {\n        opening = 0;\n      }\n    } else if (character === C_BACKSLASH) {\n      /* Allow brackets to be escaped. */\n      index++;\n      subqueue += value.charAt(index);\n      /* In GFM mode, brackets in code still count.\n       * In all other modes, they don’t.  This empty\n       * block prevents the next statements are\n       * entered. */\n    } else if ((!opening || gfm) && character === C_BRACKET_OPEN) {\n      depth++;\n    } else if ((!opening || gfm) && character === C_BRACKET_CLOSE) {\n      if (depth) {\n        depth--;\n      } else {\n        /* Allow white-space between content and\n         * url in GFM mode. */\n        if (!pedantic) {\n          while (index < length) {\n            character = value.charAt(index + 1);\n\n            if (!whitespace(character)) {\n              break;\n            }\n\n            subqueue += character;\n            index++;\n          }\n        }\n\n        if (value.charAt(index + 1) !== C_PAREN_OPEN) {\n          return;\n        }\n\n        subqueue += C_PAREN_OPEN;\n        closed = true;\n        index++;\n        break;\n      }\n    }\n\n    queue += subqueue;\n    subqueue = '';\n    index++;\n  }\n  /* Eat the content closing. */\n\n\n  if (!closed) {\n    return;\n  }\n\n  content = queue;\n  subvalue += queue + subqueue;\n  index++;\n  /* Eat white-space. */\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (!whitespace(character)) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n  /* Eat the URL. */\n\n\n  character = value.charAt(index);\n  markers = commonmark ? COMMONMARK_LINK_MARKERS : LINK_MARKERS;\n  queue = '';\n  beforeURL = subvalue;\n\n  if (character === C_LT) {\n    index++;\n    beforeURL += C_LT;\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character === C_GT) {\n        break;\n      }\n\n      if (commonmark && character === '\\n') {\n        return;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    if (value.charAt(index) !== C_GT) {\n      return;\n    }\n\n    subvalue += C_LT + queue + C_GT;\n    url = queue;\n    index++;\n  } else {\n    character = null;\n    subqueue = '';\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (subqueue && own.call(markers, character)) {\n        break;\n      }\n\n      if (whitespace(character)) {\n        if (!pedantic) {\n          break;\n        }\n\n        subqueue += character;\n      } else {\n        if (character === C_PAREN_OPEN) {\n          depth++;\n        } else if (character === C_PAREN_CLOSE) {\n          if (depth === 0) {\n            break;\n          }\n\n          depth--;\n        }\n\n        queue += subqueue;\n        subqueue = '';\n\n        if (character === C_BACKSLASH) {\n          queue += C_BACKSLASH;\n          character = value.charAt(++index);\n        }\n\n        queue += character;\n      }\n\n      index++;\n    }\n\n    subvalue += queue;\n    url = queue;\n    index = subvalue.length;\n  }\n  /* Eat white-space. */\n\n\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (!whitespace(character)) {\n      break;\n    }\n\n    queue += character;\n    index++;\n  }\n\n  character = value.charAt(index);\n  subvalue += queue;\n  /* Eat the title. */\n\n  if (queue && own.call(markers, character)) {\n    index++;\n    subvalue += character;\n    queue = '';\n    marker = markers[character];\n    beforeTitle = subvalue;\n    /* In commonmark-mode, things are pretty easy: the\n     * marker cannot occur inside the title.\n     *\n     * Non-commonmark does, however, support nested\n     * delimiters. */\n\n    if (commonmark) {\n      while (index < length) {\n        character = value.charAt(index);\n\n        if (character === marker) {\n          break;\n        }\n\n        if (character === C_BACKSLASH) {\n          queue += C_BACKSLASH;\n          character = value.charAt(++index);\n        }\n\n        index++;\n        queue += character;\n      }\n\n      character = value.charAt(index);\n\n      if (character !== marker) {\n        return;\n      }\n\n      title = queue;\n      subvalue += queue + character;\n      index++;\n\n      while (index < length) {\n        character = value.charAt(index);\n\n        if (!whitespace(character)) {\n          break;\n        }\n\n        subvalue += character;\n        index++;\n      }\n    } else {\n      subqueue = '';\n\n      while (index < length) {\n        character = value.charAt(index);\n\n        if (character === marker) {\n          if (hasMarker) {\n            queue += marker + subqueue;\n            subqueue = '';\n          }\n\n          hasMarker = true;\n        } else if (!hasMarker) {\n          queue += character;\n        } else if (character === C_PAREN_CLOSE) {\n          subvalue += queue + marker + subqueue;\n          title = queue;\n          break;\n        } else if (whitespace(character)) {\n          subqueue += character;\n        } else {\n          queue += marker + subqueue + character;\n          subqueue = '';\n          hasMarker = false;\n        }\n\n        index++;\n      }\n    }\n  }\n\n  if (value.charAt(index) !== C_PAREN_CLOSE) {\n    return;\n  }\n  /* istanbul ignore if - never used (yet) */\n\n\n  if (silent) {\n    return true;\n  }\n\n  subvalue += C_PAREN_CLOSE;\n  url = self.decode.raw(self.unescape(url), eat(beforeURL).test().end, {\n    nonTerminated: false\n  });\n\n  if (title) {\n    beforeTitle = eat(beforeTitle).test().end;\n    title = self.decode.raw(self.unescape(title), beforeTitle);\n  }\n\n  node = {\n    type: isImage ? 'image' : 'link',\n    title: title || null,\n    url: url\n  };\n\n  if (isImage) {\n    node.alt = self.decode.raw(self.unescape(content), now) || null;\n  } else {\n    exit = self.enterLink();\n    node.children = self.tokenizeInline(content, now);\n    exit();\n  }\n\n  return eat(subvalue)(node);\n}","// extracted by mini-css-extract-plugin\nmodule.exports = {\"variables\":\"\\\"../../layouts/variables.css\\\"\",\"pink\":\"#ff00cc\",\"orange\":\"#ff6600\",\"blue\":\"#00ccff\",\"darkBlue\":\"#0055d4\",\"grey\":\"#9c9c9c\",\"discourse\":\"social-module--discourse--2hvhP\",\"email\":\"social-module--email--302Xv\",\"facebook\":\"social-module--facebook--KA39V\",\"github\":\"social-module--github--1NPMk\",\"instagram\":\"social-module--instagram--3_ieV\",\"mailchimp\":\"social-module--mailchimp--R1j-B\",\"meetup\":\"social-module--meetup--3bCGA\",\"telegram\":\"social-module--telegram--TRpIr\",\"twitter\":\"social-module--twitter--3WEuB\",\"youtube\":\"social-module--youtube--WbUHD\"};","'use strict';\n\nvar collapseWhiteSpace = require('collapse-white-space');\n\nmodule.exports = normalize;\n/* Normalize an identifier.  Collapses multiple white space\n * characters into a single space, and removes casing. */\n\nfunction normalize(value) {\n  return collapseWhiteSpace(value).toLowerCase();\n}","'use strict';\n\nvar path = require('path');\n\nfunction replaceExt(npath, ext) {\n  if (typeof npath !== 'string') {\n    return npath;\n  }\n\n  if (npath.length === 0) {\n    return npath;\n  }\n\n  var nFileName = path.basename(npath, path.extname(npath)) + ext;\n  return path.join(path.dirname(npath), nFileName);\n}\n\nmodule.exports = replaceExt;","// extracted by mini-css-extract-plugin\nmodule.exports = {\"variables\":\"\\\"../layouts/variables.css\\\"\",\"orange\":\"#ff6600\",\"pink\":\"#ff00cc\",\"blue\":\"#00ccff\",\"gradient\":\"linear-gradient(-45deg, #00ccff, #ff00cc, #ff6600, #0055d4)\",\"gradientSize\":\"200% 200%\",\"gradientPosition\":\"100% 30%\",\"button\":\"button-module--button--27elc\"};","'use strict';\n\nmodule.exports = indentation;\n/* Map of characters, and their column length,\n * which can be used as indentation. */\n\nvar characters = {\n  ' ': 1,\n  '\\t': 4\n};\n/* Gets indentation information for a line. */\n\nfunction indentation(value) {\n  var index = 0;\n  var indent = 0;\n  var character = value.charAt(index);\n  var stops = {};\n  var size;\n\n  while (character in characters) {\n    size = characters[character];\n    indent += size;\n\n    if (size > 1) {\n      indent = Math.floor(indent / size) * size;\n    }\n\n    stops[indent] = index;\n    character = value.charAt(++index);\n  }\n\n  return {\n    indent: indent,\n    stops: stops\n  };\n}","'use strict';\n\nvar xtend = require('xtend');\n\nvar escapes = require('markdown-escapes');\n\nvar defaults = require('./defaults');\n\nmodule.exports = setOptions;\n\nfunction setOptions(options) {\n  var self = this;\n  var current = self.options;\n  var key;\n  var value;\n\n  if (options == null) {\n    options = {};\n  } else if (typeof options === 'object') {\n    options = xtend(options);\n  } else {\n    throw new Error('Invalid value `' + options + '` ' + 'for setting `options`');\n  }\n\n  for (key in defaults) {\n    value = options[key];\n\n    if (value == null) {\n      value = current[key];\n    }\n\n    if (key !== 'blocks' && typeof value !== 'boolean' || key === 'blocks' && typeof value !== 'object') {\n      throw new Error('Invalid value `' + value + '` for setting `options.' + key + '`');\n    }\n\n    options[key] = value;\n  }\n\n  self.options = options;\n  self.escape = escapes(options);\n  return self;\n}","'use strict';\n\nmodule.exports = wordCharacter;\nvar fromCode = String.fromCharCode;\nvar re = /\\w/;\n/* Check if the given character code, or the character\n * code at the first character, is a word character. */\n\nfunction wordCharacter(character) {\n  return re.test(typeof character === 'number' ? fromCode(character) : character.charAt(0));\n}","module.exports = \"data:image/svg+xml;base64,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\"","'use strict';\n\nmodule.exports = thematicBreak;\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_ASTERISK = '*';\nvar C_UNDERSCORE = '_';\nvar C_DASH = '-';\nvar THEMATIC_BREAK_MARKER_COUNT = 3;\n\nfunction thematicBreak(eat, value, silent) {\n  var index = -1;\n  var length = value.length + 1;\n  var subvalue = '';\n  var character;\n  var marker;\n  var markerCount;\n  var queue;\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_TAB && character !== C_SPACE) {\n      break;\n    }\n\n    subvalue += character;\n  }\n\n  if (character !== C_ASTERISK && character !== C_DASH && character !== C_UNDERSCORE) {\n    return;\n  }\n\n  marker = character;\n  subvalue += character;\n  markerCount = 1;\n  queue = '';\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character === marker) {\n      markerCount++;\n      subvalue += queue + marker;\n      queue = '';\n    } else if (character === C_SPACE) {\n      queue += character;\n    } else if (markerCount >= THEMATIC_BREAK_MARKER_COUNT && (!character || character === C_NEWLINE)) {\n      subvalue += queue;\n\n      if (silent) {\n        return true;\n      }\n\n      return eat(subvalue)({\n        type: 'thematicBreak'\n      });\n    } else {\n      return;\n    }\n  }\n}","'use strict';\n/* eslint-disable max-params */\n\nvar trim = require('trim');\n\nvar repeat = require('repeat-string');\n\nvar decimal = require('is-decimal');\n\nvar getIndent = require('../util/get-indentation');\n\nvar removeIndent = require('../util/remove-indentation');\n\nvar interrupt = require('../util/interrupt');\n\nmodule.exports = list;\nvar C_ASTERISK = '*';\nvar C_UNDERSCORE = '_';\nvar C_PLUS = '+';\nvar C_DASH = '-';\nvar C_DOT = '.';\nvar C_SPACE = ' ';\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_PAREN_CLOSE = ')';\nvar C_X_LOWER = 'x';\nvar TAB_SIZE = 4;\nvar EXPRESSION_LOOSE_LIST_ITEM = /\\n\\n(?!\\s*$)/;\nvar EXPRESSION_TASK_ITEM = /^\\[([ \\t]|x|X)][ \\t]/;\nvar EXPRESSION_BULLET = /^([ \\t]*)([*+-]|\\d+[.)])( {1,4}(?! )| |\\t|$|(?=\\n))([^\\n]*)/;\nvar EXPRESSION_PEDANTIC_BULLET = /^([ \\t]*)([*+-]|\\d+[.)])([ \\t]+)/;\nvar EXPRESSION_INITIAL_INDENT = /^( {1,4}|\\t)?/gm;\n/* Map of characters which can be used to mark\n * list-items. */\n\nvar LIST_UNORDERED_MARKERS = {};\nLIST_UNORDERED_MARKERS[C_ASTERISK] = true;\nLIST_UNORDERED_MARKERS[C_PLUS] = true;\nLIST_UNORDERED_MARKERS[C_DASH] = true;\n/* Map of characters which can be used to mark\n * list-items after a digit. */\n\nvar LIST_ORDERED_MARKERS = {};\nLIST_ORDERED_MARKERS[C_DOT] = true;\n/* Map of characters which can be used to mark\n * list-items after a digit. */\n\nvar LIST_ORDERED_COMMONMARK_MARKERS = {};\nLIST_ORDERED_COMMONMARK_MARKERS[C_DOT] = true;\nLIST_ORDERED_COMMONMARK_MARKERS[C_PAREN_CLOSE] = true;\n\nfunction list(eat, value, silent) {\n  var self = this;\n  var commonmark = self.options.commonmark;\n  var pedantic = self.options.pedantic;\n  var tokenizers = self.blockTokenizers;\n  var interuptors = self.interruptList;\n  var markers;\n  var index = 0;\n  var length = value.length;\n  var start = null;\n  var size = 0;\n  var queue;\n  var ordered;\n  var character;\n  var marker;\n  var nextIndex;\n  var startIndex;\n  var prefixed;\n  var currentMarker;\n  var content;\n  var line;\n  var prevEmpty;\n  var empty;\n  var items;\n  var allLines;\n  var emptyLines;\n  var item;\n  var enterTop;\n  var exitBlockquote;\n  var isLoose;\n  var node;\n  var now;\n  var end;\n  var indented;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character === C_TAB) {\n      size += TAB_SIZE - size % TAB_SIZE;\n    } else if (character === C_SPACE) {\n      size++;\n    } else {\n      break;\n    }\n\n    index++;\n  }\n\n  if (size >= TAB_SIZE) {\n    return;\n  }\n\n  character = value.charAt(index);\n  markers = commonmark ? LIST_ORDERED_COMMONMARK_MARKERS : LIST_ORDERED_MARKERS;\n\n  if (LIST_UNORDERED_MARKERS[character] === true) {\n    marker = character;\n    ordered = false;\n  } else {\n    ordered = true;\n    queue = '';\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (!decimal(character)) {\n        break;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    character = value.charAt(index);\n\n    if (!queue || markers[character] !== true) {\n      return;\n    }\n\n    start = parseInt(queue, 10);\n    marker = character;\n  }\n\n  character = value.charAt(++index);\n\n  if (character !== C_SPACE && character !== C_TAB) {\n    return;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  index = 0;\n  items = [];\n  allLines = [];\n  emptyLines = [];\n\n  while (index < length) {\n    nextIndex = value.indexOf(C_NEWLINE, index);\n    startIndex = index;\n    prefixed = false;\n    indented = false;\n\n    if (nextIndex === -1) {\n      nextIndex = length;\n    }\n\n    end = index + TAB_SIZE;\n    size = 0;\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character === C_TAB) {\n        size += TAB_SIZE - size % TAB_SIZE;\n      } else if (character === C_SPACE) {\n        size++;\n      } else {\n        break;\n      }\n\n      index++;\n    }\n\n    if (size >= TAB_SIZE) {\n      indented = true;\n    }\n\n    if (item && size >= item.indent) {\n      indented = true;\n    }\n\n    character = value.charAt(index);\n    currentMarker = null;\n\n    if (!indented) {\n      if (LIST_UNORDERED_MARKERS[character] === true) {\n        currentMarker = character;\n        index++;\n        size++;\n      } else {\n        queue = '';\n\n        while (index < length) {\n          character = value.charAt(index);\n\n          if (!decimal(character)) {\n            break;\n          }\n\n          queue += character;\n          index++;\n        }\n\n        character = value.charAt(index);\n        index++;\n\n        if (queue && markers[character] === true) {\n          currentMarker = character;\n          size += queue.length + 1;\n        }\n      }\n\n      if (currentMarker) {\n        character = value.charAt(index);\n\n        if (character === C_TAB) {\n          size += TAB_SIZE - size % TAB_SIZE;\n          index++;\n        } else if (character === C_SPACE) {\n          end = index + TAB_SIZE;\n\n          while (index < end) {\n            if (value.charAt(index) !== C_SPACE) {\n              break;\n            }\n\n            index++;\n            size++;\n          }\n\n          if (index === end && value.charAt(index) === C_SPACE) {\n            index -= TAB_SIZE - 1;\n            size -= TAB_SIZE - 1;\n          }\n        } else if (character !== C_NEWLINE && character !== '') {\n          currentMarker = null;\n        }\n      }\n    }\n\n    if (currentMarker) {\n      if (!pedantic && marker !== currentMarker) {\n        break;\n      }\n\n      prefixed = true;\n    } else {\n      if (!commonmark && !indented && value.charAt(startIndex) === C_SPACE) {\n        indented = true;\n      } else if (commonmark && item) {\n        indented = size >= item.indent || size > TAB_SIZE;\n      }\n\n      prefixed = false;\n      index = startIndex;\n    }\n\n    line = value.slice(startIndex, nextIndex);\n    content = startIndex === index ? line : value.slice(index, nextIndex);\n\n    if (currentMarker === C_ASTERISK || currentMarker === C_UNDERSCORE || currentMarker === C_DASH) {\n      if (tokenizers.thematicBreak.call(self, eat, line, true)) {\n        break;\n      }\n    }\n\n    prevEmpty = empty;\n    empty = !trim(content).length;\n\n    if (indented && item) {\n      item.value = item.value.concat(emptyLines, line);\n      allLines = allLines.concat(emptyLines, line);\n      emptyLines = [];\n    } else if (prefixed) {\n      if (emptyLines.length !== 0) {\n        item.value.push('');\n        item.trail = emptyLines.concat();\n      }\n\n      item = {\n        value: [line],\n        indent: size,\n        trail: []\n      };\n      items.push(item);\n      allLines = allLines.concat(emptyLines, line);\n      emptyLines = [];\n    } else if (empty) {\n      if (prevEmpty) {\n        break;\n      }\n\n      emptyLines.push(line);\n    } else {\n      if (prevEmpty) {\n        break;\n      }\n\n      if (interrupt(interuptors, tokenizers, self, [eat, line, true])) {\n        break;\n      }\n\n      item.value = item.value.concat(emptyLines, line);\n      allLines = allLines.concat(emptyLines, line);\n      emptyLines = [];\n    }\n\n    index = nextIndex + 1;\n  }\n\n  node = eat(allLines.join(C_NEWLINE)).reset({\n    type: 'list',\n    ordered: ordered,\n    start: start,\n    loose: null,\n    children: []\n  });\n  enterTop = self.enterList();\n  exitBlockquote = self.enterBlock();\n  isLoose = false;\n  index = -1;\n  length = items.length;\n\n  while (++index < length) {\n    item = items[index].value.join(C_NEWLINE);\n    now = eat.now();\n    item = eat(item)(listItem(self, item, now), node);\n\n    if (item.loose) {\n      isLoose = true;\n    }\n\n    item = items[index].trail.join(C_NEWLINE);\n\n    if (index !== length - 1) {\n      item += C_NEWLINE;\n    }\n\n    eat(item);\n  }\n\n  enterTop();\n  exitBlockquote();\n  node.loose = isLoose;\n  return node;\n}\n\nfunction listItem(ctx, value, position) {\n  var offsets = ctx.offset;\n  var fn = ctx.options.pedantic ? pedanticListItem : normalListItem;\n  var checked = null;\n  var task;\n  var indent;\n  value = fn.apply(null, arguments);\n\n  if (ctx.options.gfm) {\n    task = value.match(EXPRESSION_TASK_ITEM);\n\n    if (task) {\n      indent = task[0].length;\n      checked = task[1].toLowerCase() === C_X_LOWER;\n      offsets[position.line] += indent;\n      value = value.slice(indent);\n    }\n  }\n\n  return {\n    type: 'listItem',\n    loose: EXPRESSION_LOOSE_LIST_ITEM.test(value) || value.charAt(value.length - 1) === C_NEWLINE,\n    checked: checked,\n    children: ctx.tokenizeBlock(value, position)\n  };\n}\n/* Create a list-item using overly simple mechanics. */\n\n\nfunction pedanticListItem(ctx, value, position) {\n  var offsets = ctx.offset;\n  var line = position.line;\n  /* Remove the list-item’s bullet. */\n\n  value = value.replace(EXPRESSION_PEDANTIC_BULLET, replacer);\n  /* The initial line was also matched by the below, so\n   * we reset the `line`. */\n\n  line = position.line;\n  return value.replace(EXPRESSION_INITIAL_INDENT, replacer);\n  /* A simple replacer which removed all matches,\n   * and adds their length to `offset`. */\n\n  function replacer($0) {\n    offsets[line] = (offsets[line] || 0) + $0.length;\n    line++;\n    return '';\n  }\n}\n/* Create a list-item using sane mechanics. */\n\n\nfunction normalListItem(ctx, value, position) {\n  var offsets = ctx.offset;\n  var line = position.line;\n  var max;\n  var bullet;\n  var rest;\n  var lines;\n  var trimmedLines;\n  var index;\n  var length;\n  /* Remove the list-item’s bullet. */\n\n  value = value.replace(EXPRESSION_BULLET, replacer);\n  lines = value.split(C_NEWLINE);\n  trimmedLines = removeIndent(value, getIndent(max).indent).split(C_NEWLINE);\n  /* We replaced the initial bullet with something\n   * else above, which was used to trick\n   * `removeIndentation` into removing some more\n   * characters when possible.  However, that could\n   * result in the initial line to be stripped more\n   * than it should be. */\n\n  trimmedLines[0] = rest;\n  offsets[line] = (offsets[line] || 0) + bullet.length;\n  line++;\n  index = 0;\n  length = lines.length;\n\n  while (++index < length) {\n    offsets[line] = (offsets[line] || 0) + lines[index].length - trimmedLines[index].length;\n    line++;\n  }\n\n  return trimmedLines.join(C_NEWLINE);\n\n  function replacer($0, $1, $2, $3, $4) {\n    bullet = $1 + $2 + $3;\n    rest = $4;\n    /* Make sure that the first nine numbered list items\n     * can indent with an extra space.  That is, when\n     * the bullet did not receive an extra final space. */\n\n    if (Number($2) < 10 && bullet.length % 2 === 1) {\n      $2 = C_SPACE + $2;\n    }\n\n    max = $1 + repeat(C_SPACE, $2.length) + $3;\n    return max + rest;\n  }\n}","'use strict';\n\nvar locate = require('../locate/escape');\n\nmodule.exports = escape;\nescape.locator = locate;\n\nfunction escape(eat, value, silent) {\n  var self = this;\n  var character;\n  var node;\n\n  if (value.charAt(0) === '\\\\') {\n    character = value.charAt(1);\n\n    if (self.escape.indexOf(character) !== -1) {\n      /* istanbul ignore if - never used (yet) */\n      if (silent) {\n        return true;\n      }\n\n      if (character === '\\n') {\n        node = {\n          type: 'break'\n        };\n      } else {\n        node = {\n          type: 'text',\n          value: character\n        };\n      }\n\n      return eat('\\\\' + character)(node);\n    }\n  }\n}","\"use strict\";\n\nvar visit = require('unist-util-visit');\n\nexports.ofType = function (types, mode) {\n  return function (node) {\n    types.forEach(function (type) {\n      return visit(node, type, disallow, true);\n    });\n    return node;\n  };\n\n  function disallow(node, index, parent) {\n    if (parent) {\n      untangle(node, index, parent, mode);\n    }\n  }\n};\n\nexports.ifNotMatch = function (allowNode, mode) {\n  return function (node) {\n    visit(node, disallow, true);\n    return node;\n  };\n\n  function disallow(node, index, parent) {\n    if (parent && !allowNode(node, index, parent)) {\n      untangle(node, index, parent, mode);\n    }\n  }\n};\n\nfunction untangle(node, index, parent, mode) {\n  if (mode === 'remove') {\n    parent.children.splice(index, 1);\n  } else if (mode === 'unwrap') {\n    var args = [index, 1];\n\n    if (node.children) {\n      args = args.concat(node.children);\n    }\n\n    Array.prototype.splice.apply(parent.children, args);\n  }\n}","'use strict';\n\nvar whitespace = require('is-whitespace-character');\n\nmodule.exports = table;\nvar C_BACKSLASH = '\\\\';\nvar C_TICK = '`';\nvar C_DASH = '-';\nvar C_PIPE = '|';\nvar C_COLON = ':';\nvar C_SPACE = ' ';\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar MIN_TABLE_COLUMNS = 1;\nvar MIN_TABLE_ROWS = 2;\nvar TABLE_ALIGN_LEFT = 'left';\nvar TABLE_ALIGN_CENTER = 'center';\nvar TABLE_ALIGN_RIGHT = 'right';\nvar TABLE_ALIGN_NONE = null;\n\nfunction table(eat, value, silent) {\n  var self = this;\n  var index;\n  var alignments;\n  var alignment;\n  var subvalue;\n  var row;\n  var length;\n  var lines;\n  var queue;\n  var character;\n  var hasDash;\n  var align;\n  var cell;\n  var preamble;\n  var count;\n  var opening;\n  var now;\n  var position;\n  var lineCount;\n  var line;\n  var rows;\n  var table;\n  var lineIndex;\n  var pipeIndex;\n  var first;\n  /* Exit when not in gfm-mode. */\n\n  if (!self.options.gfm) {\n    return;\n  }\n  /* Get the rows.\n   * Detecting tables soon is hard, so there are some\n   * checks for performance here, such as the minimum\n   * number of rows, and allowed characters in the\n   * alignment row. */\n\n\n  index = 0;\n  lineCount = 0;\n  length = value.length + 1;\n  lines = [];\n\n  while (index < length) {\n    lineIndex = value.indexOf(C_NEWLINE, index);\n    pipeIndex = value.indexOf(C_PIPE, index + 1);\n\n    if (lineIndex === -1) {\n      lineIndex = value.length;\n    }\n\n    if (pipeIndex === -1 || pipeIndex > lineIndex) {\n      if (lineCount < MIN_TABLE_ROWS) {\n        return;\n      }\n\n      break;\n    }\n\n    lines.push(value.slice(index, lineIndex));\n    lineCount++;\n    index = lineIndex + 1;\n  }\n  /* Parse the alignment row. */\n\n\n  subvalue = lines.join(C_NEWLINE);\n  alignments = lines.splice(1, 1)[0] || [];\n  index = 0;\n  length = alignments.length;\n  lineCount--;\n  alignment = false;\n  align = [];\n\n  while (index < length) {\n    character = alignments.charAt(index);\n\n    if (character === C_PIPE) {\n      hasDash = null;\n\n      if (alignment === false) {\n        if (first === false) {\n          return;\n        }\n      } else {\n        align.push(alignment);\n        alignment = false;\n      }\n\n      first = false;\n    } else if (character === C_DASH) {\n      hasDash = true;\n      alignment = alignment || TABLE_ALIGN_NONE;\n    } else if (character === C_COLON) {\n      if (alignment === TABLE_ALIGN_LEFT) {\n        alignment = TABLE_ALIGN_CENTER;\n      } else if (hasDash && alignment === TABLE_ALIGN_NONE) {\n        alignment = TABLE_ALIGN_RIGHT;\n      } else {\n        alignment = TABLE_ALIGN_LEFT;\n      }\n    } else if (!whitespace(character)) {\n      return;\n    }\n\n    index++;\n  }\n\n  if (alignment !== false) {\n    align.push(alignment);\n  }\n  /* Exit when without enough columns. */\n\n\n  if (align.length < MIN_TABLE_COLUMNS) {\n    return;\n  }\n  /* istanbul ignore if - never used (yet) */\n\n\n  if (silent) {\n    return true;\n  }\n  /* Parse the rows. */\n\n\n  position = -1;\n  rows = [];\n  table = eat(subvalue).reset({\n    type: 'table',\n    align: align,\n    children: rows\n  });\n\n  while (++position < lineCount) {\n    line = lines[position];\n    row = {\n      type: 'tableRow',\n      children: []\n    };\n    /* Eat a newline character when this is not the\n     * first row. */\n\n    if (position) {\n      eat(C_NEWLINE);\n    }\n    /* Eat the row. */\n\n\n    eat(line).reset(row, table);\n    length = line.length + 1;\n    index = 0;\n    queue = '';\n    cell = '';\n    preamble = true;\n    count = null;\n    opening = null;\n\n    while (index < length) {\n      character = line.charAt(index);\n\n      if (character === C_TAB || character === C_SPACE) {\n        if (cell) {\n          queue += character;\n        } else {\n          eat(character);\n        }\n\n        index++;\n        continue;\n      }\n\n      if (character === '' || character === C_PIPE) {\n        if (preamble) {\n          eat(character);\n        } else {\n          if (character && opening) {\n            queue += character;\n            index++;\n            continue;\n          }\n\n          if ((cell || character) && !preamble) {\n            subvalue = cell;\n\n            if (queue.length > 1) {\n              if (character) {\n                subvalue += queue.slice(0, queue.length - 1);\n                queue = queue.charAt(queue.length - 1);\n              } else {\n                subvalue += queue;\n                queue = '';\n              }\n            }\n\n            now = eat.now();\n            eat(subvalue)({\n              type: 'tableCell',\n              children: self.tokenizeInline(cell, now)\n            }, row);\n          }\n\n          eat(queue + character);\n          queue = '';\n          cell = '';\n        }\n      } else {\n        if (queue) {\n          cell += queue;\n          queue = '';\n        }\n\n        cell += character;\n\n        if (character === C_BACKSLASH && index !== length - 2) {\n          cell += line.charAt(index + 1);\n          index++;\n        }\n\n        if (character === C_TICK) {\n          count = 1;\n\n          while (line.charAt(index + 1) === character) {\n            cell += character;\n            index++;\n            count++;\n          }\n\n          if (!opening) {\n            opening = count;\n          } else if (count >= opening) {\n            opening = 0;\n          }\n        }\n      }\n\n      preamble = false;\n      index++;\n    }\n    /* Eat the alignment row. */\n\n\n    if (!position) {\n      eat(C_NEWLINE + alignments);\n    }\n  }\n\n  return table;\n}","'use strict';\n\nmodule.exports = visitParents;\n\nvar is = require('unist-util-is');\n\nvar CONTINUE = true;\nvar SKIP = 'skip';\nvar EXIT = false;\nvisitParents.CONTINUE = CONTINUE;\nvisitParents.SKIP = SKIP;\nvisitParents.EXIT = EXIT;\n\nfunction visitParents(tree, test, visitor, reverse) {\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor;\n    visitor = test;\n    test = null;\n  }\n\n  one(tree, null, []); // Visit a single node.\n\n  function one(node, index, parents) {\n    var result;\n\n    if (!test || is(test, node, index, parents[parents.length - 1] || null)) {\n      result = visitor(node, parents);\n\n      if (result === EXIT) {\n        return result;\n      }\n    }\n\n    if (node.children && result !== SKIP) {\n      return all(node.children, parents.concat(node)) === EXIT ? EXIT : result;\n    }\n\n    return result;\n  } // Visit children in `parent`.\n\n\n  function all(children, parents) {\n    var min = -1;\n    var step = reverse ? -1 : 1;\n    var index = (reverse ? children.length : min) + step;\n    var child;\n    var result;\n\n    while (index > min && index < children.length) {\n      child = children[index];\n      result = child && one(child, index, parents);\n\n      if (result === EXIT) {\n        return result;\n      }\n\n      index = typeof result === 'number' ? result : index + step;\n    }\n  }\n}","// extracted by mini-css-extract-plugin\nmodule.exports = {\"variables\":\"\\\"../layouts/variables.css\\\"\",\"grey\":\"#9c9c9c\",\"pink\":\"#ff00cc\",\"blue\":\"#00ccff\",\"gradientGrey\":\"linear-gradient(-45deg, #c5c5c5, #9c9c9c)\",\"iconSize\":\"20px\",\"gradient\":\"linear-gradient(-45deg, #00ccff, #ff00cc, #ff6600, #0055d4)\",\"gradientSize\":\"200% 200%\",\"gradientPosition\":\"100% 30%\",\"contentPadding\":\"120px\",\"breakMobile\":\"419px\",\"breakTablet\":\"767px\",\"contentPaddingMobile\":\"40px\",\"contentPaddingTablet\":\"80px\",\"topSection\":\"index-module--topSection--1-YPq\",\"social\":\"index-module--social--2NDmj\",\"section\":\"index-module--section--2nAm5\"};","'use strict';\n\nvar whitespace = require('is-whitespace-character');\n\nvar locate = require('../locate/link');\n\nvar normalize = require('../util/normalize');\n\nmodule.exports = reference;\nreference.locator = locate;\nvar T_LINK = 'link';\nvar T_IMAGE = 'image';\nvar T_FOOTNOTE = 'footnote';\nvar REFERENCE_TYPE_SHORTCUT = 'shortcut';\nvar REFERENCE_TYPE_COLLAPSED = 'collapsed';\nvar REFERENCE_TYPE_FULL = 'full';\nvar C_CARET = '^';\nvar C_BACKSLASH = '\\\\';\nvar C_BRACKET_OPEN = '[';\nvar C_BRACKET_CLOSE = ']';\n\nfunction reference(eat, value, silent) {\n  var self = this;\n  var character = value.charAt(0);\n  var index = 0;\n  var length = value.length;\n  var subvalue = '';\n  var intro = '';\n  var type = T_LINK;\n  var referenceType = REFERENCE_TYPE_SHORTCUT;\n  var content;\n  var identifier;\n  var now;\n  var node;\n  var exit;\n  var queue;\n  var bracketed;\n  var depth;\n  /* Check whether we’re eating an image. */\n\n  if (character === '!') {\n    type = T_IMAGE;\n    intro = character;\n    character = value.charAt(++index);\n  }\n\n  if (character !== C_BRACKET_OPEN) {\n    return;\n  }\n\n  index++;\n  intro += character;\n  queue = '';\n  /* Check whether we’re eating a footnote. */\n\n  if (self.options.footnotes && value.charAt(index) === C_CARET) {\n    /* Exit if `![^` is found, so the `!` will be seen as text after this,\n     * and we’ll enter this function again when `[^` is found. */\n    if (type === T_IMAGE) {\n      return;\n    }\n\n    intro += C_CARET;\n    index++;\n    type = T_FOOTNOTE;\n  }\n  /* Eat the text. */\n\n\n  depth = 0;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character === C_BRACKET_OPEN) {\n      bracketed = true;\n      depth++;\n    } else if (character === C_BRACKET_CLOSE) {\n      if (!depth) {\n        break;\n      }\n\n      depth--;\n    }\n\n    if (character === C_BACKSLASH) {\n      queue += C_BACKSLASH;\n      character = value.charAt(++index);\n    }\n\n    queue += character;\n    index++;\n  }\n\n  subvalue = queue;\n  content = queue;\n  character = value.charAt(index);\n\n  if (character !== C_BRACKET_CLOSE) {\n    return;\n  }\n\n  index++;\n  subvalue += character;\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (!whitespace(character)) {\n      break;\n    }\n\n    queue += character;\n    index++;\n  }\n\n  character = value.charAt(index);\n  /* Inline footnotes cannot have an identifier. */\n\n  if (type !== T_FOOTNOTE && character === C_BRACKET_OPEN) {\n    identifier = '';\n    queue += character;\n    index++;\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character === C_BRACKET_OPEN || character === C_BRACKET_CLOSE) {\n        break;\n      }\n\n      if (character === C_BACKSLASH) {\n        identifier += C_BACKSLASH;\n        character = value.charAt(++index);\n      }\n\n      identifier += character;\n      index++;\n    }\n\n    character = value.charAt(index);\n\n    if (character === C_BRACKET_CLOSE) {\n      referenceType = identifier ? REFERENCE_TYPE_FULL : REFERENCE_TYPE_COLLAPSED;\n      queue += identifier + character;\n      index++;\n    } else {\n      identifier = '';\n    }\n\n    subvalue += queue;\n    queue = '';\n  } else {\n    if (!content) {\n      return;\n    }\n\n    identifier = content;\n  }\n  /* Brackets cannot be inside the identifier. */\n\n\n  if (referenceType !== REFERENCE_TYPE_FULL && bracketed) {\n    return;\n  }\n\n  subvalue = intro + subvalue;\n\n  if (type === T_LINK && self.inLink) {\n    return null;\n  }\n  /* istanbul ignore if - never used (yet) */\n\n\n  if (silent) {\n    return true;\n  }\n\n  if (type === T_FOOTNOTE && content.indexOf(' ') !== -1) {\n    return eat(subvalue)({\n      type: 'footnote',\n      children: this.tokenizeInline(content, eat.now())\n    });\n  }\n\n  now = eat.now();\n  now.column += intro.length;\n  now.offset += intro.length;\n  identifier = referenceType === REFERENCE_TYPE_FULL ? identifier : content;\n  node = {\n    type: type + 'Reference',\n    identifier: normalize(identifier)\n  };\n\n  if (type === T_LINK || type === T_IMAGE) {\n    node.referenceType = referenceType;\n  }\n\n  if (type === T_LINK) {\n    exit = self.enterLink();\n    node.children = self.tokenizeInline(content, now);\n    exit();\n  } else if (type === T_IMAGE) {\n    node.alt = self.decode.raw(self.unescape(content), now) || null;\n  }\n\n  return eat(subvalue)(node);\n}","var visitWithParents = require('unist-util-visit-parents');\n\nfunction addListMetadata() {\n  return function (ast) {\n    visitWithParents(ast, 'list', function (listNode, parents) {\n      var depth = 0,\n          i,\n          n;\n\n      for (i = 0, n = parents.length; i < n; i++) {\n        if (parents[i].type === 'list') depth += 1;\n      }\n\n      for (i = 0, n = listNode.children.length; i < n; i++) {\n        var child = listNode.children[i];\n        child.index = i;\n        child.ordered = listNode.ordered;\n      }\n\n      listNode.depth = depth;\n    });\n    return ast;\n  };\n}\n\nmodule.exports = addListMetadata;","'use strict';\n\nvar wrap = require('./wrap.js');\n\nmodule.exports = trough;\ntrough.wrap = wrap;\nvar slice = [].slice;\n/* Create new middleware. */\n\nfunction trough() {\n  var fns = [];\n  var middleware = {};\n  middleware.run = run;\n  middleware.use = use;\n  return middleware;\n  /* Run `fns`.  Last argument must be\n   * a completion handler. */\n\n  function run() {\n    var index = -1;\n    var input = slice.call(arguments, 0, -1);\n    var done = arguments[arguments.length - 1];\n\n    if (typeof done !== 'function') {\n      throw new Error('Expected function as last argument, not ' + done);\n    }\n\n    next.apply(null, [null].concat(input));\n    /* Run the next `fn`, if any. */\n\n    function next(err) {\n      var fn = fns[++index];\n      var params = slice.call(arguments, 0);\n      var values = params.slice(1);\n      var length = input.length;\n      var pos = -1;\n\n      if (err) {\n        done(err);\n        return;\n      }\n      /* Copy non-nully input into values. */\n\n\n      while (++pos < length) {\n        if (values[pos] === null || values[pos] === undefined) {\n          values[pos] = input[pos];\n        }\n      }\n\n      input = values;\n      /* Next or done. */\n\n      if (fn) {\n        wrap(fn, next).apply(null, input);\n      } else {\n        done.apply(null, [null].concat(input));\n      }\n    }\n  }\n  /* Add `fn` to the list. */\n\n\n  function use(fn) {\n    if (typeof fn !== 'function') {\n      throw new Error('Expected `fn` to be a function, not ' + fn);\n    }\n\n    fns.push(fn);\n    return middleware;\n  }\n}","'use strict';\n\nvar xtend = require('xtend');\n\nvar removePosition = require('unist-util-remove-position');\n\nmodule.exports = parse;\nvar C_NEWLINE = '\\n';\nvar EXPRESSION_LINE_BREAKS = /\\r\\n|\\r/g;\n/* Parse the bound file. */\n\nfunction parse() {\n  var self = this;\n  var value = String(self.file);\n  var start = {\n    line: 1,\n    column: 1,\n    offset: 0\n  };\n  var content = xtend(start);\n  var node;\n  /* Clean non-unix newlines: `\\r\\n` and `\\r` are all\n   * changed to `\\n`.  This should not affect positional\n   * information. */\n\n  value = value.replace(EXPRESSION_LINE_BREAKS, C_NEWLINE);\n\n  if (value.charCodeAt(0) === 0xFEFF) {\n    value = value.slice(1);\n    content.column++;\n    content.offset++;\n  }\n\n  node = {\n    type: 'root',\n    children: self.tokenizeBlock(value, content),\n    position: {\n      start: start,\n      end: self.eof || xtend(start)\n    }\n  };\n\n  if (!self.options.position) {\n    removePosition(node, true);\n  }\n\n  return node;\n}"],"sourceRoot":""}