{"version":3,"sources":["webpack:///./node_modules/gatsby-image/index.js","webpack:///./node_modules/prismjs/components/prism-javascript.js","webpack:///./node_modules/prismjs/components/prism-yaml.js","webpack:///./src/components/ContentBox/styled.ts","webpack:///./src/components/ContentBox/ContentBox.tsx","webpack:///./node_modules/prismjs/components/prism-typescript.js","webpack:///./node_modules/prismjs/prism.js"],"names":["_interopRequireDefault","require","exports","__esModule","default","io","_assertThisInitialized2","_inheritsLoose2","_objectWithoutPropertiesLoose2","_extends2","_react","_propTypes","convertProps","props","convertedProps","resolutions","sizes","critical","fixed","fluid","loading","groupByMedia","concat","matchesMedia","_ref","media","isBrowser","window","matchMedia","matches","getImageCacheKey","_ref2","srcData","getCurrentSrcData","src","currentData","Array","isArray","some","image","hasArtDirectionSupport","foundMedia","findIndex","noMedia","imageCache","Object","create","inImageCache","cacheKey","hasNativeLazyLoadSupport","HTMLImageElement","prototype","hasIOSupport","IntersectionObserver","listeners","WeakMap","generateImageSources","imageVariants","map","_ref3","srcSet","srcSetWebp","createElement","Fragment","key","type","withMedia","without","forEach","variant","push","generateTracedSVGSources","_ref4","tracedSVG","generateBase64Sources","_ref5","base64","generateNoscriptSource","_ref6","isWebp","listenToIntersections","el","cb","observer","entries","entry","has","target","get","isIntersecting","intersectionRatio","unobserve","delete","rootMargin","observe","set","noscriptImg","title","alt","width","height","crossOrigin","draggable","join","Placeholder","forwardRef","ref","generateSources","spreadProps","ariaHidden","baseImage","Img","length","style","onLoad","onError","otherProps","position","top","left","objectFit","objectPosition","propTypes","object","func","Image","_React$Component","_this","call","this","seenBefore","isCritical","addNoScript","fadeIn","useIOSupport","isVisible","state","imgLoaded","imgCached","isHydrated","imageRef","createRef","placeholderRef","handleImageLoaded","bind","handleRef","_proto","componentDidMount","setState","onStartLoad","wasCached","img","current","complete","componentWillUnmount","cleanUpListeners","_this2","imageInCache","currentSrc","render","_convertProps","className","_convertProps$style","_convertProps$imgStyl","imgStyle","_convertProps$placeho","placeholderStyle","placeholderClassName","backgroundColor","durationFadeIn","Tag","itemProp","shouldReveal","shouldFadeIn","imageStyle","opacity","transition","bgColor","delayHideStyle","transitionDelay","imagePlaceholderStyle","placeholderImageProps","overflow","maxWidth","maxHeight","JSON","stringify","paddingBottom","aspectRatio","bottom","right","dangerouslySetInnerHTML","__html","divStyle","display","Component","defaultProps","fixedObject","shape","number","isRequired","string","srcWebp","fluidObject","requireFixedOrFluid","originalPropTypes","propName","componentName","_PropTypes$checkPropT","Error","checkPropTypes","oneOfType","arrayOf","bool","oneOf","_default","Prism","languages","javascript","extend","clike","pattern","lookbehind","insertBefore","greedy","inside","alias","regex","rest","markup","tag","addInlined","js","anchorOrAlias","properties","source","plainKey","replace","createValuePattern","value","flags","RegExp","yaml","yml","InnerBox","styled","RebassBox","theme","breakpoints","Box","colors","content","background","border","borderRadius","boxShadow","font","body","sidebar","activeLink","link","ContentBox","children","useEffect","setTimeout","highlightAll","typescript","typeInside","ts","_self","lang","uniqueId","_","manual","disableWorkerMessageHandler","util","encode","tokens","Token","o","toString","slice","objId","obj","defineProperty","clone","deepClone","visited","id","hasOwnProperty","v","i","getLanguage","element","test","parentElement","match","toLowerCase","currentScript","document","err","exec","stack","scripts","getElementsByTagName","isActive","defaultActivation","no","classList","contains","redef","before","insert","root","grammar","ret","token","newToken","old","DFS","callback","property","propertyType","plugins","async","highlightAllUnder","container","env","selector","hooks","run","elements","apply","querySelectorAll","highlightElement","language","parent","nodeName","code","textContent","insertHighlightedCode","highlightedCode","innerHTML","Worker","worker","filename","onmessage","evt","data","postMessage","immediateClose","highlight","text","tokenize","tokenList","LinkedList","addAfter","head","matchGrammar","startNode","startPos","rematch","patterns","j","cause","patternObj","lookbehindLength","global","currentNode","next","pos","tail","reach","str","removeCount","prev","lastIndex","from","index","to","p","k","matchStr","after","removeFrom","removeRange","wrapped","list","array","node","toArray","all","add","name","callbacks","matchedStr","newNode","count","s","e","classes","attributes","aliases","addEventListener","message","parse","close","script","highlightAutomaticallyCallback","hasAttribute","readyState","defer","requestAnimationFrame","WorkerGlobalScope","self","module","tagName","includedCdataInside","def","html","mathml","svg","xml","ssml","atom","rss","css","EXTENSIONS","SELECTOR","pre","setAttribute","appendChild","getAttribute","extension","setLanguageClass","autoloader","loadLanguages","xhr","XMLHttpRequest","open","onreadystatechange","status","responseText","statusText","send","fileHighlight","logged","console","warn","arguments","trim"],"mappings":"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","file":"e433ba68677b7ce14f39167c1b30269630c25389-f6ca0e4a21401b01abda.js","sourcesContent":["\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nexports.__esModule = true;\nexports.default = void 0;\n\nvar _assertThisInitialized2 = _interopRequireDefault(require(\"@babel/runtime/helpers/assertThisInitialized\"));\n\nvar _inheritsLoose2 = _interopRequireDefault(require(\"@babel/runtime/helpers/inheritsLoose\"));\n\nvar _objectWithoutPropertiesLoose2 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectWithoutPropertiesLoose\"));\n\nvar _extends2 = _interopRequireDefault(require(\"@babel/runtime/helpers/extends\"));\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar logDeprecationNotice = function logDeprecationNotice(prop, replacement) {\n  if (process.env.NODE_ENV === \"production\") {\n    return;\n  }\n\n  console.log(\"\\n    The \\\"\" + prop + \"\\\" prop is now deprecated and will be removed in the next major version\\n    of \\\"gatsby-image\\\".\\n    \");\n\n  if (replacement) {\n    console.log(\"Please use \" + replacement + \" instead of \\\"\" + prop + \"\\\".\");\n  }\n}; // Handle legacy props during their deprecation phase\n\n\nvar convertProps = function convertProps(props) {\n  var convertedProps = (0, _extends2.default)({}, props);\n  var resolutions = convertedProps.resolutions,\n      sizes = convertedProps.sizes,\n      critical = convertedProps.critical;\n\n  if (resolutions) {\n    convertedProps.fixed = resolutions;\n    logDeprecationNotice(\"resolutions\", \"the gatsby-image v2 prop \\\"fixed\\\"\");\n    delete convertedProps.resolutions;\n  }\n\n  if (sizes) {\n    convertedProps.fluid = sizes;\n    logDeprecationNotice(\"sizes\", \"the gatsby-image v2 prop \\\"fluid\\\"\");\n    delete convertedProps.sizes;\n  }\n\n  if (critical) {\n    logDeprecationNotice(\"critical\", \"the native \\\"loading\\\" attribute\");\n    convertedProps.loading = \"eager\";\n  } // convert fluid & fixed to arrays so we only have to work with arrays\n\n\n  if (convertedProps.fluid) {\n    convertedProps.fluid = groupByMedia([].concat(convertedProps.fluid));\n  }\n\n  if (convertedProps.fixed) {\n    convertedProps.fixed = groupByMedia([].concat(convertedProps.fixed));\n  }\n\n  return convertedProps;\n};\n/**\n * Checks if fluid or fixed are art-direction arrays.\n *\n * @param currentData  {{media?: string}[]}   The props to check for images.\n * @return {boolean}\n */\n\n\nvar hasArtDirectionSupport = function hasArtDirectionSupport(currentData) {\n  return !!currentData && Array.isArray(currentData) && currentData.some(function (image) {\n    return typeof image.media !== \"undefined\";\n  });\n};\n/**\n * Tries to detect if a media query matches the current viewport.\n * @property media   {{media?: string}}  A media query string.\n * @return {boolean}\n */\n\n\nvar matchesMedia = function matchesMedia(_ref) {\n  var media = _ref.media;\n  return media ? isBrowser && !!window.matchMedia(media).matches : false;\n};\n/**\n * Find the source of an image to use as a key in the image cache.\n * Use `the first image in either `fixed` or `fluid`\n * @param {{fluid: {src: string, media?: string}[], fixed: {src: string, media?: string}[]}} args\n * @return {string?} Returns image src or undefined it not given.\n */\n\n\nvar getImageCacheKey = function getImageCacheKey(_ref2) {\n  var fluid = _ref2.fluid,\n      fixed = _ref2.fixed;\n  var srcData = getCurrentSrcData(fluid || fixed || []);\n  return srcData && srcData.src;\n};\n/**\n * Returns the current src - Preferably with art-direction support.\n * @param currentData  {{media?: string}[], maxWidth?: Number, maxHeight?: Number}   The fluid or fixed image array.\n * @return {{src: string, media?: string, maxWidth?: Number, maxHeight?: Number}}\n */\n\n\nvar getCurrentSrcData = function getCurrentSrcData(currentData) {\n  if (isBrowser && hasArtDirectionSupport(currentData)) {\n    // Do we have an image for the current Viewport?\n    var foundMedia = currentData.findIndex(matchesMedia);\n\n    if (foundMedia !== -1) {\n      return currentData[foundMedia];\n    } // No media matches, select first element without a media condition\n\n\n    var noMedia = currentData.findIndex(function (image) {\n      return typeof image.media === \"undefined\";\n    });\n\n    if (noMedia !== -1) {\n      return currentData[noMedia];\n    }\n  } // Else return the first image.\n\n\n  return currentData[0];\n}; // Cache if we've seen an image before so we don't bother with\n// lazy-loading & fading in on subsequent mounts.\n\n\nvar imageCache = Object.create({});\n\nvar inImageCache = function inImageCache(props) {\n  var convertedProps = convertProps(props);\n  var cacheKey = getImageCacheKey(convertedProps);\n  return imageCache[cacheKey] || false;\n};\n\nvar activateCacheForImage = function activateCacheForImage(props) {\n  var convertedProps = convertProps(props);\n  var cacheKey = getImageCacheKey(convertedProps);\n\n  if (cacheKey) {\n    imageCache[cacheKey] = true;\n  }\n}; // Native lazy-loading support: https://addyosmani.com/blog/lazy-loading/\n\n\nvar hasNativeLazyLoadSupport = typeof HTMLImageElement !== \"undefined\" && \"loading\" in HTMLImageElement.prototype;\nvar isBrowser = typeof window !== \"undefined\";\nvar hasIOSupport = isBrowser && window.IntersectionObserver;\nvar io;\nvar listeners = new WeakMap();\n\nfunction getIO() {\n  if (typeof io === \"undefined\" && typeof window !== \"undefined\" && window.IntersectionObserver) {\n    io = new window.IntersectionObserver(function (entries) {\n      entries.forEach(function (entry) {\n        if (listeners.has(entry.target)) {\n          var cb = listeners.get(entry.target); // Edge doesn't currently support isIntersecting, so also test for an intersectionRatio > 0\n\n          if (entry.isIntersecting || entry.intersectionRatio > 0) {\n            io.unobserve(entry.target);\n            listeners.delete(entry.target);\n            cb();\n          }\n        }\n      });\n    }, {\n      rootMargin: \"200px\"\n    });\n  }\n\n  return io;\n}\n\nfunction generateImageSources(imageVariants) {\n  return imageVariants.map(function (_ref3) {\n    var src = _ref3.src,\n        srcSet = _ref3.srcSet,\n        srcSetWebp = _ref3.srcSetWebp,\n        media = _ref3.media,\n        sizes = _ref3.sizes;\n    return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, {\n      key: src\n    }, srcSetWebp && /*#__PURE__*/_react.default.createElement(\"source\", {\n      type: \"image/webp\",\n      media: media,\n      srcSet: srcSetWebp,\n      sizes: sizes\n    }), srcSet && /*#__PURE__*/_react.default.createElement(\"source\", {\n      media: media,\n      srcSet: srcSet,\n      sizes: sizes\n    }));\n  });\n} // Return an array ordered by elements having a media prop, does not use\n// native sort, as a stable sort is not guaranteed by all browsers/versions\n\n\nfunction groupByMedia(imageVariants) {\n  var withMedia = [];\n  var without = [];\n  imageVariants.forEach(function (variant) {\n    return (variant.media ? withMedia : without).push(variant);\n  });\n\n  if (without.length > 1 && process.env.NODE_ENV !== \"production\") {\n    console.warn(\"We've found \" + without.length + \" sources without a media property. They might be ignored by the browser, see: https://www.gatsbyjs.org/packages/gatsby-image/#art-directing-multiple-images\");\n  }\n\n  return [].concat(withMedia, without);\n}\n\nfunction generateTracedSVGSources(imageVariants) {\n  return imageVariants.map(function (_ref4) {\n    var src = _ref4.src,\n        media = _ref4.media,\n        tracedSVG = _ref4.tracedSVG;\n    return /*#__PURE__*/_react.default.createElement(\"source\", {\n      key: src,\n      media: media,\n      srcSet: tracedSVG\n    });\n  });\n}\n\nfunction generateBase64Sources(imageVariants) {\n  return imageVariants.map(function (_ref5) {\n    var src = _ref5.src,\n        media = _ref5.media,\n        base64 = _ref5.base64;\n    return /*#__PURE__*/_react.default.createElement(\"source\", {\n      key: src,\n      media: media,\n      srcSet: base64\n    });\n  });\n}\n\nfunction generateNoscriptSource(_ref6, isWebp) {\n  var srcSet = _ref6.srcSet,\n      srcSetWebp = _ref6.srcSetWebp,\n      media = _ref6.media,\n      sizes = _ref6.sizes;\n  var src = isWebp ? srcSetWebp : srcSet;\n  var mediaAttr = media ? \"media=\\\"\" + media + \"\\\" \" : \"\";\n  var typeAttr = isWebp ? \"type='image/webp' \" : \"\";\n  var sizesAttr = sizes ? \"sizes=\\\"\" + sizes + \"\\\" \" : \"\";\n  return \"<source \" + typeAttr + mediaAttr + \"srcset=\\\"\" + src + \"\\\" \" + sizesAttr + \"/>\";\n}\n\nfunction generateNoscriptSources(imageVariants) {\n  return imageVariants.map(function (variant) {\n    return (variant.srcSetWebp ? generateNoscriptSource(variant, true) : \"\") + generateNoscriptSource(variant);\n  }).join(\"\");\n}\n\nvar listenToIntersections = function listenToIntersections(el, cb) {\n  var observer = getIO();\n\n  if (observer) {\n    observer.observe(el);\n    listeners.set(el, cb);\n  }\n\n  return function () {\n    observer.unobserve(el);\n    listeners.delete(el);\n  };\n};\n\nvar noscriptImg = function noscriptImg(props) {\n  // Check if prop exists before adding each attribute to the string output below to prevent\n  // HTML validation issues caused by empty values like width=\"\" and height=\"\"\n  var src = props.src ? \"src=\\\"\" + props.src + \"\\\" \" : \"src=\\\"\\\" \"; // required attribute\n\n  var sizes = props.sizes ? \"sizes=\\\"\" + props.sizes + \"\\\" \" : \"\";\n  var srcSet = props.srcSet ? \"srcset=\\\"\" + props.srcSet + \"\\\" \" : \"\";\n  var title = props.title ? \"title=\\\"\" + props.title + \"\\\" \" : \"\";\n  var alt = props.alt ? \"alt=\\\"\" + props.alt + \"\\\" \" : \"alt=\\\"\\\" \"; // required attribute\n\n  var width = props.width ? \"width=\\\"\" + props.width + \"\\\" \" : \"\";\n  var height = props.height ? \"height=\\\"\" + props.height + \"\\\" \" : \"\";\n  var crossOrigin = props.crossOrigin ? \"crossorigin=\\\"\" + props.crossOrigin + \"\\\" \" : \"\";\n  var loading = props.loading ? \"loading=\\\"\" + props.loading + \"\\\" \" : \"\";\n  var draggable = props.draggable ? \"draggable=\\\"\" + props.draggable + \"\\\" \" : \"\";\n  var sources = generateNoscriptSources(props.imageVariants);\n  return \"<picture>\" + sources + \"<img \" + loading + width + height + sizes + srcSet + src + alt + title + crossOrigin + draggable + \"style=\\\"position:absolute;top:0;left:0;opacity:1;width:100%;height:100%;object-fit:cover;object-position:center\\\"/></picture>\";\n}; // Earlier versions of gatsby-image during the 2.x cycle did not wrap\n// the `Img` component in a `picture` element. This maintains compatibility\n// until a breaking change can be introduced in the next major release\n\n\nvar Placeholder = /*#__PURE__*/_react.default.forwardRef(function (props, ref) {\n  var src = props.src,\n      imageVariants = props.imageVariants,\n      generateSources = props.generateSources,\n      spreadProps = props.spreadProps,\n      ariaHidden = props.ariaHidden;\n\n  var baseImage = /*#__PURE__*/_react.default.createElement(Img, (0, _extends2.default)({\n    ref: ref,\n    src: src\n  }, spreadProps, {\n    ariaHidden: ariaHidden\n  }));\n\n  return imageVariants.length > 1 ? /*#__PURE__*/_react.default.createElement(\"picture\", null, generateSources(imageVariants), baseImage) : baseImage;\n});\n\nvar Img = /*#__PURE__*/_react.default.forwardRef(function (props, ref) {\n  var sizes = props.sizes,\n      srcSet = props.srcSet,\n      src = props.src,\n      style = props.style,\n      onLoad = props.onLoad,\n      onError = props.onError,\n      loading = props.loading,\n      draggable = props.draggable,\n      ariaHidden = props.ariaHidden,\n      otherProps = (0, _objectWithoutPropertiesLoose2.default)(props, [\"sizes\", \"srcSet\", \"src\", \"style\", \"onLoad\", \"onError\", \"loading\", \"draggable\", \"ariaHidden\"]);\n  return /*#__PURE__*/_react.default.createElement(\"img\", (0, _extends2.default)({\n    \"aria-hidden\": ariaHidden,\n    sizes: sizes,\n    srcSet: srcSet,\n    src: src\n  }, otherProps, {\n    onLoad: onLoad,\n    onError: onError,\n    ref: ref,\n    loading: loading,\n    draggable: draggable,\n    style: (0, _extends2.default)({\n      position: \"absolute\",\n      top: 0,\n      left: 0,\n      width: \"100%\",\n      height: \"100%\",\n      objectFit: \"cover\",\n      objectPosition: \"center\"\n    }, style)\n  }));\n});\n\nImg.propTypes = {\n  style: _propTypes.default.object,\n  onError: _propTypes.default.func,\n  onLoad: _propTypes.default.func\n};\n\nvar Image = /*#__PURE__*/function (_React$Component) {\n  (0, _inheritsLoose2.default)(Image, _React$Component);\n\n  function Image(props) {\n    var _this;\n\n    _this = _React$Component.call(this, props) || this; // If this image has already been loaded before then we can assume it's\n    // already in the browser cache so it's cheap to just show directly.\n\n    _this.seenBefore = isBrowser && inImageCache(props);\n    _this.isCritical = props.loading === \"eager\" || props.critical;\n    _this.addNoScript = !(_this.isCritical && !props.fadeIn);\n    _this.useIOSupport = !hasNativeLazyLoadSupport && hasIOSupport && !_this.isCritical && !_this.seenBefore;\n    var isVisible = _this.isCritical || isBrowser && (hasNativeLazyLoadSupport || !_this.useIOSupport);\n    _this.state = {\n      isVisible: isVisible,\n      imgLoaded: false,\n      imgCached: false,\n      fadeIn: !_this.seenBefore && props.fadeIn,\n      isHydrated: false\n    };\n    _this.imageRef = /*#__PURE__*/_react.default.createRef();\n    _this.placeholderRef = props.placeholderRef || /*#__PURE__*/_react.default.createRef();\n    _this.handleImageLoaded = _this.handleImageLoaded.bind((0, _assertThisInitialized2.default)(_this));\n    _this.handleRef = _this.handleRef.bind((0, _assertThisInitialized2.default)(_this));\n    return _this;\n  }\n\n  var _proto = Image.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    this.setState({\n      isHydrated: isBrowser\n    });\n\n    if (this.state.isVisible && typeof this.props.onStartLoad === \"function\") {\n      this.props.onStartLoad({\n        wasCached: inImageCache(this.props)\n      });\n    }\n\n    if (this.isCritical) {\n      var img = this.imageRef.current;\n\n      if (img && img.complete) {\n        this.handleImageLoaded();\n      }\n    }\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    if (this.cleanUpListeners) {\n      this.cleanUpListeners();\n    }\n  } // Specific to IntersectionObserver based lazy-load support\n  ;\n\n  _proto.handleRef = function handleRef(ref) {\n    var _this2 = this;\n\n    if (this.useIOSupport && ref) {\n      this.cleanUpListeners = listenToIntersections(ref, function () {\n        var imageInCache = inImageCache(_this2.props);\n\n        if (!_this2.state.isVisible && typeof _this2.props.onStartLoad === \"function\") {\n          _this2.props.onStartLoad({\n            wasCached: imageInCache\n          });\n        } // imgCached and imgLoaded must update after isVisible,\n        // Once isVisible is true, imageRef becomes accessible, which imgCached needs access to.\n        // imgLoaded and imgCached are in a 2nd setState call to be changed together,\n        // avoiding initiating unnecessary animation frames from style changes.\n\n\n        _this2.setState({\n          isVisible: true\n        }, function () {\n          _this2.setState({\n            imgLoaded: imageInCache,\n            // `currentSrc` should be a string, but can be `undefined` in IE,\n            // !! operator validates the value is not undefined/null/\"\"\n            // for lazyloaded components this might be null\n            // TODO fix imgCached behaviour as it's now false when it's lazyloaded\n            imgCached: !!(_this2.imageRef.current && _this2.imageRef.current.currentSrc)\n          });\n        });\n      });\n    }\n  };\n\n  _proto.handleImageLoaded = function handleImageLoaded() {\n    activateCacheForImage(this.props);\n    this.setState({\n      imgLoaded: true\n    });\n\n    if (this.props.onLoad) {\n      this.props.onLoad();\n    }\n  };\n\n  _proto.render = function render() {\n    var _convertProps = convertProps(this.props),\n        title = _convertProps.title,\n        alt = _convertProps.alt,\n        className = _convertProps.className,\n        _convertProps$style = _convertProps.style,\n        style = _convertProps$style === void 0 ? {} : _convertProps$style,\n        _convertProps$imgStyl = _convertProps.imgStyle,\n        imgStyle = _convertProps$imgStyl === void 0 ? {} : _convertProps$imgStyl,\n        _convertProps$placeho = _convertProps.placeholderStyle,\n        placeholderStyle = _convertProps$placeho === void 0 ? {} : _convertProps$placeho,\n        placeholderClassName = _convertProps.placeholderClassName,\n        fluid = _convertProps.fluid,\n        fixed = _convertProps.fixed,\n        backgroundColor = _convertProps.backgroundColor,\n        durationFadeIn = _convertProps.durationFadeIn,\n        Tag = _convertProps.Tag,\n        itemProp = _convertProps.itemProp,\n        loading = _convertProps.loading,\n        draggable = _convertProps.draggable;\n\n    var imageVariants = fluid || fixed; // Abort early if missing image data (#25371)\n\n    if (!imageVariants) {\n      return null;\n    }\n\n    var shouldReveal = this.state.fadeIn === false || this.state.imgLoaded;\n    var shouldFadeIn = this.state.fadeIn === true && !this.state.imgCached;\n    var imageStyle = (0, _extends2.default)({\n      opacity: shouldReveal ? 1 : 0,\n      transition: shouldFadeIn ? \"opacity \" + durationFadeIn + \"ms\" : \"none\"\n    }, imgStyle);\n    var bgColor = typeof backgroundColor === \"boolean\" ? \"lightgray\" : backgroundColor;\n    var delayHideStyle = {\n      transitionDelay: durationFadeIn + \"ms\"\n    };\n    var imagePlaceholderStyle = (0, _extends2.default)({\n      opacity: this.state.imgLoaded ? 0 : 1\n    }, shouldFadeIn && delayHideStyle, imgStyle, placeholderStyle);\n    var placeholderImageProps = {\n      title: title,\n      alt: !this.state.isVisible ? alt : \"\",\n      style: imagePlaceholderStyle,\n      className: placeholderClassName,\n      itemProp: itemProp\n    }; // Initial client render state needs to match SSR until hydration finishes.\n    // Once hydration completes, render again to update to the correct image.\n    // `imageVariants` is always an Array type at this point due to `convertProps()`\n\n    var image = !this.state.isHydrated ? imageVariants[0] : getCurrentSrcData(imageVariants);\n\n    if (fluid) {\n      return /*#__PURE__*/_react.default.createElement(Tag, {\n        className: (className ? className : \"\") + \" gatsby-image-wrapper\",\n        style: (0, _extends2.default)({\n          position: \"relative\",\n          overflow: \"hidden\",\n          maxWidth: image.maxWidth ? image.maxWidth + \"px\" : null,\n          maxHeight: image.maxHeight ? image.maxHeight + \"px\" : null\n        }, style),\n        ref: this.handleRef,\n        key: \"fluid-\" + JSON.stringify(image.srcSet)\n      }, /*#__PURE__*/_react.default.createElement(Tag, {\n        \"aria-hidden\": true,\n        style: {\n          width: \"100%\",\n          paddingBottom: 100 / image.aspectRatio + \"%\"\n        }\n      }), bgColor && /*#__PURE__*/_react.default.createElement(Tag, {\n        \"aria-hidden\": true,\n        title: title,\n        style: (0, _extends2.default)({\n          backgroundColor: bgColor,\n          position: \"absolute\",\n          top: 0,\n          bottom: 0,\n          opacity: !this.state.imgLoaded ? 1 : 0,\n          right: 0,\n          left: 0\n        }, shouldFadeIn && delayHideStyle)\n      }), image.base64 && /*#__PURE__*/_react.default.createElement(Placeholder, {\n        ariaHidden: true,\n        ref: this.placeholderRef,\n        src: image.base64,\n        spreadProps: placeholderImageProps,\n        imageVariants: imageVariants,\n        generateSources: generateBase64Sources\n      }), image.tracedSVG && /*#__PURE__*/_react.default.createElement(Placeholder, {\n        ariaHidden: true,\n        ref: this.placeholderRef,\n        src: image.tracedSVG,\n        spreadProps: placeholderImageProps,\n        imageVariants: imageVariants,\n        generateSources: generateTracedSVGSources\n      }), this.state.isVisible && /*#__PURE__*/_react.default.createElement(\"picture\", null, generateImageSources(imageVariants), /*#__PURE__*/_react.default.createElement(Img, {\n        alt: alt,\n        title: title,\n        sizes: image.sizes,\n        src: image.src,\n        crossOrigin: this.props.crossOrigin,\n        srcSet: image.srcSet,\n        style: imageStyle,\n        ref: this.imageRef,\n        onLoad: this.handleImageLoaded,\n        onError: this.props.onError,\n        itemProp: itemProp,\n        loading: loading,\n        draggable: draggable\n      })), this.addNoScript && /*#__PURE__*/_react.default.createElement(\"noscript\", {\n        dangerouslySetInnerHTML: {\n          __html: noscriptImg((0, _extends2.default)({\n            alt: alt,\n            title: title,\n            loading: loading\n          }, image, {\n            imageVariants: imageVariants\n          }))\n        }\n      }));\n    }\n\n    if (fixed) {\n      var divStyle = (0, _extends2.default)({\n        position: \"relative\",\n        overflow: \"hidden\",\n        display: \"inline-block\",\n        width: image.width,\n        height: image.height\n      }, style);\n\n      if (style.display === \"inherit\") {\n        delete divStyle.display;\n      }\n\n      return /*#__PURE__*/_react.default.createElement(Tag, {\n        className: (className ? className : \"\") + \" gatsby-image-wrapper\",\n        style: divStyle,\n        ref: this.handleRef,\n        key: \"fixed-\" + JSON.stringify(image.srcSet)\n      }, bgColor && /*#__PURE__*/_react.default.createElement(Tag, {\n        \"aria-hidden\": true,\n        title: title,\n        style: (0, _extends2.default)({\n          backgroundColor: bgColor,\n          width: image.width,\n          opacity: !this.state.imgLoaded ? 1 : 0,\n          height: image.height\n        }, shouldFadeIn && delayHideStyle)\n      }), image.base64 && /*#__PURE__*/_react.default.createElement(Placeholder, {\n        ariaHidden: true,\n        ref: this.placeholderRef,\n        src: image.base64,\n        spreadProps: placeholderImageProps,\n        imageVariants: imageVariants,\n        generateSources: generateBase64Sources\n      }), image.tracedSVG && /*#__PURE__*/_react.default.createElement(Placeholder, {\n        ariaHidden: true,\n        ref: this.placeholderRef,\n        src: image.tracedSVG,\n        spreadProps: placeholderImageProps,\n        imageVariants: imageVariants,\n        generateSources: generateTracedSVGSources\n      }), this.state.isVisible && /*#__PURE__*/_react.default.createElement(\"picture\", null, generateImageSources(imageVariants), /*#__PURE__*/_react.default.createElement(Img, {\n        alt: alt,\n        title: title,\n        width: image.width,\n        height: image.height,\n        sizes: image.sizes,\n        src: image.src,\n        crossOrigin: this.props.crossOrigin,\n        srcSet: image.srcSet,\n        style: imageStyle,\n        ref: this.imageRef,\n        onLoad: this.handleImageLoaded,\n        onError: this.props.onError,\n        itemProp: itemProp,\n        loading: loading,\n        draggable: draggable\n      })), this.addNoScript && /*#__PURE__*/_react.default.createElement(\"noscript\", {\n        dangerouslySetInnerHTML: {\n          __html: noscriptImg((0, _extends2.default)({\n            alt: alt,\n            title: title,\n            loading: loading\n          }, image, {\n            imageVariants: imageVariants\n          }))\n        }\n      }));\n    }\n\n    return null;\n  };\n\n  return Image;\n}(_react.default.Component);\n\nImage.defaultProps = {\n  fadeIn: true,\n  durationFadeIn: 500,\n  alt: \"\",\n  Tag: \"div\",\n  // We set it to `lazy` by default because it's best to default to a performant\n  // setting and let the user \"opt out\" to `eager`\n  loading: \"lazy\"\n};\n\nvar fixedObject = _propTypes.default.shape({\n  width: _propTypes.default.number.isRequired,\n  height: _propTypes.default.number.isRequired,\n  src: _propTypes.default.string.isRequired,\n  srcSet: _propTypes.default.string.isRequired,\n  base64: _propTypes.default.string,\n  tracedSVG: _propTypes.default.string,\n  srcWebp: _propTypes.default.string,\n  srcSetWebp: _propTypes.default.string,\n  media: _propTypes.default.string\n});\n\nvar fluidObject = _propTypes.default.shape({\n  aspectRatio: _propTypes.default.number.isRequired,\n  src: _propTypes.default.string.isRequired,\n  srcSet: _propTypes.default.string.isRequired,\n  sizes: _propTypes.default.string.isRequired,\n  base64: _propTypes.default.string,\n  tracedSVG: _propTypes.default.string,\n  srcWebp: _propTypes.default.string,\n  srcSetWebp: _propTypes.default.string,\n  media: _propTypes.default.string,\n  maxWidth: _propTypes.default.number,\n  maxHeight: _propTypes.default.number\n});\n\nfunction requireFixedOrFluid(originalPropTypes) {\n  return function (props, propName, componentName) {\n    var _PropTypes$checkPropT;\n\n    if (!props.fixed && !props.fluid) {\n      throw new Error(\"The prop `fluid` or `fixed` is marked as required in `\" + componentName + \"`, but their values are both `undefined`.\");\n    }\n\n    _propTypes.default.checkPropTypes((_PropTypes$checkPropT = {}, _PropTypes$checkPropT[propName] = originalPropTypes, _PropTypes$checkPropT), props, \"prop\", componentName);\n  };\n} // If you modify these propTypes, please don't forget to update following files as well:\n// https://github.com/gatsbyjs/gatsby/blob/master/packages/gatsby-image/index.d.ts\n// https://github.com/gatsbyjs/gatsby/blob/master/packages/gatsby-image/README.md#gatsby-image-props\n// https://github.com/gatsbyjs/gatsby/blob/master/docs/docs/gatsby-image.md#gatsby-image-props\n\n\nImage.propTypes = {\n  resolutions: fixedObject,\n  sizes: fluidObject,\n  fixed: requireFixedOrFluid(_propTypes.default.oneOfType([fixedObject, _propTypes.default.arrayOf(fixedObject)])),\n  fluid: requireFixedOrFluid(_propTypes.default.oneOfType([fluidObject, _propTypes.default.arrayOf(fluidObject)])),\n  fadeIn: _propTypes.default.bool,\n  durationFadeIn: _propTypes.default.number,\n  title: _propTypes.default.string,\n  alt: _propTypes.default.string,\n  className: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object]),\n  // Support Glamor's css prop.\n  critical: _propTypes.default.bool,\n  crossOrigin: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.bool]),\n  style: _propTypes.default.object,\n  imgStyle: _propTypes.default.object,\n  placeholderStyle: _propTypes.default.object,\n  placeholderClassName: _propTypes.default.string,\n  backgroundColor: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.bool]),\n  onLoad: _propTypes.default.func,\n  onError: _propTypes.default.func,\n  onStartLoad: _propTypes.default.func,\n  Tag: _propTypes.default.string,\n  itemProp: _propTypes.default.string,\n  loading: _propTypes.default.oneOf([\"auto\", \"lazy\", \"eager\"]),\n  draggable: _propTypes.default.bool\n};\nvar _default = Image;\nexports.default = _default;","Prism.languages.javascript = Prism.languages.extend('clike', {\n  'class-name': [Prism.languages.clike['class-name'], {\n    pattern: /(^|[^$\\w\\xA0-\\uFFFF])[_$A-Z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*(?=\\.(?:prototype|constructor))/,\n    lookbehind: true\n  }],\n  'keyword': [{\n    pattern: /((?:^|})\\s*)(?:catch|finally)\\b/,\n    lookbehind: true\n  }, {\n    pattern: /(^|[^.]|\\.\\.\\.\\s*)\\b(?:as|async(?=\\s*(?:function\\b|\\(|[$\\w\\xA0-\\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|for|from|function|(?:get|set)(?=\\s*[\\[$\\w\\xA0-\\uFFFF])|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\\b/,\n    lookbehind: true\n  }],\n  'number': /\\b(?:(?:0[xX](?:[\\dA-Fa-f](?:_[\\dA-Fa-f])?)+|0[bB](?:[01](?:_[01])?)+|0[oO](?:[0-7](?:_[0-7])?)+)n?|(?:\\d(?:_\\d)?)+n|NaN|Infinity)\\b|(?:\\b(?:\\d(?:_\\d)?)+\\.?(?:\\d(?:_\\d)?)*|\\B\\.(?:\\d(?:_\\d)?)+)(?:[Ee][+-]?(?:\\d(?:_\\d)?)+)?/,\n  // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)\n  'function': /#?[_$a-zA-Z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*(?=\\s*(?:\\.\\s*(?:apply|bind|call)\\s*)?\\()/,\n  'operator': /--|\\+\\+|\\*\\*=?|=>|&&=?|\\|\\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\\.{3}|\\?\\?=?|\\?\\.?|[~:]/\n});\nPrism.languages.javascript['class-name'][0].pattern = /(\\b(?:class|interface|extends|implements|instanceof|new)\\s+)[\\w.\\\\]+/;\nPrism.languages.insertBefore('javascript', 'keyword', {\n  'regex': {\n    pattern: /((?:^|[^$\\w\\xA0-\\uFFFF.\"'\\])\\s]|\\b(?:return|yield))\\s*)\\/(?:\\[(?:[^\\]\\\\\\r\\n]|\\\\.)*]|\\\\.|[^/\\\\\\[\\r\\n])+\\/[gimyus]{0,6}(?=(?:\\s|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/)*(?:$|[\\r\\n,.;:})\\]]|\\/\\/))/,\n    lookbehind: true,\n    greedy: true,\n    inside: {\n      'regex-source': {\n        pattern: /^(\\/)[\\s\\S]+(?=\\/[a-z]*$)/,\n        lookbehind: true,\n        alias: 'language-regex',\n        inside: Prism.languages.regex\n      },\n      'regex-flags': /[a-z]+$/,\n      'regex-delimiter': /^\\/|\\/$/\n    }\n  },\n  // This must be declared before keyword because we use \"function\" inside the look-forward\n  'function-variable': {\n    pattern: /#?[_$a-zA-Z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*(?=\\s*[=:]\\s*(?:async\\s*)?(?:\\bfunction\\b|(?:\\((?:[^()]|\\([^()]*\\))*\\)|[_$a-zA-Z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*)\\s*=>))/,\n    alias: 'function'\n  },\n  'parameter': [{\n    pattern: /(function(?:\\s+[_$A-Za-z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*)?\\s*\\(\\s*)(?!\\s)(?:[^()]|\\([^()]*\\))+?(?=\\s*\\))/,\n    lookbehind: true,\n    inside: Prism.languages.javascript\n  }, {\n    pattern: /[_$a-z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*(?=\\s*=>)/i,\n    inside: Prism.languages.javascript\n  }, {\n    pattern: /(\\(\\s*)(?!\\s)(?:[^()]|\\([^()]*\\))+?(?=\\s*\\)\\s*=>)/,\n    lookbehind: true,\n    inside: Prism.languages.javascript\n  }, {\n    pattern: /((?:\\b|\\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\\w\\xA0-\\uFFFF]))(?:[_$A-Za-z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*\\s*)\\(\\s*|\\]\\s*\\(\\s*)(?!\\s)(?:[^()]|\\([^()]*\\))+?(?=\\s*\\)\\s*\\{)/,\n    lookbehind: true,\n    inside: Prism.languages.javascript\n  }],\n  'constant': /\\b[A-Z](?:[A-Z_]|\\dx?)*\\b/\n});\nPrism.languages.insertBefore('javascript', 'string', {\n  'template-string': {\n    pattern: /`(?:\\\\[\\s\\S]|\\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})+}|(?!\\${)[^\\\\`])*`/,\n    greedy: true,\n    inside: {\n      'template-punctuation': {\n        pattern: /^`|`$/,\n        alias: 'string'\n      },\n      'interpolation': {\n        pattern: /((?:^|[^\\\\])(?:\\\\{2})*)\\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})+}/,\n        lookbehind: true,\n        inside: {\n          'interpolation-punctuation': {\n            pattern: /^\\${|}$/,\n            alias: 'punctuation'\n          },\n          rest: Prism.languages.javascript\n        }\n      },\n      'string': /[\\s\\S]+/\n    }\n  }\n});\n\nif (Prism.languages.markup) {\n  Prism.languages.markup.tag.addInlined('script', 'javascript');\n}\n\nPrism.languages.js = Prism.languages.javascript;","(function (Prism) {\n  // https://yaml.org/spec/1.2/spec.html#c-ns-anchor-property\n  // https://yaml.org/spec/1.2/spec.html#c-ns-alias-node\n  var anchorOrAlias = /[*&][^\\s[\\]{},]+/; // https://yaml.org/spec/1.2/spec.html#c-ns-tag-property\n\n  var tag = /!(?:<[\\w\\-%#;/?:@&=+$,.!~*'()[\\]]+>|(?:[a-zA-Z\\d-]*!)?[\\w\\-%#;/?:@&=+$.~*'()]+)?/; // https://yaml.org/spec/1.2/spec.html#c-ns-properties(n,c)\n\n  var properties = '(?:' + tag.source + '(?:[ \\t]+' + anchorOrAlias.source + ')?|' + anchorOrAlias.source + '(?:[ \\t]+' + tag.source + ')?)'; // https://yaml.org/spec/1.2/spec.html#ns-plain(n,c)\n  // This is a simplified version that doesn't support \"#\" and multiline keys\n  // All these long scarry character classes are simplified versions of YAML's characters\n\n  var plainKey = /(?:[^\\s\\x00-\\x08\\x0e-\\x1f!\"#%&'*,\\-:>?@[\\]`{|}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]|[?:-]<PLAIN>)(?:[ \\t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(/<PLAIN>/g, function () {\n    return /[^\\s\\x00-\\x08\\x0e-\\x1f,[\\]{}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]/.source;\n  });\n  var string = /\"(?:[^\"\\\\\\r\\n]|\\\\.)*\"|'(?:[^'\\\\\\r\\n]|\\\\.)*'/.source;\n  /**\n   *\n   * @param {string} value\n   * @param {string} [flags]\n   * @returns {RegExp}\n   */\n\n  function createValuePattern(value, flags) {\n    flags = (flags || '').replace(/m/g, '') + 'm'; // add m flag\n\n    var pattern = /([:\\-,[{]\\s*(?:\\s<<prop>>[ \\t]+)?)(?:<<value>>)(?=[ \\t]*(?:$|,|]|}|\\s*#))/.source.replace(/<<prop>>/g, function () {\n      return properties;\n    }).replace(/<<value>>/g, function () {\n      return value;\n    });\n    return RegExp(pattern, flags);\n  }\n\n  Prism.languages.yaml = {\n    'scalar': {\n      pattern: RegExp(/([\\-:]\\s*(?:\\s<<prop>>[ \\t]+)?[|>])[ \\t]*(?:((?:\\r?\\n|\\r)[ \\t]+)[^\\r\\n]+(?:\\2[^\\r\\n]+)*)/.source.replace(/<<prop>>/g, function () {\n        return properties;\n      })),\n      lookbehind: true,\n      alias: 'string'\n    },\n    'comment': /#.*/,\n    'key': {\n      pattern: RegExp(/((?:^|[:\\-,[{\\r\\n?])[ \\t]*(?:<<prop>>[ \\t]+)?)<<key>>(?=\\s*:\\s)/.source.replace(/<<prop>>/g, function () {\n        return properties;\n      }).replace(/<<key>>/g, function () {\n        return '(?:' + plainKey + '|' + string + ')';\n      })),\n      lookbehind: true,\n      greedy: true,\n      alias: 'atrule'\n    },\n    'directive': {\n      pattern: /(^[ \\t]*)%.+/m,\n      lookbehind: true,\n      alias: 'important'\n    },\n    'datetime': {\n      pattern: createValuePattern(/\\d{4}-\\d\\d?-\\d\\d?(?:[tT]|[ \\t]+)\\d\\d?:\\d{2}:\\d{2}(?:\\.\\d*)?[ \\t]*(?:Z|[-+]\\d\\d?(?::\\d{2})?)?|\\d{4}-\\d{2}-\\d{2}|\\d\\d?:\\d{2}(?::\\d{2}(?:\\.\\d*)?)?/.source),\n      lookbehind: true,\n      alias: 'number'\n    },\n    'boolean': {\n      pattern: createValuePattern(/true|false/.source, 'i'),\n      lookbehind: true,\n      alias: 'important'\n    },\n    'null': {\n      pattern: createValuePattern(/null|~/.source, 'i'),\n      lookbehind: true,\n      alias: 'important'\n    },\n    'string': {\n      pattern: createValuePattern(string),\n      lookbehind: true,\n      greedy: true\n    },\n    'number': {\n      pattern: createValuePattern(/[+-]?(?:0x[\\da-f]+|0o[0-7]+|(?:\\d+\\.?\\d*|\\.?\\d+)(?:e[+-]?\\d+)?|\\.inf|\\.nan)/.source, 'i'),\n      lookbehind: true\n    },\n    'tag': tag,\n    'important': anchorOrAlias,\n    'punctuation': /---|[:[\\]{}\\-,|>?]|\\.\\.\\./\n  };\n  Prism.languages.yml = Prism.languages.yaml;\n})(Prism);","import styled from 'styled-components'\nimport {\n  Box as RebassBox\n} from 'rebass/styled-components'\n\nexport const InnerBox = styled(RebassBox)`\n  margin: 3rem 6rem;\n\n  @media (max-width: ${props => props.theme.breakpoints[0]}) {\n    margin: 1rem;\n  }\n`\n\nexport const Box = styled(RebassBox)`\n  background-color: ${props => props.theme.colors.content.background};\n  border: ${props => props.theme.content.border};\n  border-radius: ${props => props.theme.content.borderRadius};\n  box-shadow: ${props => props.theme.content.boxShadow};\n  margin: 4rem 0 0;\n\n  @media (max-width: ${props => props.theme.breakpoints[0]}) {\n    margin: 1rem 0 0;\n  }\n\n  p, li, blockquote {\n    font-family: ${props => props.theme.font.body};\n    font-weight: 600;\n    font-size: 16px;\n    line-height: 1.8rem;\n    letter-spacing: 0.02rem;\n    text-align: justify;\n    margin-bottom: 1rem;\n  }\n\n  p a {\n    color: ${props => props.theme.colors.sidebar.activeLink};\n    border-bottom: 1px dashed ${props => props.theme.colors.sidebar.link};\n  }\n\n  p a:hover {\n    color: ${props => props.theme.colors.sidebar.link};\n    border-bottom: 1px dashed ${props => props.theme.colors.sidebar.activeLink};\n  }\n\n  h1 {\n    font-size: 32px;\n    font-weight: bold;\n    margin: 2rem 0;\n    padding-top: 2rem;\n    padding-bottom: 2rem;\n  }\n\n  h2 {\n    font-size: 22px;\n    font-weight: bold;\n    margin: 2rem 0;\n  }\n\n  h3 {\n    font-size: 20px;\n    font-weight: bold;\n    margin: 2rem 0;\n  }\n\n  ol {\n    list-style-type: decimal-leading-zero;\n    margin-left: 1rem;\n  }\n\n  ol li {\n    margin-left: 1rem;\n  }\n\n  blockquote {\n    position: relative;\n\n    &:before {\n      border-left: 0.5rem solid ${props => props.theme.colors.border};\n      content: \"\";\n      display: block;\n      float: left;\n      padding: 0 0 2rem;\n      top: 0;\n      left: 0;\n      bottom: 0;\n      margin: 0 0 3rem;\n    }\n  }\n\n  sup.footnote-ref {\n    font-size: 0.6rem;\n    opacity: 0.4;\n    vertical-align: super;\n  }\n\n  sup.footnote-ref:hover {\n    opacity: 1;\n  }\n\n  .footnotes-sep {\n    background-color: ${props => props.theme.colors.sidebar.border};\n    color: ${props => props.theme.colors.sidebar.border};\n    height: 1px;\n    opacity: 0.2;\n    margin: 4rem auto;\n    width: 60%;\n  }\n\n  .footnotes {\n    margin: 4rem 0;\n    opacity: 0.6;\n    padding: 0 0 1rem;\n  }\n\n  .footnotes:hover {\n    opacity: 1;\n  }\n\n  .footnotes p {\n    font-size: 14px;\n  }\n\n  .tagName {\n    font-weight: bolder;\n    font-size: 20px;\n    font-family: monospace;\n  }\n`\n","import React, { ReactNode, FunctionComponent, useEffect } from 'react'\nimport Prism from 'prismjs'\nimport 'prismjs/components/prism-typescript'\nimport 'prismjs/components/prism-javascript'\nimport 'prismjs/components/prism-yaml'\nimport 'prismjs/themes/prism-okaidia.css'\n\nimport { Box, InnerBox } from './styled'\n\ninterface Props {\n  children: ReactNode\n}\n\nconst ContentBox: FunctionComponent<Props> = ({ children }: Props) => {\n  useEffect(() => {\n    setTimeout(() => Prism.highlightAll(), 0)\n  }, [])\n\n  return (\n    <Box>\n      <InnerBox>\n        {children}\n      </InnerBox>\n    </Box>\n  )\n}\n\nexport default ContentBox\n","(function (Prism) {\n  Prism.languages.typescript = Prism.languages.extend('javascript', {\n    'class-name': {\n      pattern: /(\\b(?:class|extends|implements|instanceof|interface|new|type)\\s+)(?!keyof\\b)[_$a-zA-Z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*(?:\\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,\n      lookbehind: true,\n      greedy: true,\n      inside: null // see below\n\n    },\n    // From JavaScript Prism keyword list and TypeScript language spec: https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md#221-reserved-words\n    'keyword': /\\b(?:abstract|as|asserts|async|await|break|case|catch|class|const|constructor|continue|debugger|declare|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|is|keyof|let|module|namespace|new|null|of|package|private|protected|public|readonly|return|require|set|static|super|switch|this|throw|try|type|typeof|undefined|var|void|while|with|yield)\\b/,\n    'builtin': /\\b(?:string|Function|any|number|boolean|Array|symbol|console|Promise|unknown|never)\\b/\n  }); // doesn't work with TS because TS is too complex\n\n  delete Prism.languages.typescript['parameter']; // a version of typescript specifically for highlighting types\n\n  var typeInside = Prism.languages.extend('typescript', {});\n  delete typeInside['class-name'];\n  Prism.languages.typescript['class-name'].inside = typeInside;\n  Prism.languages.insertBefore('typescript', 'function', {\n    'generic-function': {\n      // e.g. foo<T extends \"bar\" | \"baz\">( ...\n      pattern: /#?[_$a-zA-Z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*\\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\\s*\\()/,\n      greedy: true,\n      inside: {\n        'function': /^#?[_$a-zA-Z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*/,\n        'generic': {\n          pattern: /<[\\s\\S]+/,\n          // everything after the first <\n          alias: 'class-name',\n          inside: typeInside\n        }\n      }\n    }\n  });\n  Prism.languages.ts = Prism.languages.typescript;\n})(Prism);","/* **********************************************\n     Begin prism-core.js\n********************************************** */\n/// <reference lib=\"WebWorker\"/>\nvar _self = typeof window !== 'undefined' ? window // if in browser\n: typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope ? self // if in worker\n: {} // if in node js\n;\n/**\n * Prism: Lightweight, robust, elegant syntax highlighting\n *\n * @license MIT <https://opensource.org/licenses/MIT>\n * @author Lea Verou <https://lea.verou.me>\n * @namespace\n * @public\n */\n\n\nvar Prism = function (_self) {\n  // Private helper vars\n  var lang = /\\blang(?:uage)?-([\\w-]+)\\b/i;\n  var uniqueId = 0;\n  var _ = {\n    /**\n     * By default, Prism will attempt to highlight all code elements (by calling {@link Prism.highlightAll}) on the\n     * current page after the page finished loading. This might be a problem if e.g. you wanted to asynchronously load\n     * additional languages or plugins yourself.\n     *\n     * By setting this value to `true`, Prism will not automatically highlight all code elements on the page.\n     *\n     * You obviously have to change this value before the automatic highlighting started. To do this, you can add an\n     * empty Prism object into the global scope before loading the Prism script like this:\n     *\n     * ```js\n     * window.Prism = window.Prism || {};\n     * Prism.manual = true;\n     * // add a new <script> to load Prism's script\n     * ```\n     *\n     * @default false\n     * @type {boolean}\n     * @memberof Prism\n     * @public\n     */\n    manual: _self.Prism && _self.Prism.manual,\n    disableWorkerMessageHandler: _self.Prism && _self.Prism.disableWorkerMessageHandler,\n\n    /**\n     * A namespace for utility methods.\n     *\n     * All function in this namespace that are not explicitly marked as _public_ are for __internal use only__ and may\n     * change or disappear at any time.\n     *\n     * @namespace\n     * @memberof Prism\n     */\n    util: {\n      encode: function encode(tokens) {\n        if (tokens instanceof Token) {\n          return new Token(tokens.type, encode(tokens.content), tokens.alias);\n        } else if (Array.isArray(tokens)) {\n          return tokens.map(encode);\n        } else {\n          return tokens.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/\\u00a0/g, ' ');\n        }\n      },\n\n      /**\n       * Returns the name of the type of the given value.\n       *\n       * @param {any} o\n       * @returns {string}\n       * @example\n       * type(null)      === 'Null'\n       * type(undefined) === 'Undefined'\n       * type(123)       === 'Number'\n       * type('foo')     === 'String'\n       * type(true)      === 'Boolean'\n       * type([1, 2])    === 'Array'\n       * type({})        === 'Object'\n       * type(String)    === 'Function'\n       * type(/abc+/)    === 'RegExp'\n       */\n      type: function type(o) {\n        return Object.prototype.toString.call(o).slice(8, -1);\n      },\n\n      /**\n       * Returns a unique number for the given object. Later calls will still return the same number.\n       *\n       * @param {Object} obj\n       * @returns {number}\n       */\n      objId: function objId(obj) {\n        if (!obj['__id']) {\n          Object.defineProperty(obj, '__id', {\n            value: ++uniqueId\n          });\n        }\n\n        return obj['__id'];\n      },\n\n      /**\n       * Creates a deep clone of the given object.\n       *\n       * The main intended use of this function is to clone language definitions.\n       *\n       * @param {T} o\n       * @param {Record<number, any>} [visited]\n       * @returns {T}\n       * @template T\n       */\n      clone: function deepClone(o, visited) {\n        visited = visited || {};\n        var clone, id;\n\n        switch (_.util.type(o)) {\n          case 'Object':\n            id = _.util.objId(o);\n\n            if (visited[id]) {\n              return visited[id];\n            }\n\n            clone =\n            /** @type {Record<string, any>} */\n            {};\n            visited[id] = clone;\n\n            for (var key in o) {\n              if (o.hasOwnProperty(key)) {\n                clone[key] = deepClone(o[key], visited);\n              }\n            }\n\n            return (\n              /** @type {any} */\n              clone\n            );\n\n          case 'Array':\n            id = _.util.objId(o);\n\n            if (visited[id]) {\n              return visited[id];\n            }\n\n            clone = [];\n            visited[id] = clone;\n\n            /** @type {Array} */\n\n            /** @type {any} */\n            o.forEach(function (v, i) {\n              clone[i] = deepClone(v, visited);\n            });\n            return (\n              /** @type {any} */\n              clone\n            );\n\n          default:\n            return o;\n        }\n      },\n\n      /**\n       * Returns the Prism language of the given element set by a `language-xxxx` or `lang-xxxx` class.\n       *\n       * If no language is set for the element or the element is `null` or `undefined`, `none` will be returned.\n       *\n       * @param {Element} element\n       * @returns {string}\n       */\n      getLanguage: function getLanguage(element) {\n        while (element && !lang.test(element.className)) {\n          element = element.parentElement;\n        }\n\n        if (element) {\n          return (element.className.match(lang) || [, 'none'])[1].toLowerCase();\n        }\n\n        return 'none';\n      },\n\n      /**\n       * Returns the script element that is currently executing.\n       *\n       * This does __not__ work for line script element.\n       *\n       * @returns {HTMLScriptElement | null}\n       */\n      currentScript: function currentScript() {\n        if (typeof document === 'undefined') {\n          return null;\n        }\n\n        if ('currentScript' in document && 1 < 2\n        /* hack to trip TS' flow analysis */\n        ) {\n            return (\n              /** @type {any} */\n              document.currentScript\n            );\n          } // IE11 workaround\n        // we'll get the src of the current script by parsing IE11's error stack trace\n        // this will not work for inline scripts\n\n\n        try {\n          throw new Error();\n        } catch (err) {\n          // Get file src url from stack. Specifically works with the format of stack traces in IE.\n          // A stack will look like this:\n          //\n          // Error\n          //    at _.util.currentScript (http://localhost/components/prism-core.js:119:5)\n          //    at Global code (http://localhost/components/prism-core.js:606:1)\n          var src = (/at [^(\\r\\n]*\\((.*):.+:.+\\)$/i.exec(err.stack) || [])[1];\n\n          if (src) {\n            var scripts = document.getElementsByTagName('script');\n\n            for (var i in scripts) {\n              if (scripts[i].src == src) {\n                return scripts[i];\n              }\n            }\n          }\n\n          return null;\n        }\n      },\n\n      /**\n       * Returns whether a given class is active for `element`.\n       *\n       * The class can be activated if `element` or one of its ancestors has the given class and it can be deactivated\n       * if `element` or one of its ancestors has the negated version of the given class. The _negated version_ of the\n       * given class is just the given class with a `no-` prefix.\n       *\n       * Whether the class is active is determined by the closest ancestor of `element` (where `element` itself is\n       * closest ancestor) that has the given class or the negated version of it. If neither `element` nor any of its\n       * ancestors have the given class or the negated version of it, then the default activation will be returned.\n       *\n       * In the paradoxical situation where the closest ancestor contains __both__ the given class and the negated\n       * version of it, the class is considered active.\n       *\n       * @param {Element} element\n       * @param {string} className\n       * @param {boolean} [defaultActivation=false]\n       * @returns {boolean}\n       */\n      isActive: function isActive(element, className, defaultActivation) {\n        var no = 'no-' + className;\n\n        while (element) {\n          var classList = element.classList;\n\n          if (classList.contains(className)) {\n            return true;\n          }\n\n          if (classList.contains(no)) {\n            return false;\n          }\n\n          element = element.parentElement;\n        }\n\n        return !!defaultActivation;\n      }\n    },\n\n    /**\n     * This namespace contains all currently loaded languages and the some helper functions to create and modify languages.\n     *\n     * @namespace\n     * @memberof Prism\n     * @public\n     */\n    languages: {\n      /**\n       * Creates a deep copy of the language with the given id and appends the given tokens.\n       *\n       * If a token in `redef` also appears in the copied language, then the existing token in the copied language\n       * will be overwritten at its original position.\n       *\n       * ## Best practices\n       *\n       * Since the position of overwriting tokens (token in `redef` that overwrite tokens in the copied language)\n       * doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to\n       * understand the language definition because, normally, the order of tokens matters in Prism grammars.\n       *\n       * Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens.\n       * Furthermore, all non-overwriting tokens should be placed after the overwriting ones.\n       *\n       * @param {string} id The id of the language to extend. This has to be a key in `Prism.languages`.\n       * @param {Grammar} redef The new tokens to append.\n       * @returns {Grammar} The new language created.\n       * @public\n       * @example\n       * Prism.languages['css-with-colors'] = Prism.languages.extend('css', {\n       *     // Prism.languages.css already has a 'comment' token, so this token will overwrite CSS' 'comment' token\n       *     // at its original position\n       *     'comment': { ... },\n       *     // CSS doesn't have a 'color' token, so this token will be appended\n       *     'color': /\\b(?:red|green|blue)\\b/\n       * });\n       */\n      extend: function extend(id, redef) {\n        var lang = _.util.clone(_.languages[id]);\n\n        for (var key in redef) {\n          lang[key] = redef[key];\n        }\n\n        return lang;\n      },\n\n      /**\n       * Inserts tokens _before_ another token in a language definition or any other grammar.\n       *\n       * ## Usage\n       *\n       * This helper method makes it easy to modify existing languages. For example, the CSS language definition\n       * not only defines CSS highlighting for CSS documents, but also needs to define highlighting for CSS embedded\n       * in HTML through `<style>` elements. To do this, it needs to modify `Prism.languages.markup` and add the\n       * appropriate tokens. However, `Prism.languages.markup` is a regular JavaScript object literal, so if you do\n       * this:\n       *\n       * ```js\n       * Prism.languages.markup.style = {\n       *     // token\n       * };\n       * ```\n       *\n       * then the `style` token will be added (and processed) at the end. `insertBefore` allows you to insert tokens\n       * before existing tokens. For the CSS example above, you would use it like this:\n       *\n       * ```js\n       * Prism.languages.insertBefore('markup', 'cdata', {\n       *     'style': {\n       *         // token\n       *     }\n       * });\n       * ```\n       *\n       * ## Special cases\n       *\n       * If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar\n       * will be ignored.\n       *\n       * This behavior can be used to insert tokens after `before`:\n       *\n       * ```js\n       * Prism.languages.insertBefore('markup', 'comment', {\n       *     'comment': Prism.languages.markup.comment,\n       *     // tokens after 'comment'\n       * });\n       * ```\n       *\n       * ## Limitations\n       *\n       * The main problem `insertBefore` has to solve is iteration order. Since ES2015, the iteration order for object\n       * properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave\n       * differently when keys are deleted and re-inserted. So `insertBefore` can't be implemented by temporarily\n       * deleting properties which is necessary to insert at arbitrary positions.\n       *\n       * To solve this problem, `insertBefore` doesn't actually insert the given tokens into the target object.\n       * Instead, it will create a new object and replace all references to the target object with the new one. This\n       * can be done without temporarily deleting properties, so the iteration order is well-defined.\n       *\n       * However, only references that can be reached from `Prism.languages` or `insert` will be replaced. I.e. if\n       * you hold the target object in a variable, then the value of the variable will not change.\n       *\n       * ```js\n       * var oldMarkup = Prism.languages.markup;\n       * var newMarkup = Prism.languages.insertBefore('markup', 'comment', { ... });\n       *\n       * assert(oldMarkup !== Prism.languages.markup);\n       * assert(newMarkup === Prism.languages.markup);\n       * ```\n       *\n       * @param {string} inside The property of `root` (e.g. a language id in `Prism.languages`) that contains the\n       * object to be modified.\n       * @param {string} before The key to insert before.\n       * @param {Grammar} insert An object containing the key-value pairs to be inserted.\n       * @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the\n       * object to be modified.\n       *\n       * Defaults to `Prism.languages`.\n       * @returns {Grammar} The new grammar object.\n       * @public\n       */\n      insertBefore: function insertBefore(inside, before, insert, root) {\n        root = root ||\n        /** @type {any} */\n        _.languages;\n        var grammar = root[inside];\n        /** @type {Grammar} */\n\n        var ret = {};\n\n        for (var token in grammar) {\n          if (grammar.hasOwnProperty(token)) {\n            if (token == before) {\n              for (var newToken in insert) {\n                if (insert.hasOwnProperty(newToken)) {\n                  ret[newToken] = insert[newToken];\n                }\n              }\n            } // Do not insert token which also occur in insert. See #1525\n\n\n            if (!insert.hasOwnProperty(token)) {\n              ret[token] = grammar[token];\n            }\n          }\n        }\n\n        var old = root[inside];\n        root[inside] = ret; // Update references in other language definitions\n\n        _.languages.DFS(_.languages, function (key, value) {\n          if (value === old && key != inside) {\n            this[key] = ret;\n          }\n        });\n\n        return ret;\n      },\n      // Traverse a language definition with Depth First Search\n      DFS: function DFS(o, callback, type, visited) {\n        visited = visited || {};\n        var objId = _.util.objId;\n\n        for (var i in o) {\n          if (o.hasOwnProperty(i)) {\n            callback.call(o, i, o[i], type || i);\n\n            var property = o[i],\n                propertyType = _.util.type(property);\n\n            if (propertyType === 'Object' && !visited[objId(property)]) {\n              visited[objId(property)] = true;\n              DFS(property, callback, null, visited);\n            } else if (propertyType === 'Array' && !visited[objId(property)]) {\n              visited[objId(property)] = true;\n              DFS(property, callback, i, visited);\n            }\n          }\n        }\n      }\n    },\n    plugins: {},\n\n    /**\n     * This is the most high-level function in Prism’s API.\n     * It fetches all the elements that have a `.language-xxxx` class and then calls {@link Prism.highlightElement} on\n     * each one of them.\n     *\n     * This is equivalent to `Prism.highlightAllUnder(document, async, callback)`.\n     *\n     * @param {boolean} [async=false] Same as in {@link Prism.highlightAllUnder}.\n     * @param {HighlightCallback} [callback] Same as in {@link Prism.highlightAllUnder}.\n     * @memberof Prism\n     * @public\n     */\n    highlightAll: function highlightAll(async, callback) {\n      _.highlightAllUnder(document, async, callback);\n    },\n\n    /**\n     * Fetches all the descendants of `container` that have a `.language-xxxx` class and then calls\n     * {@link Prism.highlightElement} on each one of them.\n     *\n     * The following hooks will be run:\n     * 1. `before-highlightall`\n     * 2. `before-all-elements-highlight`\n     * 3. All hooks of {@link Prism.highlightElement} for each element.\n     *\n     * @param {ParentNode} container The root element, whose descendants that have a `.language-xxxx` class will be highlighted.\n     * @param {boolean} [async=false] Whether each element is to be highlighted asynchronously using Web Workers.\n     * @param {HighlightCallback} [callback] An optional callback to be invoked on each element after its highlighting is done.\n     * @memberof Prism\n     * @public\n     */\n    highlightAllUnder: function highlightAllUnder(container, async, callback) {\n      var env = {\n        callback: callback,\n        container: container,\n        selector: 'code[class*=\"language-\"], [class*=\"language-\"] code, code[class*=\"lang-\"], [class*=\"lang-\"] code'\n      };\n\n      _.hooks.run('before-highlightall', env);\n\n      env.elements = Array.prototype.slice.apply(env.container.querySelectorAll(env.selector));\n\n      _.hooks.run('before-all-elements-highlight', env);\n\n      for (var i = 0, element; element = env.elements[i++];) {\n        _.highlightElement(element, async === true, env.callback);\n      }\n    },\n\n    /**\n     * Highlights the code inside a single element.\n     *\n     * The following hooks will be run:\n     * 1. `before-sanity-check`\n     * 2. `before-highlight`\n     * 3. All hooks of {@link Prism.highlight}. These hooks will be run by an asynchronous worker if `async` is `true`.\n     * 4. `before-insert`\n     * 5. `after-highlight`\n     * 6. `complete`\n     *\n     * Some the above hooks will be skipped if the element doesn't contain any text or there is no grammar loaded for\n     * the element's language.\n     *\n     * @param {Element} element The element containing the code.\n     * It must have a class of `language-xxxx` to be processed, where `xxxx` is a valid language identifier.\n     * @param {boolean} [async=false] Whether the element is to be highlighted asynchronously using Web Workers\n     * to improve performance and avoid blocking the UI when highlighting very large chunks of code. This option is\n     * [disabled by default](https://prismjs.com/faq.html#why-is-asynchronous-highlighting-disabled-by-default).\n     *\n     * Note: All language definitions required to highlight the code must be included in the main `prism.js` file for\n     * asynchronous highlighting to work. You can build your own bundle on the\n     * [Download page](https://prismjs.com/download.html).\n     * @param {HighlightCallback} [callback] An optional callback to be invoked after the highlighting is done.\n     * Mostly useful when `async` is `true`, since in that case, the highlighting is done asynchronously.\n     * @memberof Prism\n     * @public\n     */\n    highlightElement: function highlightElement(element, async, callback) {\n      // Find language\n      var language = _.util.getLanguage(element);\n\n      var grammar = _.languages[language]; // Set language on the element, if not present\n\n      element.className = element.className.replace(lang, '').replace(/\\s+/g, ' ') + ' language-' + language; // Set language on the parent, for styling\n\n      var parent = element.parentElement;\n\n      if (parent && parent.nodeName.toLowerCase() === 'pre') {\n        parent.className = parent.className.replace(lang, '').replace(/\\s+/g, ' ') + ' language-' + language;\n      }\n\n      var code = element.textContent;\n      var env = {\n        element: element,\n        language: language,\n        grammar: grammar,\n        code: code\n      };\n\n      function insertHighlightedCode(highlightedCode) {\n        env.highlightedCode = highlightedCode;\n\n        _.hooks.run('before-insert', env);\n\n        env.element.innerHTML = env.highlightedCode;\n\n        _.hooks.run('after-highlight', env);\n\n        _.hooks.run('complete', env);\n\n        callback && callback.call(env.element);\n      }\n\n      _.hooks.run('before-sanity-check', env);\n\n      if (!env.code) {\n        _.hooks.run('complete', env);\n\n        callback && callback.call(env.element);\n        return;\n      }\n\n      _.hooks.run('before-highlight', env);\n\n      if (!env.grammar) {\n        insertHighlightedCode(_.util.encode(env.code));\n        return;\n      }\n\n      if (async && _self.Worker) {\n        var worker = new Worker(_.filename);\n\n        worker.onmessage = function (evt) {\n          insertHighlightedCode(evt.data);\n        };\n\n        worker.postMessage(JSON.stringify({\n          language: env.language,\n          code: env.code,\n          immediateClose: true\n        }));\n      } else {\n        insertHighlightedCode(_.highlight(env.code, env.grammar, env.language));\n      }\n    },\n\n    /**\n     * Low-level function, only use if you know what you’re doing. It accepts a string of text as input\n     * and the language definitions to use, and returns a string with the HTML produced.\n     *\n     * The following hooks will be run:\n     * 1. `before-tokenize`\n     * 2. `after-tokenize`\n     * 3. `wrap`: On each {@link Token}.\n     *\n     * @param {string} text A string with the code to be highlighted.\n     * @param {Grammar} grammar An object containing the tokens to use.\n     *\n     * Usually a language definition like `Prism.languages.markup`.\n     * @param {string} language The name of the language definition passed to `grammar`.\n     * @returns {string} The highlighted HTML.\n     * @memberof Prism\n     * @public\n     * @example\n     * Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');\n     */\n    highlight: function highlight(text, grammar, language) {\n      var env = {\n        code: text,\n        grammar: grammar,\n        language: language\n      };\n\n      _.hooks.run('before-tokenize', env);\n\n      env.tokens = _.tokenize(env.code, env.grammar);\n\n      _.hooks.run('after-tokenize', env);\n\n      return Token.stringify(_.util.encode(env.tokens), env.language);\n    },\n\n    /**\n     * This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input\n     * and the language definitions to use, and returns an array with the tokenized code.\n     *\n     * When the language definition includes nested tokens, the function is called recursively on each of these tokens.\n     *\n     * This method could be useful in other contexts as well, as a very crude parser.\n     *\n     * @param {string} text A string with the code to be highlighted.\n     * @param {Grammar} grammar An object containing the tokens to use.\n     *\n     * Usually a language definition like `Prism.languages.markup`.\n     * @returns {TokenStream} An array of strings and tokens, a token stream.\n     * @memberof Prism\n     * @public\n     * @example\n     * let code = `var foo = 0;`;\n     * let tokens = Prism.tokenize(code, Prism.languages.javascript);\n     * tokens.forEach(token => {\n     *     if (token instanceof Prism.Token && token.type === 'number') {\n     *         console.log(`Found numeric literal: ${token.content}`);\n     *     }\n     * });\n     */\n    tokenize: function tokenize(text, grammar) {\n      var rest = grammar.rest;\n\n      if (rest) {\n        for (var token in rest) {\n          grammar[token] = rest[token];\n        }\n\n        delete grammar.rest;\n      }\n\n      var tokenList = new LinkedList();\n      addAfter(tokenList, tokenList.head, text);\n      matchGrammar(text, tokenList, grammar, tokenList.head, 0);\n      return toArray(tokenList);\n    },\n\n    /**\n     * @namespace\n     * @memberof Prism\n     * @public\n     */\n    hooks: {\n      all: {},\n\n      /**\n       * Adds the given callback to the list of callbacks for the given hook.\n       *\n       * The callback will be invoked when the hook it is registered for is run.\n       * Hooks are usually directly run by a highlight function but you can also run hooks yourself.\n       *\n       * One callback function can be registered to multiple hooks and the same hook multiple times.\n       *\n       * @param {string} name The name of the hook.\n       * @param {HookCallback} callback The callback function which is given environment variables.\n       * @public\n       */\n      add: function add(name, callback) {\n        var hooks = _.hooks.all;\n        hooks[name] = hooks[name] || [];\n        hooks[name].push(callback);\n      },\n\n      /**\n       * Runs a hook invoking all registered callbacks with the given environment variables.\n       *\n       * Callbacks will be invoked synchronously and in the order in which they were registered.\n       *\n       * @param {string} name The name of the hook.\n       * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.\n       * @public\n       */\n      run: function run(name, env) {\n        var callbacks = _.hooks.all[name];\n\n        if (!callbacks || !callbacks.length) {\n          return;\n        }\n\n        for (var i = 0, callback; callback = callbacks[i++];) {\n          callback(env);\n        }\n      }\n    },\n    Token: Token\n  };\n  _self.Prism = _; // Typescript note:\n  // The following can be used to import the Token type in JSDoc:\n  //\n  //   @typedef {InstanceType<import(\"./prism-core\")[\"Token\"]>} Token\n\n  /**\n   * Creates a new token.\n   *\n   * @param {string} type See {@link Token#type type}\n   * @param {string | TokenStream} content See {@link Token#content content}\n   * @param {string|string[]} [alias] The alias(es) of the token.\n   * @param {string} [matchedStr=\"\"] A copy of the full string this token was created from.\n   * @class\n   * @global\n   * @public\n   */\n\n  function Token(type, content, alias, matchedStr) {\n    /**\n     * The type of the token.\n     *\n     * This is usually the key of a pattern in a {@link Grammar}.\n     *\n     * @type {string}\n     * @see GrammarToken\n     * @public\n     */\n    this.type = type;\n    /**\n     * The strings or tokens contained by this token.\n     *\n     * This will be a token stream if the pattern matched also defined an `inside` grammar.\n     *\n     * @type {string | TokenStream}\n     * @public\n     */\n\n    this.content = content;\n    /**\n     * The alias(es) of the token.\n     *\n     * @type {string|string[]}\n     * @see GrammarToken\n     * @public\n     */\n\n    this.alias = alias; // Copy of the full string this token was created from\n\n    this.length = (matchedStr || '').length | 0;\n  }\n  /**\n   * A token stream is an array of strings and {@link Token Token} objects.\n   *\n   * Token streams have to fulfill a few properties that are assumed by most functions (mostly internal ones) that process\n   * them.\n   *\n   * 1. No adjacent strings.\n   * 2. No empty strings.\n   *\n   *    The only exception here is the token stream that only contains the empty string and nothing else.\n   *\n   * @typedef {Array<string | Token>} TokenStream\n   * @global\n   * @public\n   */\n\n  /**\n   * Converts the given token or token stream to an HTML representation.\n   *\n   * The following hooks will be run:\n   * 1. `wrap`: On each {@link Token}.\n   *\n   * @param {string | Token | TokenStream} o The token or token stream to be converted.\n   * @param {string} language The name of current language.\n   * @returns {string} The HTML representation of the token or token stream.\n   * @memberof Token\n   * @static\n   */\n\n\n  Token.stringify = function stringify(o, language) {\n    if (typeof o == 'string') {\n      return o;\n    }\n\n    if (Array.isArray(o)) {\n      var s = '';\n      o.forEach(function (e) {\n        s += stringify(e, language);\n      });\n      return s;\n    }\n\n    var env = {\n      type: o.type,\n      content: stringify(o.content, language),\n      tag: 'span',\n      classes: ['token', o.type],\n      attributes: {},\n      language: language\n    };\n    var aliases = o.alias;\n\n    if (aliases) {\n      if (Array.isArray(aliases)) {\n        Array.prototype.push.apply(env.classes, aliases);\n      } else {\n        env.classes.push(aliases);\n      }\n    }\n\n    _.hooks.run('wrap', env);\n\n    var attributes = '';\n\n    for (var name in env.attributes) {\n      attributes += ' ' + name + '=\"' + (env.attributes[name] || '').replace(/\"/g, '&quot;') + '\"';\n    }\n\n    return '<' + env.tag + ' class=\"' + env.classes.join(' ') + '\"' + attributes + '>' + env.content + '</' + env.tag + '>';\n  };\n  /**\n   * @param {string} text\n   * @param {LinkedList<string | Token>} tokenList\n   * @param {any} grammar\n   * @param {LinkedListNode<string | Token>} startNode\n   * @param {number} startPos\n   * @param {RematchOptions} [rematch]\n   * @returns {void}\n   * @private\n   *\n   * @typedef RematchOptions\n   * @property {string} cause\n   * @property {number} reach\n   */\n\n\n  function matchGrammar(text, tokenList, grammar, startNode, startPos, rematch) {\n    for (var token in grammar) {\n      if (!grammar.hasOwnProperty(token) || !grammar[token]) {\n        continue;\n      }\n\n      var patterns = grammar[token];\n      patterns = Array.isArray(patterns) ? patterns : [patterns];\n\n      for (var j = 0; j < patterns.length; ++j) {\n        if (rematch && rematch.cause == token + ',' + j) {\n          return;\n        }\n\n        var patternObj = patterns[j],\n            inside = patternObj.inside,\n            lookbehind = !!patternObj.lookbehind,\n            greedy = !!patternObj.greedy,\n            lookbehindLength = 0,\n            alias = patternObj.alias;\n\n        if (greedy && !patternObj.pattern.global) {\n          // Without the global flag, lastIndex won't work\n          var flags = patternObj.pattern.toString().match(/[imsuy]*$/)[0];\n          patternObj.pattern = RegExp(patternObj.pattern.source, flags + 'g');\n        }\n        /** @type {RegExp} */\n\n\n        var pattern = patternObj.pattern || patternObj;\n\n        for ( // iterate the token list and keep track of the current token/string position\n        var currentNode = startNode.next, pos = startPos; currentNode !== tokenList.tail; pos += currentNode.value.length, currentNode = currentNode.next) {\n          if (rematch && pos >= rematch.reach) {\n            break;\n          }\n\n          var str = currentNode.value;\n\n          if (tokenList.length > text.length) {\n            // Something went terribly wrong, ABORT, ABORT!\n            return;\n          }\n\n          if (str instanceof Token) {\n            continue;\n          }\n\n          var removeCount = 1; // this is the to parameter of removeBetween\n\n          if (greedy && currentNode != tokenList.tail.prev) {\n            pattern.lastIndex = pos;\n            var match = pattern.exec(text);\n\n            if (!match) {\n              break;\n            }\n\n            var from = match.index + (lookbehind && match[1] ? match[1].length : 0);\n            var to = match.index + match[0].length;\n            var p = pos; // find the node that contains the match\n\n            p += currentNode.value.length;\n\n            while (from >= p) {\n              currentNode = currentNode.next;\n              p += currentNode.value.length;\n            } // adjust pos (and p)\n\n\n            p -= currentNode.value.length;\n            pos = p; // the current node is a Token, then the match starts inside another Token, which is invalid\n\n            if (currentNode.value instanceof Token) {\n              continue;\n            } // find the last node which is affected by this match\n\n\n            for (var k = currentNode; k !== tokenList.tail && (p < to || typeof k.value === 'string'); k = k.next) {\n              removeCount++;\n              p += k.value.length;\n            }\n\n            removeCount--; // replace with the new match\n\n            str = text.slice(pos, p);\n            match.index -= pos;\n          } else {\n            pattern.lastIndex = 0;\n            var match = pattern.exec(str);\n          }\n\n          if (!match) {\n            continue;\n          }\n\n          if (lookbehind) {\n            lookbehindLength = match[1] ? match[1].length : 0;\n          }\n\n          var from = match.index + lookbehindLength,\n              matchStr = match[0].slice(lookbehindLength),\n              to = from + matchStr.length,\n              before = str.slice(0, from),\n              after = str.slice(to);\n          var reach = pos + str.length;\n\n          if (rematch && reach > rematch.reach) {\n            rematch.reach = reach;\n          }\n\n          var removeFrom = currentNode.prev;\n\n          if (before) {\n            removeFrom = addAfter(tokenList, removeFrom, before);\n            pos += before.length;\n          }\n\n          removeRange(tokenList, removeFrom, removeCount);\n          var wrapped = new Token(token, inside ? _.tokenize(matchStr, inside) : matchStr, alias, matchStr);\n          currentNode = addAfter(tokenList, removeFrom, wrapped);\n\n          if (after) {\n            addAfter(tokenList, currentNode, after);\n          }\n\n          if (removeCount > 1) {\n            // at least one Token object was removed, so we have to do some rematching\n            // this can only happen if the current pattern is greedy\n            matchGrammar(text, tokenList, grammar, currentNode.prev, pos, {\n              cause: token + ',' + j,\n              reach: reach\n            });\n          }\n        }\n      }\n    }\n  }\n  /**\n   * @typedef LinkedListNode\n   * @property {T} value\n   * @property {LinkedListNode<T> | null} prev The previous node.\n   * @property {LinkedListNode<T> | null} next The next node.\n   * @template T\n   * @private\n   */\n\n  /**\n   * @template T\n   * @private\n   */\n\n\n  function LinkedList() {\n    /** @type {LinkedListNode<T>} */\n    var head = {\n      value: null,\n      prev: null,\n      next: null\n    };\n    /** @type {LinkedListNode<T>} */\n\n    var tail = {\n      value: null,\n      prev: head,\n      next: null\n    };\n    head.next = tail;\n    /** @type {LinkedListNode<T>} */\n\n    this.head = head;\n    /** @type {LinkedListNode<T>} */\n\n    this.tail = tail;\n    this.length = 0;\n  }\n  /**\n   * Adds a new node with the given value to the list.\n   * @param {LinkedList<T>} list\n   * @param {LinkedListNode<T>} node\n   * @param {T} value\n   * @returns {LinkedListNode<T>} The added node.\n   * @template T\n   */\n\n\n  function addAfter(list, node, value) {\n    // assumes that node != list.tail && values.length >= 0\n    var next = node.next;\n    var newNode = {\n      value: value,\n      prev: node,\n      next: next\n    };\n    node.next = newNode;\n    next.prev = newNode;\n    list.length++;\n    return newNode;\n  }\n  /**\n   * Removes `count` nodes after the given node. The given node will not be removed.\n   * @param {LinkedList<T>} list\n   * @param {LinkedListNode<T>} node\n   * @param {number} count\n   * @template T\n   */\n\n\n  function removeRange(list, node, count) {\n    var next = node.next;\n\n    for (var i = 0; i < count && next !== list.tail; i++) {\n      next = next.next;\n    }\n\n    node.next = next;\n    next.prev = node;\n    list.length -= i;\n  }\n  /**\n   * @param {LinkedList<T>} list\n   * @returns {T[]}\n   * @template T\n   */\n\n\n  function toArray(list) {\n    var array = [];\n    var node = list.head.next;\n\n    while (node !== list.tail) {\n      array.push(node.value);\n      node = node.next;\n    }\n\n    return array;\n  }\n\n  if (!_self.document) {\n    if (!_self.addEventListener) {\n      // in Node.js\n      return _;\n    }\n\n    if (!_.disableWorkerMessageHandler) {\n      // In worker\n      _self.addEventListener('message', function (evt) {\n        var message = JSON.parse(evt.data),\n            lang = message.language,\n            code = message.code,\n            immediateClose = message.immediateClose;\n\n        _self.postMessage(_.highlight(code, _.languages[lang], lang));\n\n        if (immediateClose) {\n          _self.close();\n        }\n      }, false);\n    }\n\n    return _;\n  } // Get current script and highlight\n\n\n  var script = _.util.currentScript();\n\n  if (script) {\n    _.filename = script.src;\n\n    if (script.hasAttribute('data-manual')) {\n      _.manual = true;\n    }\n  }\n\n  function highlightAutomaticallyCallback() {\n    if (!_.manual) {\n      _.highlightAll();\n    }\n  }\n\n  if (!_.manual) {\n    // If the document state is \"loading\", then we'll use DOMContentLoaded.\n    // If the document state is \"interactive\" and the prism.js script is deferred, then we'll also use the\n    // DOMContentLoaded event because there might be some plugins or languages which have also been deferred and they\n    // might take longer one animation frame to execute which can create a race condition where only some plugins have\n    // been loaded when Prism.highlightAll() is executed, depending on how fast resources are loaded.\n    // See https://github.com/PrismJS/prism/issues/2102\n    var readyState = document.readyState;\n\n    if (readyState === 'loading' || readyState === 'interactive' && script && script.defer) {\n      document.addEventListener('DOMContentLoaded', highlightAutomaticallyCallback);\n    } else {\n      if (window.requestAnimationFrame) {\n        window.requestAnimationFrame(highlightAutomaticallyCallback);\n      } else {\n        window.setTimeout(highlightAutomaticallyCallback, 16);\n      }\n    }\n  }\n\n  return _;\n}(_self);\n\nif (typeof module !== 'undefined' && module.exports) {\n  module.exports = Prism;\n} // hack for components to work correctly in node.js\n\n\nif (typeof global !== 'undefined') {\n  global.Prism = Prism;\n} // some additional documentation/types\n\n/**\n * The expansion of a simple `RegExp` literal to support additional properties.\n *\n * @typedef GrammarToken\n * @property {RegExp} pattern The regular expression of the token.\n * @property {boolean} [lookbehind=false] If `true`, then the first capturing group of `pattern` will (effectively)\n * behave as a lookbehind group meaning that the captured text will not be part of the matched text of the new token.\n * @property {boolean} [greedy=false] Whether the token is greedy.\n * @property {string|string[]} [alias] An optional alias or list of aliases.\n * @property {Grammar} [inside] The nested grammar of this token.\n *\n * The `inside` grammar will be used to tokenize the text value of each token of this kind.\n *\n * This can be used to make nested and even recursive language definitions.\n *\n * Note: This can cause infinite recursion. Be careful when you embed different languages or even the same language into\n * each another.\n * @global\n * @public\n*/\n\n/**\n * @typedef Grammar\n * @type {Object<string, RegExp | GrammarToken | Array<RegExp | GrammarToken>>}\n * @property {Grammar} [rest] An optional grammar object that will be appended to this grammar.\n * @global\n * @public\n */\n\n/**\n * A function which will invoked after an element was successfully highlighted.\n *\n * @callback HighlightCallback\n * @param {Element} element The element successfully highlighted.\n * @returns {void}\n * @global\n * @public\n*/\n\n/**\n * @callback HookCallback\n * @param {Object<string, any>} env The environment variables of the hook.\n * @returns {void}\n * @global\n * @public\n */\n\n/* **********************************************\n     Begin prism-markup.js\n********************************************** */\n\n\nPrism.languages.markup = {\n  'comment': /<!--[\\s\\S]*?-->/,\n  'prolog': /<\\?[\\s\\S]+?\\?>/,\n  'doctype': {\n    // https://www.w3.org/TR/xml/#NT-doctypedecl\n    pattern: /<!DOCTYPE(?:[^>\"'[\\]]|\"[^\"]*\"|'[^']*')+(?:\\[(?:[^<\"'\\]]|\"[^\"]*\"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\\]\\s*)?>/i,\n    greedy: true,\n    inside: {\n      'internal-subset': {\n        pattern: /(\\[)[\\s\\S]+(?=\\]>$)/,\n        lookbehind: true,\n        greedy: true,\n        inside: null // see below\n\n      },\n      'string': {\n        pattern: /\"[^\"]*\"|'[^']*'/,\n        greedy: true\n      },\n      'punctuation': /^<!|>$|[[\\]]/,\n      'doctype-tag': /^DOCTYPE/,\n      'name': /[^\\s<>'\"]+/\n    }\n  },\n  'cdata': /<!\\[CDATA\\[[\\s\\S]*?]]>/i,\n  'tag': {\n    pattern: /<\\/?(?!\\d)[^\\s>\\/=$<%]+(?:\\s(?:\\s*[^\\s>\\/=]+(?:\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s'\">=]+(?=[\\s>]))|(?=[\\s/>])))+)?\\s*\\/?>/,\n    greedy: true,\n    inside: {\n      'tag': {\n        pattern: /^<\\/?[^\\s>\\/]+/,\n        inside: {\n          'punctuation': /^<\\/?/,\n          'namespace': /^[^\\s>\\/:]+:/\n        }\n      },\n      'attr-value': {\n        pattern: /=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s'\">=]+)/,\n        inside: {\n          'punctuation': [{\n            pattern: /^=/,\n            alias: 'attr-equals'\n          }, /\"|'/]\n        }\n      },\n      'punctuation': /\\/?>/,\n      'attr-name': {\n        pattern: /[^\\s>\\/]+/,\n        inside: {\n          'namespace': /^[^\\s>\\/:]+:/\n        }\n      }\n    }\n  },\n  'entity': [{\n    pattern: /&[\\da-z]{1,8};/i,\n    alias: 'named-entity'\n  }, /&#x?[\\da-f]{1,8};/i]\n};\nPrism.languages.markup['tag'].inside['attr-value'].inside['entity'] = Prism.languages.markup['entity'];\nPrism.languages.markup['doctype'].inside['internal-subset'].inside = Prism.languages.markup; // Plugin to make entity title show the real entity, idea by Roman Komarov\n\nPrism.hooks.add('wrap', function (env) {\n  if (env.type === 'entity') {\n    env.attributes['title'] = env.content.replace(/&amp;/, '&');\n  }\n});\nObject.defineProperty(Prism.languages.markup.tag, 'addInlined', {\n  /**\n   * Adds an inlined language to markup.\n   *\n   * An example of an inlined language is CSS with `<style>` tags.\n   *\n   * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as\n   * case insensitive.\n   * @param {string} lang The language key.\n   * @example\n   * addInlined('style', 'css');\n   */\n  value: function addInlined(tagName, lang) {\n    var includedCdataInside = {};\n    includedCdataInside['language-' + lang] = {\n      pattern: /(^<!\\[CDATA\\[)[\\s\\S]+?(?=\\]\\]>$)/i,\n      lookbehind: true,\n      inside: Prism.languages[lang]\n    };\n    includedCdataInside['cdata'] = /^<!\\[CDATA\\[|\\]\\]>$/i;\n    var inside = {\n      'included-cdata': {\n        pattern: /<!\\[CDATA\\[[\\s\\S]*?\\]\\]>/i,\n        inside: includedCdataInside\n      }\n    };\n    inside['language-' + lang] = {\n      pattern: /[\\s\\S]+/,\n      inside: Prism.languages[lang]\n    };\n    var def = {};\n    def[tagName] = {\n      pattern: RegExp(/(<__[\\s\\S]*?>)(?:<!\\[CDATA\\[(?:[^\\]]|\\](?!\\]>))*\\]\\]>|(?!<!\\[CDATA\\[)[\\s\\S])*?(?=<\\/__>)/.source.replace(/__/g, function () {\n        return tagName;\n      }), 'i'),\n      lookbehind: true,\n      greedy: true,\n      inside: inside\n    };\n    Prism.languages.insertBefore('markup', 'cdata', def);\n  }\n});\nPrism.languages.html = Prism.languages.markup;\nPrism.languages.mathml = Prism.languages.markup;\nPrism.languages.svg = Prism.languages.markup;\nPrism.languages.xml = Prism.languages.extend('markup', {});\nPrism.languages.ssml = Prism.languages.xml;\nPrism.languages.atom = Prism.languages.xml;\nPrism.languages.rss = Prism.languages.xml;\n/* **********************************************\n     Begin prism-css.js\n********************************************** */\n\n(function (Prism) {\n  var string = /(\"|')(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/;\n  Prism.languages.css = {\n    'comment': /\\/\\*[\\s\\S]*?\\*\\//,\n    'atrule': {\n      pattern: /@[\\w-]+[\\s\\S]*?(?:;|(?=\\s*\\{))/,\n      inside: {\n        'rule': /^@[\\w-]+/,\n        'selector-function-argument': {\n          pattern: /(\\bselector\\s*\\((?!\\s*\\))\\s*)(?:[^()]|\\((?:[^()]|\\([^()]*\\))*\\))+?(?=\\s*\\))/,\n          lookbehind: true,\n          alias: 'selector'\n        },\n        'keyword': {\n          pattern: /(^|[^\\w-])(?:and|not|only|or)(?![\\w-])/,\n          lookbehind: true\n        } // See rest below\n\n      }\n    },\n    'url': {\n      // https://drafts.csswg.org/css-values-3/#urls\n      pattern: RegExp('\\\\burl\\\\((?:' + string.source + '|' + /(?:[^\\\\\\r\\n()\"']|\\\\[\\s\\S])*/.source + ')\\\\)', 'i'),\n      greedy: true,\n      inside: {\n        'function': /^url/i,\n        'punctuation': /^\\(|\\)$/,\n        'string': {\n          pattern: RegExp('^' + string.source + '$'),\n          alias: 'url'\n        }\n      }\n    },\n    'selector': RegExp('[^{}\\\\s](?:[^{};\"\\']|' + string.source + ')*?(?=\\\\s*\\\\{)'),\n    'string': {\n      pattern: string,\n      greedy: true\n    },\n    'property': /[-_a-z\\xA0-\\uFFFF][-\\w\\xA0-\\uFFFF]*(?=\\s*:)/i,\n    'important': /!important\\b/i,\n    'function': /[-a-z0-9]+(?=\\()/i,\n    'punctuation': /[(){};:,]/\n  };\n  Prism.languages.css['atrule'].inside.rest = Prism.languages.css;\n  var markup = Prism.languages.markup;\n\n  if (markup) {\n    markup.tag.addInlined('style', 'css');\n    Prism.languages.insertBefore('inside', 'attr-value', {\n      'style-attr': {\n        pattern: /\\s*style=(\"|')(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1/i,\n        inside: {\n          'attr-name': {\n            pattern: /^\\s*style/i,\n            inside: markup.tag.inside\n          },\n          'punctuation': /^\\s*=\\s*['\"]|['\"]\\s*$/,\n          'attr-value': {\n            pattern: /.+/i,\n            inside: Prism.languages.css\n          }\n        },\n        alias: 'language-css'\n      }\n    }, markup.tag);\n  }\n})(Prism);\n/* **********************************************\n     Begin prism-clike.js\n********************************************** */\n\n\nPrism.languages.clike = {\n  'comment': [{\n    pattern: /(^|[^\\\\])\\/\\*[\\s\\S]*?(?:\\*\\/|$)/,\n    lookbehind: true\n  }, {\n    pattern: /(^|[^\\\\:])\\/\\/.*/,\n    lookbehind: true,\n    greedy: true\n  }],\n  'string': {\n    pattern: /([\"'])(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/,\n    greedy: true\n  },\n  'class-name': {\n    pattern: /(\\b(?:class|interface|extends|implements|trait|instanceof|new)\\s+|\\bcatch\\s+\\()[\\w.\\\\]+/i,\n    lookbehind: true,\n    inside: {\n      'punctuation': /[.\\\\]/\n    }\n  },\n  'keyword': /\\b(?:if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\\b/,\n  'boolean': /\\b(?:true|false)\\b/,\n  'function': /\\w+(?=\\()/,\n  'number': /\\b0x[\\da-f]+\\b|(?:\\b\\d+\\.?\\d*|\\B\\.\\d+)(?:e[+-]?\\d+)?/i,\n  'operator': /[<>]=?|[!=]=?=?|--?|\\+\\+?|&&?|\\|\\|?|[?*/~^%]/,\n  'punctuation': /[{}[\\];(),.:]/\n};\n/* **********************************************\n     Begin prism-javascript.js\n********************************************** */\n\nPrism.languages.javascript = Prism.languages.extend('clike', {\n  'class-name': [Prism.languages.clike['class-name'], {\n    pattern: /(^|[^$\\w\\xA0-\\uFFFF])[_$A-Z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*(?=\\.(?:prototype|constructor))/,\n    lookbehind: true\n  }],\n  'keyword': [{\n    pattern: /((?:^|})\\s*)(?:catch|finally)\\b/,\n    lookbehind: true\n  }, {\n    pattern: /(^|[^.]|\\.\\.\\.\\s*)\\b(?:as|async(?=\\s*(?:function\\b|\\(|[$\\w\\xA0-\\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|for|from|function|(?:get|set)(?=\\s*[\\[$\\w\\xA0-\\uFFFF])|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\\b/,\n    lookbehind: true\n  }],\n  'number': /\\b(?:(?:0[xX](?:[\\dA-Fa-f](?:_[\\dA-Fa-f])?)+|0[bB](?:[01](?:_[01])?)+|0[oO](?:[0-7](?:_[0-7])?)+)n?|(?:\\d(?:_\\d)?)+n|NaN|Infinity)\\b|(?:\\b(?:\\d(?:_\\d)?)+\\.?(?:\\d(?:_\\d)?)*|\\B\\.(?:\\d(?:_\\d)?)+)(?:[Ee][+-]?(?:\\d(?:_\\d)?)+)?/,\n  // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)\n  'function': /#?[_$a-zA-Z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*(?=\\s*(?:\\.\\s*(?:apply|bind|call)\\s*)?\\()/,\n  'operator': /--|\\+\\+|\\*\\*=?|=>|&&=?|\\|\\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\\.{3}|\\?\\?=?|\\?\\.?|[~:]/\n});\nPrism.languages.javascript['class-name'][0].pattern = /(\\b(?:class|interface|extends|implements|instanceof|new)\\s+)[\\w.\\\\]+/;\nPrism.languages.insertBefore('javascript', 'keyword', {\n  'regex': {\n    pattern: /((?:^|[^$\\w\\xA0-\\uFFFF.\"'\\])\\s]|\\b(?:return|yield))\\s*)\\/(?:\\[(?:[^\\]\\\\\\r\\n]|\\\\.)*]|\\\\.|[^/\\\\\\[\\r\\n])+\\/[gimyus]{0,6}(?=(?:\\s|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/)*(?:$|[\\r\\n,.;:})\\]]|\\/\\/))/,\n    lookbehind: true,\n    greedy: true,\n    inside: {\n      'regex-source': {\n        pattern: /^(\\/)[\\s\\S]+(?=\\/[a-z]*$)/,\n        lookbehind: true,\n        alias: 'language-regex',\n        inside: Prism.languages.regex\n      },\n      'regex-flags': /[a-z]+$/,\n      'regex-delimiter': /^\\/|\\/$/\n    }\n  },\n  // This must be declared before keyword because we use \"function\" inside the look-forward\n  'function-variable': {\n    pattern: /#?[_$a-zA-Z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*(?=\\s*[=:]\\s*(?:async\\s*)?(?:\\bfunction\\b|(?:\\((?:[^()]|\\([^()]*\\))*\\)|[_$a-zA-Z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*)\\s*=>))/,\n    alias: 'function'\n  },\n  'parameter': [{\n    pattern: /(function(?:\\s+[_$A-Za-z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*)?\\s*\\(\\s*)(?!\\s)(?:[^()]|\\([^()]*\\))+?(?=\\s*\\))/,\n    lookbehind: true,\n    inside: Prism.languages.javascript\n  }, {\n    pattern: /[_$a-z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*(?=\\s*=>)/i,\n    inside: Prism.languages.javascript\n  }, {\n    pattern: /(\\(\\s*)(?!\\s)(?:[^()]|\\([^()]*\\))+?(?=\\s*\\)\\s*=>)/,\n    lookbehind: true,\n    inside: Prism.languages.javascript\n  }, {\n    pattern: /((?:\\b|\\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\\w\\xA0-\\uFFFF]))(?:[_$A-Za-z\\xA0-\\uFFFF][$\\w\\xA0-\\uFFFF]*\\s*)\\(\\s*|\\]\\s*\\(\\s*)(?!\\s)(?:[^()]|\\([^()]*\\))+?(?=\\s*\\)\\s*\\{)/,\n    lookbehind: true,\n    inside: Prism.languages.javascript\n  }],\n  'constant': /\\b[A-Z](?:[A-Z_]|\\dx?)*\\b/\n});\nPrism.languages.insertBefore('javascript', 'string', {\n  'template-string': {\n    pattern: /`(?:\\\\[\\s\\S]|\\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})+}|(?!\\${)[^\\\\`])*`/,\n    greedy: true,\n    inside: {\n      'template-punctuation': {\n        pattern: /^`|`$/,\n        alias: 'string'\n      },\n      'interpolation': {\n        pattern: /((?:^|[^\\\\])(?:\\\\{2})*)\\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})+}/,\n        lookbehind: true,\n        inside: {\n          'interpolation-punctuation': {\n            pattern: /^\\${|}$/,\n            alias: 'punctuation'\n          },\n          rest: Prism.languages.javascript\n        }\n      },\n      'string': /[\\s\\S]+/\n    }\n  }\n});\n\nif (Prism.languages.markup) {\n  Prism.languages.markup.tag.addInlined('script', 'javascript');\n}\n\nPrism.languages.js = Prism.languages.javascript;\n/* **********************************************\n     Begin prism-file-highlight.js\n********************************************** */\n\n(function () {\n  if (typeof self === 'undefined' || !self.Prism || !self.document) {\n    return;\n  }\n\n  var Prism = window.Prism;\n  var LOADING_MESSAGE = 'Loading…';\n\n  var FAILURE_MESSAGE = function FAILURE_MESSAGE(status, message) {\n    return '✖ Error ' + status + ' while fetching file: ' + message;\n  };\n\n  var FAILURE_EMPTY_MESSAGE = '✖ Error: File does not exist or is empty';\n  var EXTENSIONS = {\n    'js': 'javascript',\n    'py': 'python',\n    'rb': 'ruby',\n    'ps1': 'powershell',\n    'psm1': 'powershell',\n    'sh': 'bash',\n    'bat': 'batch',\n    'h': 'c',\n    'tex': 'latex'\n  };\n  var STATUS_ATTR = 'data-src-status';\n  var STATUS_LOADING = 'loading';\n  var STATUS_LOADED = 'loaded';\n  var STATUS_FAILED = 'failed';\n  var SELECTOR = 'pre[data-src]:not([' + STATUS_ATTR + '=\"' + STATUS_LOADED + '\"])' + ':not([' + STATUS_ATTR + '=\"' + STATUS_LOADING + '\"])';\n  var lang = /\\blang(?:uage)?-([\\w-]+)\\b/i;\n  /**\n   * Sets the Prism `language-xxxx` or `lang-xxxx` class to the given language.\n   *\n   * @param {HTMLElement} element\n   * @param {string} language\n   * @returns {void}\n   */\n\n  function setLanguageClass(element, language) {\n    var className = element.className;\n    className = className.replace(lang, ' ') + ' language-' + language;\n    element.className = className.replace(/\\s+/g, ' ').trim();\n  }\n\n  Prism.hooks.add('before-highlightall', function (env) {\n    env.selector += ', ' + SELECTOR;\n  });\n  Prism.hooks.add('before-sanity-check', function (env) {\n    var pre =\n    /** @type {HTMLPreElement} */\n    env.element;\n\n    if (pre.matches(SELECTOR)) {\n      env.code = ''; // fast-path the whole thing and go to complete\n\n      pre.setAttribute(STATUS_ATTR, STATUS_LOADING); // mark as loading\n      // add code element with loading message\n\n      var code = pre.appendChild(document.createElement('CODE'));\n      code.textContent = LOADING_MESSAGE;\n      var src = pre.getAttribute('data-src');\n      var language = env.language;\n\n      if (language === 'none') {\n        // the language might be 'none' because there is no language set;\n        // in this case, we want to use the extension as the language\n        var extension = (/\\.(\\w+)$/.exec(src) || [, 'none'])[1];\n        language = EXTENSIONS[extension] || extension;\n      } // set language classes\n\n\n      setLanguageClass(code, language);\n      setLanguageClass(pre, language); // preload the language\n\n      var autoloader = Prism.plugins.autoloader;\n\n      if (autoloader) {\n        autoloader.loadLanguages(language);\n      } // load file\n\n\n      var xhr = new XMLHttpRequest();\n      xhr.open('GET', src, true);\n\n      xhr.onreadystatechange = function () {\n        if (xhr.readyState == 4) {\n          if (xhr.status < 400 && xhr.responseText) {\n            // mark as loaded\n            pre.setAttribute(STATUS_ATTR, STATUS_LOADED); // highlight code\n\n            code.textContent = xhr.responseText;\n            Prism.highlightElement(code);\n          } else {\n            // mark as failed\n            pre.setAttribute(STATUS_ATTR, STATUS_FAILED);\n\n            if (xhr.status >= 400) {\n              code.textContent = FAILURE_MESSAGE(xhr.status, xhr.statusText);\n            } else {\n              code.textContent = FAILURE_EMPTY_MESSAGE;\n            }\n          }\n        }\n      };\n\n      xhr.send(null);\n    }\n  });\n  Prism.plugins.fileHighlight = {\n    /**\n     * Executes the File Highlight plugin for all matching `pre` elements under the given container.\n     *\n     * Note: Elements which are already loaded or currently loading will not be touched by this method.\n     *\n     * @param {ParentNode} [container=document]\n     */\n    highlight: function highlight(container) {\n      var elements = (container || document).querySelectorAll(SELECTOR);\n\n      for (var i = 0, element; element = elements[i++];) {\n        Prism.highlightElement(element);\n      }\n    }\n  };\n  var logged = false;\n  /** @deprecated Use `Prism.plugins.fileHighlight.highlight` instead. */\n\n  Prism.fileHighlight = function () {\n    if (!logged) {\n      console.warn('Prism.fileHighlight is deprecated. Use `Prism.plugins.fileHighlight.highlight` instead.');\n      logged = true;\n    }\n\n    Prism.plugins.fileHighlight.highlight.apply(this, arguments);\n  };\n})();"],"sourceRoot":""}