{"version":3,"sources":["webpack:///./node_modules/core-js/internals/to-positive-integer.js","webpack:///./node_modules/copy-to-clipboard/index.js","webpack:///./node_modules/core-js/internals/object-set-prototype-of.js","webpack:///./node_modules/@emotion/stylis/dist/stylis.browser.esm.js","webpack:///./node_modules/core-js/internals/object-get-prototype-of.js","webpack:///./node_modules/core-js/internals/correct-prototype-getter.js","webpack:///./node_modules/core-js/internals/array-buffer-view-core.js","webpack:///./node_modules/@babel/runtime/helpers/inherits.js","webpack:///./node_modules/decode-uri-component/index.js","webpack:///./node_modules/process/browser.js","webpack:///./node_modules/split-on-first/index.js","webpack:///./node_modules/gatsby-plugin-mdx/index.js","webpack:///./node_modules/@babel/runtime/helpers/nonIterableSpread.js","webpack:///./node_modules/toggle-selection/index.js","webpack:///./node_modules/refractor/lang/csharp.js","webpack:///./node_modules/@babel/runtime/helpers/iterableToArray.js","webpack:///./node_modules/react-scrollspy/lib/throttle.js","webpack:///./node_modules/core-js/internals/to-offset.js","webpack:///./node_modules/shallowequal/index.js","webpack:///./src/components/Article/clock.svg","webpack:///./node_modules/core-js/modules/es.typed-array.sort.js","webpack:///./node_modules/@babel/runtime/helpers/arrayWithoutHoles.js","webpack:///./node_modules/@babel/runtime/helpers/slicedToArray.js","webpack:///./node_modules/@emotion/unitless/dist/unitless.browser.esm.js","webpack:///./src/components/Article/stream.svg","webpack:///./node_modules/@babel/runtime/helpers/getPrototypeOf.js","webpack:///./node_modules/core-js/internals/a-possible-prototype.js","webpack:///./node_modules/react-copy-to-clipboard/lib/index.js","webpack:///./node_modules/core-js/modules/es.typed-array.set.js","webpack:///./node_modules/@babel/runtime/helpers/toConsumableArray.js","webpack:///./node_modules/refractor/lang/ruby.js","webpack:///./node_modules/core-js/internals/array-buffer-basic-detection.js","webpack:///./node_modules/refractor/lang/swift.js","webpack:///./node_modules/@babel/runtime/helpers/createClass.js","webpack:///./node_modules/@babel/runtime/helpers/arrayLikeToArray.js","webpack:///./node_modules/gatsby-plugin-mdx/mdx-renderer.js","webpack:///./node_modules/react-scrollspy/lib/scrollspy.js","webpack:///./node_modules/strict-uri-encode/index.js","webpack:///./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","webpack:///./node_modules/@babel/runtime/helpers/possibleConstructorReturn.js","webpack:///./node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js","webpack:///./node_modules/filter-obj/index.js","webpack:///./node_modules/query-string/index.js","webpack:///./node_modules/react-parallax-hover/dist/index.js","webpack:///./node_modules/@emotion/memoize/dist/emotion-memoize.esm.js","webpack:///./node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js","webpack:///./node_modules/@babel/runtime/helpers/defineProperty.js","webpack:///./node_modules/@babel/runtime/helpers/classCallCheck.js","webpack:///./node_modules/@babel/runtime/helpers/iterableToArrayLimit.js","webpack:///./node_modules/react-copy-to-clipboard/lib/Component.js","webpack:///./node_modules/@babel/runtime/helpers/construct.js","webpack:///./node_modules/styled-components/dist/styled-components.browser.esm.js","webpack:///./node_modules/@babel/runtime/helpers/arrayWithHoles.js","webpack:///./node_modules/@babel/runtime/helpers/nonIterableRest.js","webpack:///./src/utilities/utilities.ts","webpack:///./src/components/Aside/Aside.tsx","webpack:///./node_modules/prism-react-renderer/prism/index.js","webpack:///./node_modules/prism-react-renderer/dist/index.js","webpack:///./node_modules/prism-react-renderer/themes/duotoneDark/index.js","webpack:///./node_modules/prism-react-renderer/themes/nightOwl/index.js","webpack:///./src/components/CodeHighlight/CodeHighlight.tsx","webpack:///./src/components/CodeTabs/langDict.ts","webpack:///./src/components/CodeTabs/CodeTabs.tsx","webpack:///./src/components/CountryContent/CountryContent.tsx","webpack:///./node_modules/@babel/runtime/helpers/esm/slicedToArray.js","webpack:///./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","webpack:///./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","webpack:///./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js","webpack:///./node_modules/react-laag/dist/index.es.js","webpack:///./src/components/GuideLink/GuideLink.tsx","webpack:///./src/components/IntroLink/IntroLink.tsx","webpack:///./src/components/NextStep/NextStep.tsx","webpack:///./src/components/Article/ArticleTOC.tsx","webpack:///./src/components/Article/Article.tsx"],"names":["toIntegerOrInfinity","$RangeError","RangeError","module","exports","it","result","deselectCurrent","clipboardToIE11Formatting","text","options","debug","message","reselectPrevious","range","selection","mark","success","document","createRange","getSelection","createElement","textContent","ariaHidden","style","all","position","top","clip","whiteSpace","webkitUserSelect","MozUserSelect","msUserSelect","userSelect","addEventListener","e","stopPropagation","format","preventDefault","clipboardData","console","warn","window","clearData","setData","onCopy","body","appendChild","selectNodeContents","addRange","execCommand","Error","err","error","copyKey","test","navigator","userAgent","replace","prompt","removeRange","removeAllRanges","removeChild","uncurryThis","anObject","aPossiblePrototype","Object","setPrototypeOf","setter","CORRECT_SETTER","getOwnPropertyDescriptor","prototype","set","Array","O","proto","__proto__","undefined","W","X","d","c","h","trim","split","ia","a","length","m","b","Z","v","n","charCodeAt","F","indexOf","P","substring","w","L","ja","ka","aa","G","ba","la","ma","R","na","ea","oa","H","q","g","x","A","S","call","B","U","prefix","D","z","M","k","y","C","K","u","l","r","I","t","J","f","p","N","charAt","ca","join","da","fa","Y","E","ha","Q","use","T","hasOwn","isCallable","toObject","sharedKey","CORRECT_PROTOTYPE_GETTER","IE_PROTO","$Object","ObjectPrototype","getPrototypeOf","object","constructor","fails","NAME","Constructor","Prototype","NATIVE_ARRAY_BUFFER","DESCRIPTORS","global","isObject","classof","tryToString","createNonEnumerableProperty","defineBuiltIn","defineProperty","isPrototypeOf","wellKnownSymbol","uid","InternalStateModule","enforceInternalState","enforce","getInternalState","get","Int8Array","Int8ArrayPrototype","Uint8ClampedArray","Uint8ClampedArrayPrototype","TypedArray","TypedArrayPrototype","TypeError","TO_STRING_TAG","TYPED_ARRAY_TAG","NATIVE_ARRAY_BUFFER_VIEWS","opera","TYPED_ARRAY_TAG_REQUIRED","TypedArrayConstructorsList","Uint8Array","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","BigIntArrayConstructorsList","BigInt64Array","BigUint64Array","getTypedArrayConstructor","state","isTypedArray","klass","Function","this","aTypedArray","aTypedArrayConstructor","exportTypedArrayMethod","KEY","property","forced","ARRAY","TypedArrayConstructor","error2","exportTypedArrayStaticMethod","isView","subClass","superClass","create","value","writable","configurable","__esModule","singleMatcher","RegExp","multiMatcher","decodeComponents","components","decodeURIComponent","left","slice","right","concat","decode","input","tokens","match","i","encodedURI","replaceMap","exec","entries","keys","key","customDecodeURIComponent","cachedSetTimeout","cachedClearTimeout","process","defaultSetTimout","defaultClearTimeout","runTimeout","fun","setTimeout","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","len","run","marker","runClearTimeout","Item","array","noop","nextTick","args","arguments","push","apply","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","name","binding","cwd","chdir","dir","umask","string","separator","separatorIndex","MDXRenderer","require","rangeCount","active","activeElement","ranges","getRangeAt","tagName","toUpperCase","blur","type","forEach","focus","csharp","Prism","pattern","replacements","index","re","flags","nested","depthLog2","keywordKinds","keywordsToPattern","words","typeDeclarationKeywords","keywords","nonTypeKeywords","nonContextualKeywords","generic","source","nestedRound","genericName","identifier","typeExpressionWithoutTuple","tupleElement","tuple","typeExpression","typeInside","keyword","punctuation","character","regularString","verbatimString","languages","extend","lookbehind","greedy","inside","number","operator","insertBefore","alias","namespace","function","preprocessor","directive","regularStringOrCharacter","regularStringCharacterOrComment","roundExpression","attrTarget","attr","attribute","target","formatString","mInterpolationRound","mInterpolation","sInterpolationRound","sInterpolation","createInterpolationInside","interpolation","interpolationRound","expression","char","dotnet","cs","displayName","aliases","iter","Symbol","iterator","from","default","_default","fn","last","timer","threshold","now","Date","toPositiveInteger","BYTES","offset","objA","objB","compare","compareContext","ret","keysA","keysB","bHasOwnProperty","hasOwnProperty","bind","idx","valueA","valueB","aCallable","internalSort","ArrayBufferViewCore","FF","IE_OR_EDGE","V8","WEBKIT","nativeSort","sort","ACCEPT_INCORRECT_ARGUMENTS","STABLE_SORT","mod","expected","comparefn","getSortCompare","arrayLikeToArray","arr","isArray","arrayWithHoles","iterableToArrayLimit","unsupportedIterableToArray","nonIterableRest","animationIterationCount","borderImageOutset","borderImageSlice","borderImageWidth","boxFlex","boxFlexGroup","boxOrdinalGroup","columnCount","columns","flex","flexGrow","flexPositive","flexShrink","flexNegative","flexOrder","gridRow","gridRowEnd","gridRowSpan","gridRowStart","gridColumn","gridColumnEnd","gridColumnSpan","gridColumnStart","msGridRow","msGridRowSpan","msGridColumn","msGridColumnSpan","fontWeight","lineHeight","opacity","order","orphans","tabSize","widows","zIndex","zoom","WebkitLineClamp","fillOpacity","floodOpacity","stopOpacity","strokeDasharray","strokeDashoffset","strokeMiterlimit","strokeOpacity","strokeWidth","_getPrototypeOf","o","$String","String","$TypeError","argument","CopyToClipboard","lengthOfArrayLike","toOffset","toIndexedObject","$set","WORKS_WITH_OBJECTS_AND_GEERIC_ON_TYPED_ARRAYS","0","TO_OBJECT_BUG","arrayLike","src","arrayWithoutHoles","iterableToArray","nonIterableSpread","ruby","comment","content","delimiter","percentExpression","symbolName","regex","variable","symbol","command","builtin","constant","rb","ArrayBuffer","DataView","swift","boolean","literal","label","nil","omit","rule","_defineProperties","props","descriptor","enumerable","protoProps","staticProps","arr2","React","mdx","useMDXScope","scope","children","mdxScope","End","useMemo","fullScope","values","map","_interopRequireDefault","_extends2","_defineProperty2","_toConsumableArray2","_classCallCheck2","_possibleConstructorReturn2","_getPrototypeOf2","_assertThisInitialized2","_createClass2","_inherits2","_propTypes","_react","_classnames","_throttle","Scrollspy","_React$Component","_this","targetItems","inViewState","isScrolledPast","_handleSpy","items","arrayOf","isRequired","currentClassName","scrolledPastClassName","componentTag","oneOfType","elementType","rootEl","onUpdate","func","item","getElementById","val","newArray","max","_getScrollDimension","scrollTop","doc","querySelector","documentElement","parentNode","scrollHeight","targets","elemsInView","elemsOutView","viewStatusList","hasInViewAlready","currentContent","isInView","_isInView","isLastItem","isScrolled","_isScrolled","_isAtBottom","pop","_fillArray","inView","outView","scrolledPast","_getScrolledPast","el","rootRect","_this$props","getBoundingClientRect","rect","winH","height","innerHeight","scrollBottom","elTop","elBottom","offsetHeight","_this$_getScrollDimen2","some","hasFoundInView","_this2","elemensViewState","_getElemsViewState","currentStatuses","setState","_update","prevStatuses","every","_spy","_initSpyTarget","removeEventListener","_initFromProps","onEvent","offEvent","_this3","Tag","_this$props2","className","counter","Children","child","_classNames","ChildTag","childClass","itemClass","Component","str","encodeURIComponent","toString","minLen","_typeof","assertThisInitialized","self","Reflect","construct","sham","Proxy","Boolean","valueOf","obj","predicate","isArr","_slicedToArray","_toConsumableArray","_createForOfIteratorHelper","allowArrayLike","_arrayLikeToArray","_unsupportedIterableToArray","s","done","_e","normalCompletion","didErr","step","next","_e2","return","strictUriEncode","decodeComponent","splitOnFirst","filterObject","validateArrayFormatSeparator","encode","strict","removeHash","hashStart","extract","queryStart","parseValue","parseNumbers","Number","isNaN","parseBooleans","toLowerCase","parse","query","assign","arrayFormat","arrayFormatSeparator","formatter","accumulator","includes","isEncodedArray","newValue","parserForArrayFormat","_step","_iterator","param","_splitOnFirst","_splitOnFirst2","_key","_value","_i","_Object$keys","_i2","_Object$keys2","reduce","keysSorter","stringify","shouldFilter","skipNull","skipEmptyString","encoderForArrayFormat","objectCopy","_i3","_Object$keys3","filter","parseUrl","url","_splitOnFirst3","_splitOnFirst4","url_","hash","parseFragmentIdentifier","fragmentIdentifier","stringifyUrl","queryFromUrl","parsedQueryFromUrl","queryString","getHash","pick","_exports$parseUrl","exclude","exclusionFilter","ParallaxHover","_templateObject","_templateObject2","_templateObject3","_templateObject4","_templateObject5","nodeInterop","cache","_getRequireWildcardCache","has","newObj","hasPropertyDescriptor","desc","_interopRequireWildcard","_styledComponents","WeakMap","cacheBabelInterop","cacheNodeInterop","ownKeys","enumerableOnly","getOwnPropertySymbols","symbols","sym","_objectSpread","_defineProperty","getOwnPropertyDescriptors","defineProperties","_setPrototypeOf","_createSuper","Derived","hasNativeReflectConstruct","_isNativeReflectConstruct","Super","NewTarget","_possibleConstructorReturn","_assertThisInitialized","ReferenceError","_taggedTemplateLiteral","strings","raw","freeze","ParallaxWrapper","div","ParallaxContainer","ParallaxShadow","ParallaxLayer","ParallaxLighting","initialState","rotateX","rotateY","scale","shine","isHovered","_Component","_inherits","_super","instance","_classCallCheck","speedModifier","depth","START_SPEED","MAX_SPEED","DEPTH_MODIFIER","transition","_ref","pageX","pageY","width","rotation","_window","scrollY","scrollLeft","scrollX","bounds","wrapper","centerX","centerY","widthMultiplier","offsetX","offsetY","deltaX","deltaY","angleRaw","Math","atan2","PI","angle","_this$state","scaleModifier","rotationXModifier","floor","rotationYModifier","transformString","WebkitTransform","MozTransform","MsTransform","OTransform","transform","distanceX","pow","distanceY","sqrt","current","_this$props3","borderRadius","buildTransitionTimingString","layer","_this$state2","_this$props4","shadow","shadowPositionModifier","shadowBlurModifier","opacityModifier","lightingShineModifier","wrapperStyles","innerContainerStyles","buildTransformStrings","shadowStyles","boxShadow","lightingStyles","backgroundImage","onMouseEnter","handleParallaxBegin","onMouseLeave","handleParallaxEnd","onMouseMove","handleParallaxMove","onTouchStart","onTouchMove","onTouchEnd","ref","renderLayers","defaultProps","speed","propTypes","any","reactPropsRegex","isPropValid","arg","prop","_s","_arr","_n","_d","_copyToClipboard","_excluded","_objectWithoutProperties","excluded","sourceKeys","_objectWithoutPropertiesLoose","sourceSymbolKeys","propertyIsEnumerable","_React$PureComponent","_len","event","elem","only","onClick","cloneElement","PureComponent","isNativeReflectConstruct","_construct","Parent","Class","_","styledComponentId","REACT_APP_SC_ATTR","SC_ATTR","SC_DISABLE_SPEEDY","REACT_APP_SC_DISABLE_SPEEDY","j","groupSizes","tag","indexOfGroup","insertRules","insertRule","clearGroup","deleteRule","getGroup","getRule","Map","V","registerName","parseInt","getTag","head","childNodes","nodeType","hasAttribute","nextSibling","setAttribute","$","element","createTextNode","sheet","styleSheets","ownerNode","cssRules","cssText","nodes","rules","splice","isServer","useCSSOMInjection","gs","names","server","querySelectorAll","getAttribute","registerId","reconstructWithOptions","allocateGSInstance","hasNameForId","add","Set","clearNames","clear","clearRules","clearTag","size","fromCharCode","ee","abs","te","ne","oe","se","staticRulesId","isStatic","componentId","baseHash","baseStyle","generateAndInjectStyles","Ne","ie","ae","ce","plugins","lastIndexOf","ue","createContext","le","Consumer","de","he","pe","fe","me","ye","stylisPlugins","disableCSSOMInjection","disableVendorPrefixes","Provider","ve","inject","id","getName","ge","Se","we","Ee","be","isReactComponent","isCss","Ae","Ce","Re","theme","De","je","Te","xe","ke","Ve","Be","ze","Me","Ge","Le","Fe","Ye","qe","attrs","parentComponentId","shouldForwardProp","componentStyle","foldedComponentIds","$as","as","forwardRef","withComponent","_foldedDefaultProps","He","withConfig","$e","createStyles","removeStyles","renderStyles","We","JSON","memo","Ue","Je","_emitSheetCSS","getStyleTags","sealed","getStyleElement","dangerouslySetInnerHTML","__html","nonce","seal","collectStyles","interleaveWithNodeStream","Xe","Ze","Ke","StyleSheet","masterSheet","stringToSlug","Aside","lang","uniqueId","plainTextGrammar","util","Token","objId","clone","deepClone","visited","getLanguage","parentElement","setLanguage","language","classList","isActive","defaultActivation","no","contains","plain","plaintext","txt","redef","before","insert","root","grammar","token","newToken","old","DFS","callback","propertyType","highlight","code","hooks","tokenize","rest","tokenList","LinkedList","addAfter","matchGrammar","startNode","startPos","rematch","patterns","cause","patternObj","currentNode","pos","tail","reach","removeCount","matchPattern","to","matchStr","after","removeFrom","prev","wrapped","nestedRematch","list","node","toArray","callbacks","matchedStr","lastIndex","lookbehindLength","newNode","count","classes","attributes","prism","markup","includedCdataInside","def","attrName","html","mathml","svg","xml","ssml","atom","rss","envVars","commandAfterHeredoc","insideString","bash","entity","toBeCopied","shell","clike","modName","cpp","css","addInlined","addAttribute","selectorInside","selector","unit","javascript","js","coffeescript","coffee","anchorOrAlias","properties","plainKey","createValuePattern","yaml","yml","inner","createInline","tableCell","tableRow","tableLine","markdown","walkTokens","codeLang","codeBlock","cls","tagPattern","fromCodePoint","known","KNOWN_ENTITY_NAMES","autoloader","random","loadLanguages","ele","innerHTML","md","graphql","validTokens","currentIndex","startToken","inputVariables","isTokenType","getToken","definitionEnd","findClosingBracket","addAlias","mutationEnd","varToken","types","open","close","stackHeight","sql","templateString","templateLiteralPattern","interpolationObject","interpolationPunctuationObject","interpolationPattern","createTemplate","getPlaceholder","tokenizeWithHooks","tokenizeInterpolationExpression","tempGrammar","tokenizeEmbedded","_tokens","placeholderCounter","placeholderMap","embeddedTokens","placeholder","interpolationExpression","placeholders","middle","replacement","afterTokens","supportedLanguages","stringContent","findTemplateStrings","embedded","typescript","ts","withId","unshift","maybeClassNameTokens","space","braces","spread","jsx","stringifyToken","openedTags","notTagNorBrace","openedBraces","plainText","diff","PREFIXES","git","go","buildPlaceholders","placeholderPattern","replaceFilter","tokenStack","tokenizePlaceholders","handlebars","hbs","json","webmanifest","less","makefile","objectivec","objc","ocaml","python","py","reason","sass","atrule","important","scss","stylus","tsx","wasm","backgroundColor","color","styles","textDecorationLine","fontStyle","_extends","newlineRe","normalizeEmptyLines","line","empty","appendTypes","typesSize","themeToDict","base","themeDict","acc","themeEntry","accStyle","objectWithoutProperties","Highlight","this$1","prevTheme","prevLanguage","output","getThemeDict","display","typeStyles","getStyleForToken","render","typeArrStack","tokenArrStack","tokenArrIndexStack","tokenArrSizeStack","stackIndex","currentLine","splitByNewlines","newlineCount","i$1","normalizeTokens","getLineProps","getTokenProps","csharpLang","rubyLang","swiftLang","CodeHighlight","useState","codeCopied","setCodeCopied","langDict","animationsInitialState","fadeIn","direction","fadeOut","CodeTabs","group","tabs","childrenProps","groups","tabName","tabsContext","useContext","TabsContext","selectedTabIndex","setSelectedTabIndex","useEffect","preferredTabs","tab","animations","resetAnimation","newIndex","setPreferredTab","selectTab","CountryContent","except","CountryContext","country","BOTTOM_LEFT","BOTTOM_RIGHT","BOTTOM_CENTER","TOP_LEFT","TOP_CENTER","TOP_RIGHT","LEFT_BOTTOM","LEFT_CENTER","LEFT_TOP","RIGHT_BOTTOM","RIGHT_CENTER","RIGHT_TOP","useBreakpoint","maxPixels","_useState14","matchMedia","matches","setMatch","matcher","onMatch","evt","GuideLink","link","subtitle","exampleImage","accentColor","external","isMobile","isTablet","linkWidth","href","rel","alt","Link","IntroLink","icon","description","NextStep","side","displayType","ArticleTOC","listedItems","flattenTOCHeaders","articleHeaders","level","flatDeep","ah","Infinity","streamIcon","shortCodes","newProps","pre","Article","fullWidth","contents","hero","heroImg","heroTextColor","selectedTab","setSelectedTab","location","useLocation","qs","search","tabTitle","mainTabs","navigate","async","getElementsByTagName","clockIcon","updatedAt","childMdx","tableOfContents"],"mappings":"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","file":"10f43cfbd5bd2069b3e583c400fbdad38111bea7-4511d784b671f8860aae.js","sourcesContent":["var toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar $RangeError = RangeError;\n\nmodule.exports = function (it) {\n  var result = toIntegerOrInfinity(it);\n  if (result < 0) throw $RangeError(\"The argument can't be less than 0\");\n  return result;\n};\n","\"use strict\";\n\nvar deselectCurrent = require(\"toggle-selection\");\nvar clipboardToIE11Formatting = {\n  \"text/plain\": \"Text\",\n  \"text/html\": \"Url\",\n  \"default\": \"Text\"\n};\nvar defaultMessage = \"Copy to clipboard: #{key}, Enter\";\nfunction format(message) {\n  var copyKey = (/mac os x/i.test(navigator.userAgent) ? \"⌘\" : \"Ctrl\") + \"+C\";\n  return message.replace(/#{\\s*key\\s*}/g, copyKey);\n}\nfunction copy(text, options) {\n  var debug,\n    message,\n    reselectPrevious,\n    range,\n    selection,\n    mark,\n    success = false;\n  if (!options) {\n    options = {};\n  }\n  debug = options.debug || false;\n  try {\n    reselectPrevious = deselectCurrent();\n    range = document.createRange();\n    selection = document.getSelection();\n    mark = document.createElement(\"span\");\n    mark.textContent = text;\n    // avoid screen readers from reading out loud the text\n    mark.ariaHidden = \"true\";\n    // reset user styles for span element\n    mark.style.all = \"unset\";\n    // prevents scrolling to the end of the page\n    mark.style.position = \"fixed\";\n    mark.style.top = 0;\n    mark.style.clip = \"rect(0, 0, 0, 0)\";\n    // used to preserve spaces and line breaks\n    mark.style.whiteSpace = \"pre\";\n    // do not inherit user-select (it may be `none`)\n    mark.style.webkitUserSelect = \"text\";\n    mark.style.MozUserSelect = \"text\";\n    mark.style.msUserSelect = \"text\";\n    mark.style.userSelect = \"text\";\n    mark.addEventListener(\"copy\", function (e) {\n      e.stopPropagation();\n      if (options.format) {\n        e.preventDefault();\n        if (typeof e.clipboardData === \"undefined\") {\n          // IE 11\n          debug && console.warn(\"unable to use e.clipboardData\");\n          debug && console.warn(\"trying IE specific stuff\");\n          window.clipboardData.clearData();\n          var format = clipboardToIE11Formatting[options.format] || clipboardToIE11Formatting[\"default\"];\n          window.clipboardData.setData(format, text);\n        } else {\n          // all other browsers\n          e.clipboardData.clearData();\n          e.clipboardData.setData(options.format, text);\n        }\n      }\n      if (options.onCopy) {\n        e.preventDefault();\n        options.onCopy(e.clipboardData);\n      }\n    });\n    document.body.appendChild(mark);\n    range.selectNodeContents(mark);\n    selection.addRange(range);\n    var successful = document.execCommand(\"copy\");\n    if (!successful) {\n      throw new Error(\"copy command was unsuccessful\");\n    }\n    success = true;\n  } catch (err) {\n    debug && console.error(\"unable to copy using execCommand: \", err);\n    debug && console.warn(\"trying IE specific stuff\");\n    try {\n      window.clipboardData.setData(options.format || \"text\", text);\n      options.onCopy && options.onCopy(window.clipboardData);\n      success = true;\n    } catch (err) {\n      debug && console.error(\"unable to copy using clipboardData: \", err);\n      debug && console.error(\"falling back to prompt\");\n      message = format(\"message\" in options ? options.message : defaultMessage);\n      window.prompt(message, text);\n    }\n  } finally {\n    if (selection) {\n      if (typeof selection.removeRange == \"function\") {\n        selection.removeRange(range);\n      } else {\n        selection.removeAllRanges();\n      }\n    }\n    if (mark) {\n      document.body.removeChild(mark);\n    }\n    reselectPrevious();\n  }\n  return success;\n}\nmodule.exports = copy;","/* eslint-disable no-proto -- safe */\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\n// eslint-disable-next-line es/no-object-setprototypeof -- safe\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n  var CORRECT_SETTER = false;\n  var test = {};\n  var setter;\n  try {\n    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\n    setter = uncurryThis(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set);\n    setter(test, []);\n    CORRECT_SETTER = test instanceof Array;\n  } catch (error) { /* empty */ }\n  return function setPrototypeOf(O, proto) {\n    anObject(O);\n    aPossiblePrototype(proto);\n    if (CORRECT_SETTER) setter(O, proto);\n    else O.__proto__ = proto;\n    return O;\n  };\n}() : undefined);\n","function stylis_min(W) {\n  function M(d, c, e, h, a) {\n    for (var m = 0, b = 0, v = 0, n = 0, q, g, x = 0, K = 0, k, u = k = q = 0, l = 0, r = 0, I = 0, t = 0, B = e.length, J = B - 1, y, f = '', p = '', F = '', G = '', C; l < B;) {\n      g = e.charCodeAt(l);\n      l === J && 0 !== b + n + v + m && (0 !== b && (g = 47 === b ? 10 : 47), n = v = m = 0, B++, J++);\n      if (0 === b + n + v + m) {\n        if (l === J && (0 < r && (f = f.replace(N, '')), 0 < f.trim().length)) {\n          switch (g) {\n            case 32:\n            case 9:\n            case 59:\n            case 13:\n            case 10:\n              break;\n            default:\n              f += e.charAt(l);\n          }\n          g = 59;\n        }\n        switch (g) {\n          case 123:\n            f = f.trim();\n            q = f.charCodeAt(0);\n            k = 1;\n            for (t = ++l; l < B;) {\n              switch (g = e.charCodeAt(l)) {\n                case 123:\n                  k++;\n                  break;\n                case 125:\n                  k--;\n                  break;\n                case 47:\n                  switch (g = e.charCodeAt(l + 1)) {\n                    case 42:\n                    case 47:\n                      a: {\n                        for (u = l + 1; u < J; ++u) {\n                          switch (e.charCodeAt(u)) {\n                            case 47:\n                              if (42 === g && 42 === e.charCodeAt(u - 1) && l + 2 !== u) {\n                                l = u + 1;\n                                break a;\n                              }\n                              break;\n                            case 10:\n                              if (47 === g) {\n                                l = u + 1;\n                                break a;\n                              }\n                          }\n                        }\n                        l = u;\n                      }\n                  }\n                  break;\n                case 91:\n                  g++;\n                case 40:\n                  g++;\n                case 34:\n                case 39:\n                  for (; l++ < J && e.charCodeAt(l) !== g;) {}\n              }\n              if (0 === k) break;\n              l++;\n            }\n            k = e.substring(t, l);\n            0 === q && (q = (f = f.replace(ca, '').trim()).charCodeAt(0));\n            switch (q) {\n              case 64:\n                0 < r && (f = f.replace(N, ''));\n                g = f.charCodeAt(1);\n                switch (g) {\n                  case 100:\n                  case 109:\n                  case 115:\n                  case 45:\n                    r = c;\n                    break;\n                  default:\n                    r = O;\n                }\n                k = M(c, r, k, g, a + 1);\n                t = k.length;\n                0 < A && (r = X(O, f, I), C = H(3, k, r, c, D, z, t, g, a, h), f = r.join(''), void 0 !== C && 0 === (t = (k = C.trim()).length) && (g = 0, k = ''));\n                if (0 < t) switch (g) {\n                  case 115:\n                    f = f.replace(da, ea);\n                  case 100:\n                  case 109:\n                  case 45:\n                    k = f + '{' + k + '}';\n                    break;\n                  case 107:\n                    f = f.replace(fa, '$1 $2');\n                    k = f + '{' + k + '}';\n                    k = 1 === w || 2 === w && L('@' + k, 3) ? '@-webkit-' + k + '@' + k : '@' + k;\n                    break;\n                  default:\n                    k = f + k, 112 === h && (k = (p += k, ''));\n                } else k = '';\n                break;\n              default:\n                k = M(c, X(c, f, I), k, h, a + 1);\n            }\n            F += k;\n            k = I = r = u = q = 0;\n            f = '';\n            g = e.charCodeAt(++l);\n            break;\n          case 125:\n          case 59:\n            f = (0 < r ? f.replace(N, '') : f).trim();\n            if (1 < (t = f.length)) switch (0 === u && (q = f.charCodeAt(0), 45 === q || 96 < q && 123 > q) && (t = (f = f.replace(' ', ':')).length), 0 < A && void 0 !== (C = H(1, f, c, d, D, z, p.length, h, a, h)) && 0 === (t = (f = C.trim()).length) && (f = '\\x00\\x00'), q = f.charCodeAt(0), g = f.charCodeAt(1), q) {\n              case 0:\n                break;\n              case 64:\n                if (105 === g || 99 === g) {\n                  G += f + e.charAt(l);\n                  break;\n                }\n              default:\n                58 !== f.charCodeAt(t - 1) && (p += P(f, q, g, f.charCodeAt(2)));\n            }\n            I = r = u = q = 0;\n            f = '';\n            g = e.charCodeAt(++l);\n        }\n      }\n      switch (g) {\n        case 13:\n        case 10:\n          47 === b ? b = 0 : 0 === 1 + q && 107 !== h && 0 < f.length && (r = 1, f += '\\x00');\n          0 < A * Y && H(0, f, c, d, D, z, p.length, h, a, h);\n          z = 1;\n          D++;\n          break;\n        case 59:\n        case 125:\n          if (0 === b + n + v + m) {\n            z++;\n            break;\n          }\n        default:\n          z++;\n          y = e.charAt(l);\n          switch (g) {\n            case 9:\n            case 32:\n              if (0 === n + m + b) switch (x) {\n                case 44:\n                case 58:\n                case 9:\n                case 32:\n                  y = '';\n                  break;\n                default:\n                  32 !== g && (y = ' ');\n              }\n              break;\n            case 0:\n              y = '\\\\0';\n              break;\n            case 12:\n              y = '\\\\f';\n              break;\n            case 11:\n              y = '\\\\v';\n              break;\n            case 38:\n              0 === n + b + m && (r = I = 1, y = '\\f' + y);\n              break;\n            case 108:\n              if (0 === n + b + m + E && 0 < u) switch (l - u) {\n                case 2:\n                  112 === x && 58 === e.charCodeAt(l - 3) && (E = x);\n                case 8:\n                  111 === K && (E = K);\n              }\n              break;\n            case 58:\n              0 === n + b + m && (u = l);\n              break;\n            case 44:\n              0 === b + v + n + m && (r = 1, y += '\\r');\n              break;\n            case 34:\n            case 39:\n              0 === b && (n = n === g ? 0 : 0 === n ? g : n);\n              break;\n            case 91:\n              0 === n + b + v && m++;\n              break;\n            case 93:\n              0 === n + b + v && m--;\n              break;\n            case 41:\n              0 === n + b + m && v--;\n              break;\n            case 40:\n              if (0 === n + b + m) {\n                if (0 === q) switch (2 * x + 3 * K) {\n                  case 533:\n                    break;\n                  default:\n                    q = 1;\n                }\n                v++;\n              }\n              break;\n            case 64:\n              0 === b + v + n + m + u + k && (k = 1);\n              break;\n            case 42:\n            case 47:\n              if (!(0 < n + m + v)) switch (b) {\n                case 0:\n                  switch (2 * g + 3 * e.charCodeAt(l + 1)) {\n                    case 235:\n                      b = 47;\n                      break;\n                    case 220:\n                      t = l, b = 42;\n                  }\n                  break;\n                case 42:\n                  47 === g && 42 === x && t + 2 !== l && (33 === e.charCodeAt(t + 2) && (p += e.substring(t, l + 1)), y = '', b = 0);\n              }\n          }\n          0 === b && (f += y);\n      }\n      K = x;\n      x = g;\n      l++;\n    }\n    t = p.length;\n    if (0 < t) {\n      r = c;\n      if (0 < A && (C = H(2, p, r, d, D, z, t, h, a, h), void 0 !== C && 0 === (p = C).length)) return G + p + F;\n      p = r.join(',') + '{' + p + '}';\n      if (0 !== w * E) {\n        2 !== w || L(p, 2) || (E = 0);\n        switch (E) {\n          case 111:\n            p = p.replace(ha, ':-moz-$1') + p;\n            break;\n          case 112:\n            p = p.replace(Q, '::-webkit-input-$1') + p.replace(Q, '::-moz-$1') + p.replace(Q, ':-ms-input-$1') + p;\n        }\n        E = 0;\n      }\n    }\n    return G + p + F;\n  }\n  function X(d, c, e) {\n    var h = c.trim().split(ia);\n    c = h;\n    var a = h.length,\n      m = d.length;\n    switch (m) {\n      case 0:\n      case 1:\n        var b = 0;\n        for (d = 0 === m ? '' : d[0] + ' '; b < a; ++b) {\n          c[b] = Z(d, c[b], e).trim();\n        }\n        break;\n      default:\n        var v = b = 0;\n        for (c = []; b < a; ++b) {\n          for (var n = 0; n < m; ++n) {\n            c[v++] = Z(d[n] + ' ', h[b], e).trim();\n          }\n        }\n    }\n    return c;\n  }\n  function Z(d, c, e) {\n    var h = c.charCodeAt(0);\n    33 > h && (h = (c = c.trim()).charCodeAt(0));\n    switch (h) {\n      case 38:\n        return c.replace(F, '$1' + d.trim());\n      case 58:\n        return d.trim() + c.replace(F, '$1' + d.trim());\n      default:\n        if (0 < 1 * e && 0 < c.indexOf('\\f')) return c.replace(F, (58 === d.charCodeAt(0) ? '' : '$1') + d.trim());\n    }\n    return d + c;\n  }\n  function P(d, c, e, h) {\n    var a = d + ';',\n      m = 2 * c + 3 * e + 4 * h;\n    if (944 === m) {\n      d = a.indexOf(':', 9) + 1;\n      var b = a.substring(d, a.length - 1).trim();\n      b = a.substring(0, d).trim() + b + ';';\n      return 1 === w || 2 === w && L(b, 1) ? '-webkit-' + b + b : b;\n    }\n    if (0 === w || 2 === w && !L(a, 1)) return a;\n    switch (m) {\n      case 1015:\n        return 97 === a.charCodeAt(10) ? '-webkit-' + a + a : a;\n      case 951:\n        return 116 === a.charCodeAt(3) ? '-webkit-' + a + a : a;\n      case 963:\n        return 110 === a.charCodeAt(5) ? '-webkit-' + a + a : a;\n      case 1009:\n        if (100 !== a.charCodeAt(4)) break;\n      case 969:\n      case 942:\n        return '-webkit-' + a + a;\n      case 978:\n        return '-webkit-' + a + '-moz-' + a + a;\n      case 1019:\n      case 983:\n        return '-webkit-' + a + '-moz-' + a + '-ms-' + a + a;\n      case 883:\n        if (45 === a.charCodeAt(8)) return '-webkit-' + a + a;\n        if (0 < a.indexOf('image-set(', 11)) return a.replace(ja, '$1-webkit-$2') + a;\n        break;\n      case 932:\n        if (45 === a.charCodeAt(4)) switch (a.charCodeAt(5)) {\n          case 103:\n            return '-webkit-box-' + a.replace('-grow', '') + '-webkit-' + a + '-ms-' + a.replace('grow', 'positive') + a;\n          case 115:\n            return '-webkit-' + a + '-ms-' + a.replace('shrink', 'negative') + a;\n          case 98:\n            return '-webkit-' + a + '-ms-' + a.replace('basis', 'preferred-size') + a;\n        }\n        return '-webkit-' + a + '-ms-' + a + a;\n      case 964:\n        return '-webkit-' + a + '-ms-flex-' + a + a;\n      case 1023:\n        if (99 !== a.charCodeAt(8)) break;\n        b = a.substring(a.indexOf(':', 15)).replace('flex-', '').replace('space-between', 'justify');\n        return '-webkit-box-pack' + b + '-webkit-' + a + '-ms-flex-pack' + b + a;\n      case 1005:\n        return ka.test(a) ? a.replace(aa, ':-webkit-') + a.replace(aa, ':-moz-') + a : a;\n      case 1e3:\n        b = a.substring(13).trim();\n        c = b.indexOf('-') + 1;\n        switch (b.charCodeAt(0) + b.charCodeAt(c)) {\n          case 226:\n            b = a.replace(G, 'tb');\n            break;\n          case 232:\n            b = a.replace(G, 'tb-rl');\n            break;\n          case 220:\n            b = a.replace(G, 'lr');\n            break;\n          default:\n            return a;\n        }\n        return '-webkit-' + a + '-ms-' + b + a;\n      case 1017:\n        if (-1 === a.indexOf('sticky', 9)) break;\n      case 975:\n        c = (a = d).length - 10;\n        b = (33 === a.charCodeAt(c) ? a.substring(0, c) : a).substring(d.indexOf(':', 7) + 1).trim();\n        switch (m = b.charCodeAt(0) + (b.charCodeAt(7) | 0)) {\n          case 203:\n            if (111 > b.charCodeAt(8)) break;\n          case 115:\n            a = a.replace(b, '-webkit-' + b) + ';' + a;\n            break;\n          case 207:\n          case 102:\n            a = a.replace(b, '-webkit-' + (102 < m ? 'inline-' : '') + 'box') + ';' + a.replace(b, '-webkit-' + b) + ';' + a.replace(b, '-ms-' + b + 'box') + ';' + a;\n        }\n        return a + ';';\n      case 938:\n        if (45 === a.charCodeAt(5)) switch (a.charCodeAt(6)) {\n          case 105:\n            return b = a.replace('-items', ''), '-webkit-' + a + '-webkit-box-' + b + '-ms-flex-' + b + a;\n          case 115:\n            return '-webkit-' + a + '-ms-flex-item-' + a.replace(ba, '') + a;\n          default:\n            return '-webkit-' + a + '-ms-flex-line-pack' + a.replace('align-content', '').replace(ba, '') + a;\n        }\n        break;\n      case 973:\n      case 989:\n        if (45 !== a.charCodeAt(3) || 122 === a.charCodeAt(4)) break;\n      case 931:\n      case 953:\n        if (!0 === la.test(d)) return 115 === (b = d.substring(d.indexOf(':') + 1)).charCodeAt(0) ? P(d.replace('stretch', 'fill-available'), c, e, h).replace(':fill-available', ':stretch') : a.replace(b, '-webkit-' + b) + a.replace(b, '-moz-' + b.replace('fill-', '')) + a;\n        break;\n      case 962:\n        if (a = '-webkit-' + a + (102 === a.charCodeAt(5) ? '-ms-' + a : '') + a, 211 === e + h && 105 === a.charCodeAt(13) && 0 < a.indexOf('transform', 10)) return a.substring(0, a.indexOf(';', 27) + 1).replace(ma, '$1-webkit-$2') + a;\n    }\n    return a;\n  }\n  function L(d, c) {\n    var e = d.indexOf(1 === c ? ':' : '{'),\n      h = d.substring(0, 3 !== c ? e : 10);\n    e = d.substring(e + 1, d.length - 1);\n    return R(2 !== c ? h : h.replace(na, '$1'), e, c);\n  }\n  function ea(d, c) {\n    var e = P(c, c.charCodeAt(0), c.charCodeAt(1), c.charCodeAt(2));\n    return e !== c + ';' ? e.replace(oa, ' or ($1)').substring(4) : '(' + c + ')';\n  }\n  function H(d, c, e, h, a, m, b, v, n, q) {\n    for (var g = 0, x = c, w; g < A; ++g) {\n      switch (w = S[g].call(B, d, x, e, h, a, m, b, v, n, q)) {\n        case void 0:\n        case !1:\n        case !0:\n        case null:\n          break;\n        default:\n          x = w;\n      }\n    }\n    if (x !== c) return x;\n  }\n  function T(d) {\n    switch (d) {\n      case void 0:\n      case null:\n        A = S.length = 0;\n        break;\n      default:\n        if ('function' === typeof d) S[A++] = d;else if ('object' === typeof d) for (var c = 0, e = d.length; c < e; ++c) {\n          T(d[c]);\n        } else Y = !!d | 0;\n    }\n    return T;\n  }\n  function U(d) {\n    d = d.prefix;\n    void 0 !== d && (R = null, d ? 'function' !== typeof d ? w = 1 : (w = 2, R = d) : w = 0);\n    return U;\n  }\n  function B(d, c) {\n    var e = d;\n    33 > e.charCodeAt(0) && (e = e.trim());\n    V = e;\n    e = [V];\n    if (0 < A) {\n      var h = H(-1, c, e, e, D, z, 0, 0, 0, 0);\n      void 0 !== h && 'string' === typeof h && (c = h);\n    }\n    var a = M(O, e, c, 0, 0);\n    0 < A && (h = H(-2, a, e, e, D, z, a.length, 0, 0, 0), void 0 !== h && (a = h));\n    V = '';\n    E = 0;\n    z = D = 1;\n    return a;\n  }\n  var ca = /^\\0+/g,\n    N = /[\\0\\r\\f]/g,\n    aa = /: */g,\n    ka = /zoo|gra/,\n    ma = /([,: ])(transform)/g,\n    ia = /,\\r+?/g,\n    F = /([\\t\\r\\n ])*\\f?&/g,\n    fa = /@(k\\w+)\\s*(\\S*)\\s*/,\n    Q = /::(place)/g,\n    ha = /:(read-only)/g,\n    G = /[svh]\\w+-[tblr]{2}/,\n    da = /\\(\\s*(.*)\\s*\\)/g,\n    oa = /([\\s\\S]*?);/g,\n    ba = /-self|flex-/g,\n    na = /[^]*?(:[rp][el]a[\\w-]+)[^]*/,\n    la = /stretch|:\\s*\\w+\\-(?:conte|avail)/,\n    ja = /([^-])(image-set\\()/,\n    z = 1,\n    D = 1,\n    E = 0,\n    w = 1,\n    O = [],\n    S = [],\n    A = 0,\n    R = null,\n    Y = 0,\n    V = '';\n  B.use = T;\n  B.set = U;\n  void 0 !== W && U(W);\n  return B;\n}\nexport default stylis_min;","var hasOwn = require('../internals/has-own-property');\nvar isCallable = require('../internals/is-callable');\nvar toObject = require('../internals/to-object');\nvar sharedKey = require('../internals/shared-key');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar $Object = Object;\nvar ObjectPrototype = $Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.getprototypeof\n// eslint-disable-next-line es/no-object-getprototypeof -- safe\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {\n  var object = toObject(O);\n  if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];\n  var constructor = object.constructor;\n  if (isCallable(constructor) && object instanceof constructor) {\n    return constructor.prototype;\n  } return object instanceof $Object ? ObjectPrototype : null;\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n  function F() { /* empty */ }\n  F.prototype.constructor = null;\n  // eslint-disable-next-line es/no-object-getprototypeof -- required for testing\n  return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","'use strict';\nvar NATIVE_ARRAY_BUFFER = require('../internals/array-buffer-basic-detection');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar hasOwn = require('../internals/has-own-property');\nvar classof = require('../internals/classof');\nvar tryToString = require('../internals/try-to-string');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar defineProperty = require('../internals/object-define-property').f;\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar uid = require('../internals/uid');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar enforceInternalState = InternalStateModule.enforce;\nvar getInternalState = InternalStateModule.get;\nvar Int8Array = global.Int8Array;\nvar Int8ArrayPrototype = Int8Array && Int8Array.prototype;\nvar Uint8ClampedArray = global.Uint8ClampedArray;\nvar Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype;\nvar TypedArray = Int8Array && getPrototypeOf(Int8Array);\nvar TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype);\nvar ObjectPrototype = Object.prototype;\nvar TypeError = global.TypeError;\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG');\nvar TYPED_ARRAY_CONSTRUCTOR = 'TypedArrayConstructor';\n// Fixing native typed arrays in Opera Presto crashes the browser, see #595\nvar NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf && classof(global.opera) !== 'Opera';\nvar TYPED_ARRAY_TAG_REQUIRED = false;\nvar NAME, Constructor, Prototype;\n\nvar TypedArrayConstructorsList = {\n  Int8Array: 1,\n  Uint8Array: 1,\n  Uint8ClampedArray: 1,\n  Int16Array: 2,\n  Uint16Array: 2,\n  Int32Array: 4,\n  Uint32Array: 4,\n  Float32Array: 4,\n  Float64Array: 8\n};\n\nvar BigIntArrayConstructorsList = {\n  BigInt64Array: 8,\n  BigUint64Array: 8\n};\n\nvar isView = function isView(it) {\n  if (!isObject(it)) return false;\n  var klass = classof(it);\n  return klass === 'DataView'\n    || hasOwn(TypedArrayConstructorsList, klass)\n    || hasOwn(BigIntArrayConstructorsList, klass);\n};\n\nvar getTypedArrayConstructor = function (it) {\n  var proto = getPrototypeOf(it);\n  if (!isObject(proto)) return;\n  var state = getInternalState(proto);\n  return (state && hasOwn(state, TYPED_ARRAY_CONSTRUCTOR)) ? state[TYPED_ARRAY_CONSTRUCTOR] : getTypedArrayConstructor(proto);\n};\n\nvar isTypedArray = function (it) {\n  if (!isObject(it)) return false;\n  var klass = classof(it);\n  return hasOwn(TypedArrayConstructorsList, klass)\n    || hasOwn(BigIntArrayConstructorsList, klass);\n};\n\nvar aTypedArray = function (it) {\n  if (isTypedArray(it)) return it;\n  throw TypeError('Target is not a typed array');\n};\n\nvar aTypedArrayConstructor = function (C) {\n  if (isCallable(C) && (!setPrototypeOf || isPrototypeOf(TypedArray, C))) return C;\n  throw TypeError(tryToString(C) + ' is not a typed array constructor');\n};\n\nvar exportTypedArrayMethod = function (KEY, property, forced, options) {\n  if (!DESCRIPTORS) return;\n  if (forced) for (var ARRAY in TypedArrayConstructorsList) {\n    var TypedArrayConstructor = global[ARRAY];\n    if (TypedArrayConstructor && hasOwn(TypedArrayConstructor.prototype, KEY)) try {\n      delete TypedArrayConstructor.prototype[KEY];\n    } catch (error) {\n      // old WebKit bug - some methods are non-configurable\n      try {\n        TypedArrayConstructor.prototype[KEY] = property;\n      } catch (error2) { /* empty */ }\n    }\n  }\n  if (!TypedArrayPrototype[KEY] || forced) {\n    defineBuiltIn(TypedArrayPrototype, KEY, forced ? property\n      : NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property, options);\n  }\n};\n\nvar exportTypedArrayStaticMethod = function (KEY, property, forced) {\n  var ARRAY, TypedArrayConstructor;\n  if (!DESCRIPTORS) return;\n  if (setPrototypeOf) {\n    if (forced) for (ARRAY in TypedArrayConstructorsList) {\n      TypedArrayConstructor = global[ARRAY];\n      if (TypedArrayConstructor && hasOwn(TypedArrayConstructor, KEY)) try {\n        delete TypedArrayConstructor[KEY];\n      } catch (error) { /* empty */ }\n    }\n    if (!TypedArray[KEY] || forced) {\n      // V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable\n      try {\n        return defineBuiltIn(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && TypedArray[KEY] || property);\n      } catch (error) { /* empty */ }\n    } else return;\n  }\n  for (ARRAY in TypedArrayConstructorsList) {\n    TypedArrayConstructor = global[ARRAY];\n    if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) {\n      defineBuiltIn(TypedArrayConstructor, KEY, property);\n    }\n  }\n};\n\nfor (NAME in TypedArrayConstructorsList) {\n  Constructor = global[NAME];\n  Prototype = Constructor && Constructor.prototype;\n  if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;\n  else NATIVE_ARRAY_BUFFER_VIEWS = false;\n}\n\nfor (NAME in BigIntArrayConstructorsList) {\n  Constructor = global[NAME];\n  Prototype = Constructor && Constructor.prototype;\n  if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;\n}\n\n// WebKit bug - typed arrays constructors prototype is Object.prototype\nif (!NATIVE_ARRAY_BUFFER_VIEWS || !isCallable(TypedArray) || TypedArray === Function.prototype) {\n  // eslint-disable-next-line no-shadow -- safe\n  TypedArray = function TypedArray() {\n    throw TypeError('Incorrect invocation');\n  };\n  if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {\n    if (global[NAME]) setPrototypeOf(global[NAME], TypedArray);\n  }\n}\n\nif (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) {\n  TypedArrayPrototype = TypedArray.prototype;\n  if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {\n    if (global[NAME]) setPrototypeOf(global[NAME].prototype, TypedArrayPrototype);\n  }\n}\n\n// WebKit bug - one more object in Uint8ClampedArray prototype chain\nif (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) {\n  setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype);\n}\n\nif (DESCRIPTORS && !hasOwn(TypedArrayPrototype, TO_STRING_TAG)) {\n  TYPED_ARRAY_TAG_REQUIRED = true;\n  defineProperty(TypedArrayPrototype, TO_STRING_TAG, { get: function () {\n    return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined;\n  } });\n  for (NAME in TypedArrayConstructorsList) if (global[NAME]) {\n    createNonEnumerableProperty(global[NAME], TYPED_ARRAY_TAG, NAME);\n  }\n}\n\nmodule.exports = {\n  NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS,\n  TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQUIRED && TYPED_ARRAY_TAG,\n  aTypedArray: aTypedArray,\n  aTypedArrayConstructor: aTypedArrayConstructor,\n  exportTypedArrayMethod: exportTypedArrayMethod,\n  exportTypedArrayStaticMethod: exportTypedArrayStaticMethod,\n  getTypedArrayConstructor: getTypedArrayConstructor,\n  isView: isView,\n  isTypedArray: isTypedArray,\n  TypedArray: TypedArray,\n  TypedArrayPrototype: TypedArrayPrototype\n};\n","var setPrototypeOf = require(\"./setPrototypeOf.js\");\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  Object.defineProperty(subClass, \"prototype\", {\n    writable: false\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}\nmodule.exports = _inherits, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","'use strict';\n\nvar token = '%[a-f0-9]{2}';\nvar singleMatcher = new RegExp(token, 'gi');\nvar multiMatcher = new RegExp('(' + token + ')+', 'gi');\nfunction decodeComponents(components, split) {\n  try {\n    // Try to decode the entire string first\n    return decodeURIComponent(components.join(''));\n  } catch (err) {\n    // Do nothing\n  }\n  if (components.length === 1) {\n    return components;\n  }\n  split = split || 1;\n\n  // Split the array in 2 parts\n  var left = components.slice(0, split);\n  var right = components.slice(split);\n  return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));\n}\nfunction decode(input) {\n  try {\n    return decodeURIComponent(input);\n  } catch (err) {\n    var tokens = input.match(singleMatcher);\n    for (var i = 1; i < tokens.length; i++) {\n      input = decodeComponents(tokens, i).join('');\n      tokens = input.match(singleMatcher);\n    }\n    return input;\n  }\n}\nfunction customDecodeURIComponent(input) {\n  // Keep track of all the replacements and prefill the map with the `BOM`\n  var replaceMap = {\n    '%FE%FF': \"\\uFFFD\\uFFFD\",\n    '%FF%FE': \"\\uFFFD\\uFFFD\"\n  };\n  var match = multiMatcher.exec(input);\n  while (match) {\n    try {\n      // Decode as big chunks as possible\n      replaceMap[match[0]] = decodeURIComponent(match[0]);\n    } catch (err) {\n      var result = decode(match[0]);\n      if (result !== match[0]) {\n        replaceMap[match[0]] = result;\n      }\n    }\n    match = multiMatcher.exec(input);\n  }\n\n  // Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else\n  replaceMap['%C2'] = \"\\uFFFD\";\n  var entries = Object.keys(replaceMap);\n  for (var i = 0; i < entries.length; i++) {\n    // Replace all decoded components\n    var key = entries[i];\n    input = input.replace(new RegExp(key, 'g'), replaceMap[key]);\n  }\n  return input;\n}\nmodule.exports = function (encodedURI) {\n  if (typeof encodedURI !== 'string') {\n    throw new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');\n  }\n  try {\n    encodedURI = encodedURI.replace(/\\+/g, ' ');\n\n    // Try the built in decoder first\n    return decodeURIComponent(encodedURI);\n  } catch (err) {\n    // Fallback to a more advanced decoder\n    return customDecodeURIComponent(encodedURI);\n  }\n};","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\nfunction defaultSetTimout() {\n  throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout() {\n  throw new Error('clearTimeout has not been defined');\n}\n(function () {\n  try {\n    if (typeof setTimeout === 'function') {\n      cachedSetTimeout = setTimeout;\n    } else {\n      cachedSetTimeout = defaultSetTimout;\n    }\n  } catch (e) {\n    cachedSetTimeout = defaultSetTimout;\n  }\n  try {\n    if (typeof clearTimeout === 'function') {\n      cachedClearTimeout = clearTimeout;\n    } else {\n      cachedClearTimeout = defaultClearTimeout;\n    }\n  } catch (e) {\n    cachedClearTimeout = defaultClearTimeout;\n  }\n})();\nfunction runTimeout(fun) {\n  if (cachedSetTimeout === setTimeout) {\n    //normal enviroments in sane situations\n    return setTimeout(fun, 0);\n  }\n  // if setTimeout wasn't available but was latter defined\n  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n    cachedSetTimeout = setTimeout;\n    return setTimeout(fun, 0);\n  }\n  try {\n    // when when somebody has screwed with setTimeout but no I.E. maddness\n    return cachedSetTimeout(fun, 0);\n  } catch (e) {\n    try {\n      // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n      return cachedSetTimeout.call(null, fun, 0);\n    } catch (e) {\n      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n      return cachedSetTimeout.call(this, fun, 0);\n    }\n  }\n}\nfunction runClearTimeout(marker) {\n  if (cachedClearTimeout === clearTimeout) {\n    //normal enviroments in sane situations\n    return clearTimeout(marker);\n  }\n  // if clearTimeout wasn't available but was latter defined\n  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n    cachedClearTimeout = clearTimeout;\n    return clearTimeout(marker);\n  }\n  try {\n    // when when somebody has screwed with setTimeout but no I.E. maddness\n    return cachedClearTimeout(marker);\n  } catch (e) {\n    try {\n      // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n      return cachedClearTimeout.call(null, marker);\n    } catch (e) {\n      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n      // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n      return cachedClearTimeout.call(this, marker);\n    }\n  }\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\nfunction cleanUpNextTick() {\n  if (!draining || !currentQueue) {\n    return;\n  }\n  draining = false;\n  if (currentQueue.length) {\n    queue = currentQueue.concat(queue);\n  } else {\n    queueIndex = -1;\n  }\n  if (queue.length) {\n    drainQueue();\n  }\n}\nfunction drainQueue() {\n  if (draining) {\n    return;\n  }\n  var timeout = runTimeout(cleanUpNextTick);\n  draining = true;\n  var len = queue.length;\n  while (len) {\n    currentQueue = queue;\n    queue = [];\n    while (++queueIndex < len) {\n      if (currentQueue) {\n        currentQueue[queueIndex].run();\n      }\n    }\n    queueIndex = -1;\n    len = queue.length;\n  }\n  currentQueue = null;\n  draining = false;\n  runClearTimeout(timeout);\n}\nprocess.nextTick = function (fun) {\n  var args = new Array(arguments.length - 1);\n  if (arguments.length > 1) {\n    for (var i = 1; i < arguments.length; i++) {\n      args[i - 1] = arguments[i];\n    }\n  }\n  queue.push(new Item(fun, args));\n  if (queue.length === 1 && !draining) {\n    runTimeout(drainQueue);\n  }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n  this.fun = fun;\n  this.array = array;\n}\nItem.prototype.run = function () {\n  this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\nfunction noop() {}\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\nprocess.listeners = function (name) {\n  return [];\n};\nprocess.binding = function (name) {\n  throw new Error('process.binding is not supported');\n};\nprocess.cwd = function () {\n  return '/';\n};\nprocess.chdir = function (dir) {\n  throw new Error('process.chdir is not supported');\n};\nprocess.umask = function () {\n  return 0;\n};","'use strict';\n\nmodule.exports = function (string, separator) {\n  if (!(typeof string === 'string' && typeof separator === 'string')) {\n    throw new TypeError('Expected the arguments to be of type `string`');\n  }\n  if (separator === '') {\n    return [string];\n  }\n  var separatorIndex = string.indexOf(separator);\n  if (separatorIndex === -1) {\n    return [string];\n  }\n  return [string.slice(0, separatorIndex), string.slice(separatorIndex + separator.length)];\n};","/**\n * Welcome to gatsby-plugin-mdx!\n *\n * Start reading in gatsby-node.js\n */\n\nconst MDXRenderer = require(`./mdx-renderer`)\n\nmodule.exports = {\n  MDXRenderer: MDXRenderer,\n}\n","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nmodule.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","module.exports = function () {\n  var selection = document.getSelection();\n  if (!selection.rangeCount) {\n    return function () {};\n  }\n  var active = document.activeElement;\n  var ranges = [];\n  for (var i = 0; i < selection.rangeCount; i++) {\n    ranges.push(selection.getRangeAt(i));\n  }\n  switch (active.tagName.toUpperCase()) {\n    // .toUpperCase handles XHTML\n    case 'INPUT':\n    case 'TEXTAREA':\n      active.blur();\n      break;\n    default:\n      active = null;\n      break;\n  }\n  selection.removeAllRanges();\n  return function () {\n    selection.type === 'Caret' && selection.removeAllRanges();\n    if (!selection.rangeCount) {\n      ranges.forEach(function (range) {\n        selection.addRange(range);\n      });\n    }\n    active && active.focus();\n  };\n};","'use strict';\n\nmodule.exports = csharp;\ncsharp.displayName = 'csharp';\ncsharp.aliases = ['dotnet', 'cs'];\nfunction csharp(Prism) {\n  ;\n  (function (Prism) {\n    /**\n     * Replaces all placeholders \"<<n>>\" of given pattern with the n-th replacement (zero based).\n     *\n     * Note: This is a simple text based replacement. Be careful when using backreferences!\n     *\n     * @param {string} pattern the given pattern.\n     * @param {string[]} replacements a list of replacement which can be inserted into the given pattern.\n     * @returns {string} the pattern with all placeholders replaced with their corresponding replacements.\n     * @example replace(/a<<0>>a/.source, [/b+/.source]) === /a(?:b+)a/.source\n     */\n    function replace(pattern, replacements) {\n      return pattern.replace(/<<(\\d+)>>/g, function (m, index) {\n        return '(?:' + replacements[+index] + ')';\n      });\n    }\n    /**\n     * @param {string} pattern\n     * @param {string[]} replacements\n     * @param {string} [flags]\n     * @returns {RegExp}\n     */\n    function re(pattern, replacements, flags) {\n      return RegExp(replace(pattern, replacements), flags || '');\n    }\n    /**\n     * Creates a nested pattern where all occurrences of the string `<<self>>` are replaced with the pattern itself.\n     *\n     * @param {string} pattern\n     * @param {number} depthLog2\n     * @returns {string}\n     */\n    function nested(pattern, depthLog2) {\n      for (var i = 0; i < depthLog2; i++) {\n        pattern = pattern.replace(/<<self>>/g, function () {\n          return '(?:' + pattern + ')';\n        });\n      }\n      return pattern.replace(/<<self>>/g, '[^\\\\s\\\\S]');\n    } // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/\n    var keywordKinds = {\n      // keywords which represent a return or variable type\n      type: 'bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void',\n      // keywords which are used to declare a type\n      typeDeclaration: 'class enum interface record struct',\n      // contextual keywords\n      // (\"var\" and \"dynamic\" are missing because they are used like types)\n      contextual: 'add alias and ascending async await by descending from(?=\\\\s*(?:\\\\w|$)) get global group into init(?=\\\\s*;) join let nameof not notnull on or orderby partial remove select set unmanaged value when where with(?=\\\\s*{)',\n      // all other keywords\n      other: 'abstract as base break case catch checked const continue default delegate do else event explicit extern finally fixed for foreach goto if implicit in internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static switch this throw try typeof unchecked unsafe using virtual volatile while yield'\n    }; // keywords\n    function keywordsToPattern(words) {\n      return '\\\\b(?:' + words.trim().replace(/ /g, '|') + ')\\\\b';\n    }\n    var typeDeclarationKeywords = keywordsToPattern(keywordKinds.typeDeclaration);\n    var keywords = RegExp(keywordsToPattern(keywordKinds.type + ' ' + keywordKinds.typeDeclaration + ' ' + keywordKinds.contextual + ' ' + keywordKinds.other));\n    var nonTypeKeywords = keywordsToPattern(keywordKinds.typeDeclaration + ' ' + keywordKinds.contextual + ' ' + keywordKinds.other);\n    var nonContextualKeywords = keywordsToPattern(keywordKinds.type + ' ' + keywordKinds.typeDeclaration + ' ' + keywordKinds.other); // types\n    var generic = nested(/<(?:[^<>;=+\\-*/%&|^]|<<self>>)*>/.source, 2); // the idea behind the other forbidden characters is to prevent false positives. Same for tupleElement.\n    var nestedRound = nested(/\\((?:[^()]|<<self>>)*\\)/.source, 2);\n    var name = /@?\\b[A-Za-z_]\\w*\\b/.source;\n    var genericName = replace(/<<0>>(?:\\s*<<1>>)?/.source, [name, generic]);\n    var identifier = replace(/(?!<<0>>)<<1>>(?:\\s*\\.\\s*<<1>>)*/.source, [nonTypeKeywords, genericName]);\n    var array = /\\[\\s*(?:,\\s*)*\\]/.source;\n    var typeExpressionWithoutTuple = replace(/<<0>>(?:\\s*(?:\\?\\s*)?<<1>>)*(?:\\s*\\?)?/.source, [identifier, array]);\n    var tupleElement = replace(/[^,()<>[\\];=+\\-*/%&|^]|<<0>>|<<1>>|<<2>>/.source, [generic, nestedRound, array]);\n    var tuple = replace(/\\(<<0>>+(?:,<<0>>+)+\\)/.source, [tupleElement]);\n    var typeExpression = replace(/(?:<<0>>|<<1>>)(?:\\s*(?:\\?\\s*)?<<2>>)*(?:\\s*\\?)?/.source, [tuple, identifier, array]);\n    var typeInside = {\n      keyword: keywords,\n      punctuation: /[<>()?,.:[\\]]/\n    }; // strings & characters\n    // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#character-literals\n    // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#string-literals\n    var character = /'(?:[^\\r\\n'\\\\]|\\\\.|\\\\[Uux][\\da-fA-F]{1,8})'/.source; // simplified pattern\n    var regularString = /\"(?:\\\\.|[^\\\\\"\\r\\n])*\"/.source;\n    var verbatimString = /@\"(?:\"\"|\\\\[\\s\\S]|[^\\\\\"])*\"(?!\")/.source;\n    Prism.languages.csharp = Prism.languages.extend('clike', {\n      string: [{\n        pattern: re(/(^|[^$\\\\])<<0>>/.source, [verbatimString]),\n        lookbehind: true,\n        greedy: true\n      }, {\n        pattern: re(/(^|[^@$\\\\])<<0>>/.source, [regularString]),\n        lookbehind: true,\n        greedy: true\n      }],\n      'class-name': [{\n        // Using static\n        // using static System.Math;\n        pattern: re(/(\\busing\\s+static\\s+)<<0>>(?=\\s*;)/.source, [identifier]),\n        lookbehind: true,\n        inside: typeInside\n      }, {\n        // Using alias (type)\n        // using Project = PC.MyCompany.Project;\n        pattern: re(/(\\busing\\s+<<0>>\\s*=\\s*)<<1>>(?=\\s*;)/.source, [name, typeExpression]),\n        lookbehind: true,\n        inside: typeInside\n      }, {\n        // Using alias (alias)\n        // using Project = PC.MyCompany.Project;\n        pattern: re(/(\\busing\\s+)<<0>>(?=\\s*=)/.source, [name]),\n        lookbehind: true\n      }, {\n        // Type declarations\n        // class Foo<A, B>\n        // interface Foo<out A, B>\n        pattern: re(/(\\b<<0>>\\s+)<<1>>/.source, [typeDeclarationKeywords, genericName]),\n        lookbehind: true,\n        inside: typeInside\n      }, {\n        // Single catch exception declaration\n        // catch(Foo)\n        // (things like catch(Foo e) is covered by variable declaration)\n        pattern: re(/(\\bcatch\\s*\\(\\s*)<<0>>/.source, [identifier]),\n        lookbehind: true,\n        inside: typeInside\n      }, {\n        // Name of the type parameter of generic constraints\n        // where Foo : class\n        pattern: re(/(\\bwhere\\s+)<<0>>/.source, [name]),\n        lookbehind: true\n      }, {\n        // Casts and checks via as and is.\n        // as Foo<A>, is Bar<B>\n        // (things like if(a is Foo b) is covered by variable declaration)\n        pattern: re(/(\\b(?:is(?:\\s+not)?|as)\\s+)<<0>>/.source, [typeExpressionWithoutTuple]),\n        lookbehind: true,\n        inside: typeInside\n      }, {\n        // Variable, field and parameter declaration\n        // (Foo bar, Bar baz, Foo[,,] bay, Foo<Bar, FooBar<Bar>> bax)\n        pattern: re(/\\b<<0>>(?=\\s+(?!<<1>>|with\\s*\\{)<<2>>(?:\\s*[=,;:{)\\]]|\\s+(?:in|when)\\b))/.source, [typeExpression, nonContextualKeywords, name]),\n        inside: typeInside\n      }],\n      keyword: keywords,\n      // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#literals\n      number: /(?:\\b0(?:x[\\da-f_]*[\\da-f]|b[01_]*[01])|(?:\\B\\.\\d+(?:_+\\d+)*|\\b\\d+(?:_+\\d+)*(?:\\.\\d+(?:_+\\d+)*)?)(?:e[-+]?\\d+(?:_+\\d+)*)?)(?:[dflmu]|lu|ul)?\\b/i,\n      operator: />>=?|<<=?|[-=]>|([-+&|])\\1|~|\\?\\?=?|[-+*/%&|^!=<>]=?/,\n      punctuation: /\\?\\.?|::|[{}[\\];(),.:]/\n    });\n    Prism.languages.insertBefore('csharp', 'number', {\n      range: {\n        pattern: /\\.\\./,\n        alias: 'operator'\n      }\n    });\n    Prism.languages.insertBefore('csharp', 'punctuation', {\n      'named-parameter': {\n        pattern: re(/([(,]\\s*)<<0>>(?=\\s*:)/.source, [name]),\n        lookbehind: true,\n        alias: 'punctuation'\n      }\n    });\n    Prism.languages.insertBefore('csharp', 'class-name', {\n      namespace: {\n        // namespace Foo.Bar {}\n        // using Foo.Bar;\n        pattern: re(/(\\b(?:namespace|using)\\s+)<<0>>(?:\\s*\\.\\s*<<0>>)*(?=\\s*[;{])/.source, [name]),\n        lookbehind: true,\n        inside: {\n          punctuation: /\\./\n        }\n      },\n      'type-expression': {\n        // default(Foo), typeof(Foo<Bar>), sizeof(int)\n        pattern: re(/(\\b(?:default|sizeof|typeof)\\s*\\(\\s*(?!\\s))(?:[^()\\s]|\\s(?!\\s)|<<0>>)*(?=\\s*\\))/.source, [nestedRound]),\n        lookbehind: true,\n        alias: 'class-name',\n        inside: typeInside\n      },\n      'return-type': {\n        // Foo<Bar> ForBar(); Foo IFoo.Bar() => 0\n        // int this[int index] => 0; T IReadOnlyList<T>.this[int index] => this[index];\n        // int Foo => 0; int Foo { get; set } = 0;\n        pattern: re(/<<0>>(?=\\s+(?:<<1>>\\s*(?:=>|[({]|\\.\\s*this\\s*\\[)|this\\s*\\[))/.source, [typeExpression, identifier]),\n        inside: typeInside,\n        alias: 'class-name'\n      },\n      'constructor-invocation': {\n        // new List<Foo<Bar[]>> { }\n        pattern: re(/(\\bnew\\s+)<<0>>(?=\\s*[[({])/.source, [typeExpression]),\n        lookbehind: true,\n        inside: typeInside,\n        alias: 'class-name'\n      },\n      /*'explicit-implementation': {\n      // int IFoo<Foo>.Bar => 0; void IFoo<Foo<Foo>>.Foo<T>();\n      pattern: replace(/\\b<<0>>(?=\\.<<1>>)/, className, methodOrPropertyDeclaration),\n      inside: classNameInside,\n      alias: 'class-name'\n      },*/\n      'generic-method': {\n        // foo<Bar>()\n        pattern: re(/<<0>>\\s*<<1>>(?=\\s*\\()/.source, [name, generic]),\n        inside: {\n          function: re(/^<<0>>/.source, [name]),\n          generic: {\n            pattern: RegExp(generic),\n            alias: 'class-name',\n            inside: typeInside\n          }\n        }\n      },\n      'type-list': {\n        // The list of types inherited or of generic constraints\n        // class Foo<F> : Bar, IList<FooBar>\n        // where F : Bar, IList<int>\n        pattern: re(/\\b((?:<<0>>\\s+<<1>>|record\\s+<<1>>\\s*<<5>>|where\\s+<<2>>)\\s*:\\s*)(?:<<3>>|<<4>>|<<1>>\\s*<<5>>|<<6>>)(?:\\s*,\\s*(?:<<3>>|<<4>>|<<6>>))*(?=\\s*(?:where|[{;]|=>|$))/.source, [typeDeclarationKeywords, genericName, name, typeExpression, keywords.source, nestedRound, /\\bnew\\s*\\(\\s*\\)/.source]),\n        lookbehind: true,\n        inside: {\n          'record-arguments': {\n            pattern: re(/(^(?!new\\s*\\()<<0>>\\s*)<<1>>/.source, [genericName, nestedRound]),\n            lookbehind: true,\n            greedy: true,\n            inside: Prism.languages.csharp\n          },\n          keyword: keywords,\n          'class-name': {\n            pattern: RegExp(typeExpression),\n            greedy: true,\n            inside: typeInside\n          },\n          punctuation: /[,()]/\n        }\n      },\n      preprocessor: {\n        pattern: /(^[\\t ]*)#.*/m,\n        lookbehind: true,\n        alias: 'property',\n        inside: {\n          // highlight preprocessor directives as keywords\n          directive: {\n            pattern: /(#)\\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\\b/,\n            lookbehind: true,\n            alias: 'keyword'\n          }\n        }\n      }\n    }); // attributes\n    var regularStringOrCharacter = regularString + '|' + character;\n    var regularStringCharacterOrComment = replace(/\\/(?![*/])|\\/\\/[^\\r\\n]*[\\r\\n]|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/|<<0>>/.source, [regularStringOrCharacter]);\n    var roundExpression = nested(replace(/[^\"'/()]|<<0>>|\\(<<self>>*\\)/.source, [regularStringCharacterOrComment]), 2); // https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/attributes/#attribute-targets\n    var attrTarget = /\\b(?:assembly|event|field|method|module|param|property|return|type)\\b/.source;\n    var attr = replace(/<<0>>(?:\\s*\\(<<1>>*\\))?/.source, [identifier, roundExpression]);\n    Prism.languages.insertBefore('csharp', 'class-name', {\n      attribute: {\n        // Attributes\n        // [Foo], [Foo(1), Bar(2, Prop = \"foo\")], [return: Foo(1), Bar(2)], [assembly: Foo(Bar)]\n        pattern: re(/((?:^|[^\\s\\w>)?])\\s*\\[\\s*)(?:<<0>>\\s*:\\s*)?<<1>>(?:\\s*,\\s*<<1>>)*(?=\\s*\\])/.source, [attrTarget, attr]),\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          target: {\n            pattern: re(/^<<0>>(?=\\s*:)/.source, [attrTarget]),\n            alias: 'keyword'\n          },\n          'attribute-arguments': {\n            pattern: re(/\\(<<0>>*\\)/.source, [roundExpression]),\n            inside: Prism.languages.csharp\n          },\n          'class-name': {\n            pattern: RegExp(identifier),\n            inside: {\n              punctuation: /\\./\n            }\n          },\n          punctuation: /[:,]/\n        }\n      }\n    }); // string interpolation\n    var formatString = /:[^}\\r\\n]+/.source; // multi line\n    var mInterpolationRound = nested(replace(/[^\"'/()]|<<0>>|\\(<<self>>*\\)/.source, [regularStringCharacterOrComment]), 2);\n    var mInterpolation = replace(/\\{(?!\\{)(?:(?![}:])<<0>>)*<<1>>?\\}/.source, [mInterpolationRound, formatString]); // single line\n    var sInterpolationRound = nested(replace(/[^\"'/()]|\\/(?!\\*)|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/|<<0>>|\\(<<self>>*\\)/.source, [regularStringOrCharacter]), 2);\n    var sInterpolation = replace(/\\{(?!\\{)(?:(?![}:])<<0>>)*<<1>>?\\}/.source, [sInterpolationRound, formatString]);\n    function createInterpolationInside(interpolation, interpolationRound) {\n      return {\n        interpolation: {\n          pattern: re(/((?:^|[^{])(?:\\{\\{)*)<<0>>/.source, [interpolation]),\n          lookbehind: true,\n          inside: {\n            'format-string': {\n              pattern: re(/(^\\{(?:(?![}:])<<0>>)*)<<1>>(?=\\}$)/.source, [interpolationRound, formatString]),\n              lookbehind: true,\n              inside: {\n                punctuation: /^:/\n              }\n            },\n            punctuation: /^\\{|\\}$/,\n            expression: {\n              pattern: /[\\s\\S]+/,\n              alias: 'language-csharp',\n              inside: Prism.languages.csharp\n            }\n          }\n        },\n        string: /[\\s\\S]+/\n      };\n    }\n    Prism.languages.insertBefore('csharp', 'string', {\n      'interpolation-string': [{\n        pattern: re(/(^|[^\\\\])(?:\\$@|@\\$)\"(?:\"\"|\\\\[\\s\\S]|\\{\\{|<<0>>|[^\\\\{\"])*\"/.source, [mInterpolation]),\n        lookbehind: true,\n        greedy: true,\n        inside: createInterpolationInside(mInterpolation, mInterpolationRound)\n      }, {\n        pattern: re(/(^|[^@\\\\])\\$\"(?:\\\\.|\\{\\{|<<0>>|[^\\\\\"{])*\"/.source, [sInterpolation]),\n        lookbehind: true,\n        greedy: true,\n        inside: createInterpolationInside(sInterpolation, sInterpolationRound)\n      }],\n      char: {\n        pattern: RegExp(character),\n        greedy: true\n      }\n    });\n    Prism.languages.dotnet = Prism.languages.cs = Prism.languages.csharp;\n  })(Prism);\n}","function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}\nmodule.exports = _iterableToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\nvar throttle = function throttle(fn) {\n  var threshold = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100;\n  var last;\n  var timer;\n  return function () {\n    var now = +new Date();\n    var timePassed = !!last && now < last + threshold;\n    if (timePassed) {\n      clearTimeout(timer);\n      timer = setTimeout(function () {\n        last = now;\n        fn();\n      }, threshold);\n    } else {\n      last = now;\n      fn();\n    }\n  };\n};\nvar _default = throttle;\nexports.default = _default;","var toPositiveInteger = require('../internals/to-positive-integer');\n\nvar $RangeError = RangeError;\n\nmodule.exports = function (it, BYTES) {\n  var offset = toPositiveInteger(it);\n  if (offset % BYTES) throw $RangeError('Wrong offset');\n  return offset;\n};\n","//\n\nmodule.exports = function shallowEqual(objA, objB, compare, compareContext) {\n  var ret = compare ? compare.call(compareContext, objA, objB) : void 0;\n  if (ret !== void 0) {\n    return !!ret;\n  }\n  if (objA === objB) {\n    return true;\n  }\n  if (typeof objA !== \"object\" || !objA || typeof objB !== \"object\" || !objB) {\n    return false;\n  }\n  var keysA = Object.keys(objA);\n  var keysB = Object.keys(objB);\n  if (keysA.length !== keysB.length) {\n    return false;\n  }\n  var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);\n\n  // Test for A's keys different from B.\n  for (var idx = 0; idx < keysA.length; idx++) {\n    var key = keysA[idx];\n    if (!bHasOwnProperty(key)) {\n      return false;\n    }\n    var valueA = objA[key];\n    var valueB = objB[key];\n    ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;\n    if (ret === false || ret === void 0 && valueA !== valueB) {\n      return false;\n    }\n  }\n  return true;\n};","module.exports = \"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyMiAyMiIgZmlsbD0iI0NCRDVFMCI+PHBhdGggZD0iTTExLDIyQTExLDExLDAsMSwxLDIyLDExLDExLDExLDAsMCwxLDExLDIyWk0xMSwyYTksOSwwLDEsMCw5LDlBOSw5LDAsMCwwLDExLDJaIj48L3BhdGg+PHBhdGggZD0iTTE1LDE0YS45My45MywwLDAsMS0uNDUtLjExbC00LTJBMSwxLDAsMCwxLDEwLDExVjVhMSwxLDAsMCwxLDIsMHY1LjM4bDMuNDUsMS43M2ExLDEsMCwwLDEsLjQ0LDEuMzRBMSwxLDAsMCwxLDE1LDE0WiI+PC9wYXRoPjwvc3ZnPgo=\"","'use strict';\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar aCallable = require('../internals/a-callable');\nvar internalSort = require('../internals/array-sort');\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar FF = require('../internals/engine-ff-version');\nvar IE_OR_EDGE = require('../internals/engine-is-ie-or-edge');\nvar V8 = require('../internals/engine-v8-version');\nvar WEBKIT = require('../internals/engine-webkit-version');\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\nvar Uint16Array = global.Uint16Array;\nvar nativeSort = Uint16Array && uncurryThis(Uint16Array.prototype.sort);\n\n// WebKit\nvar ACCEPT_INCORRECT_ARGUMENTS = !!nativeSort && !(fails(function () {\n  nativeSort(new Uint16Array(2), null);\n}) && fails(function () {\n  nativeSort(new Uint16Array(2), {});\n}));\n\nvar STABLE_SORT = !!nativeSort && !fails(function () {\n  // feature detection can be too slow, so check engines versions\n  if (V8) return V8 < 74;\n  if (FF) return FF < 67;\n  if (IE_OR_EDGE) return true;\n  if (WEBKIT) return WEBKIT < 602;\n\n  var array = new Uint16Array(516);\n  var expected = Array(516);\n  var index, mod;\n\n  for (index = 0; index < 516; index++) {\n    mod = index % 4;\n    array[index] = 515 - index;\n    expected[index] = index - 2 * mod + 3;\n  }\n\n  nativeSort(array, function (a, b) {\n    return (a / 4 | 0) - (b / 4 | 0);\n  });\n\n  for (index = 0; index < 516; index++) {\n    if (array[index] !== expected[index]) return true;\n  }\n});\n\nvar getSortCompare = function (comparefn) {\n  return function (x, y) {\n    if (comparefn !== undefined) return +comparefn(x, y) || 0;\n    // eslint-disable-next-line no-self-compare -- NaN check\n    if (y !== y) return -1;\n    // eslint-disable-next-line no-self-compare -- NaN check\n    if (x !== x) return 1;\n    if (x === 0 && y === 0) return 1 / x > 0 && 1 / y < 0 ? 1 : -1;\n    return x > y;\n  };\n};\n\n// `%TypedArray%.prototype.sort` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.sort\nexportTypedArrayMethod('sort', function sort(comparefn) {\n  if (comparefn !== undefined) aCallable(comparefn);\n  if (STABLE_SORT) return nativeSort(this, comparefn);\n\n  return internalSort(aTypedArray(this), getSortCompare(comparefn));\n}, !STABLE_SORT || ACCEPT_INCORRECT_ARGUMENTS);\n","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\nmodule.exports = _arrayWithoutHoles, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayWithHoles = require(\"./arrayWithHoles.js\");\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit.js\");\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\nvar nonIterableRest = require(\"./nonIterableRest.js\");\nfunction _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\nmodule.exports = _slicedToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var unitlessKeys = {\n  animationIterationCount: 1,\n  borderImageOutset: 1,\n  borderImageSlice: 1,\n  borderImageWidth: 1,\n  boxFlex: 1,\n  boxFlexGroup: 1,\n  boxOrdinalGroup: 1,\n  columnCount: 1,\n  columns: 1,\n  flex: 1,\n  flexGrow: 1,\n  flexPositive: 1,\n  flexShrink: 1,\n  flexNegative: 1,\n  flexOrder: 1,\n  gridRow: 1,\n  gridRowEnd: 1,\n  gridRowSpan: 1,\n  gridRowStart: 1,\n  gridColumn: 1,\n  gridColumnEnd: 1,\n  gridColumnSpan: 1,\n  gridColumnStart: 1,\n  msGridRow: 1,\n  msGridRowSpan: 1,\n  msGridColumn: 1,\n  msGridColumnSpan: 1,\n  fontWeight: 1,\n  lineHeight: 1,\n  opacity: 1,\n  order: 1,\n  orphans: 1,\n  tabSize: 1,\n  widows: 1,\n  zIndex: 1,\n  zoom: 1,\n  WebkitLineClamp: 1,\n  // SVG-related properties\n  fillOpacity: 1,\n  floodOpacity: 1,\n  stopOpacity: 1,\n  strokeDasharray: 1,\n  strokeDashoffset: 1,\n  strokeMiterlimit: 1,\n  strokeOpacity: 1,\n  strokeWidth: 1\n};\nexport default unitlessKeys;","module.exports = \"data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTYgMTJMMjEgMTIiIHN0cm9rZT0iIzY3Nzc4NCIgc3Ryb2tlLXdpZHRoPSIyIiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiLz4KPHBhdGggZD0iTTMgNkgxOCIgc3Ryb2tlPSIjNjc3Nzg0IiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIvPgo8cGF0aCBkPSJNMyAxOEgxOCIgc3Ryb2tlPSIjNjc3Nzg0IiBzdHJva2Utd2lkdGg9IjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIvPgo8L3N2Zz4K\"","function _getPrototypeOf(o) {\n  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  return _getPrototypeOf(o);\n}\nmodule.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var isCallable = require('../internals/is-callable');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument) {\n  if (typeof argument == 'object' || isCallable(argument)) return argument;\n  throw $TypeError(\"Can't set \" + $String(argument) + ' as a prototype');\n};\n","\"use strict\";\n\nvar _require = require('./Component'),\n  CopyToClipboard = _require.CopyToClipboard;\nCopyToClipboard.CopyToClipboard = CopyToClipboard;\nmodule.exports = CopyToClipboard;","'use strict';\nvar global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar toOffset = require('../internals/to-offset');\nvar toIndexedObject = require('../internals/to-object');\nvar fails = require('../internals/fails');\n\nvar RangeError = global.RangeError;\nvar Int8Array = global.Int8Array;\nvar Int8ArrayPrototype = Int8Array && Int8Array.prototype;\nvar $set = Int8ArrayPrototype && Int8ArrayPrototype.set;\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\n\nvar WORKS_WITH_OBJECTS_AND_GEERIC_ON_TYPED_ARRAYS = !fails(function () {\n  // eslint-disable-next-line es/no-typed-arrays -- required for testing\n  var array = new Uint8ClampedArray(2);\n  call($set, array, { length: 1, 0: 3 }, 1);\n  return array[1] !== 3;\n});\n\n// https://bugs.chromium.org/p/v8/issues/detail?id=11294 and other\nvar TO_OBJECT_BUG = WORKS_WITH_OBJECTS_AND_GEERIC_ON_TYPED_ARRAYS && ArrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS && fails(function () {\n  var array = new Int8Array(2);\n  array.set(1);\n  array.set('2', 1);\n  return array[0] !== 0 || array[1] !== 2;\n});\n\n// `%TypedArray%.prototype.set` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.set\nexportTypedArrayMethod('set', function set(arrayLike /* , offset */) {\n  aTypedArray(this);\n  var offset = toOffset(arguments.length > 1 ? arguments[1] : undefined, 1);\n  var src = toIndexedObject(arrayLike);\n  if (WORKS_WITH_OBJECTS_AND_GEERIC_ON_TYPED_ARRAYS) return call($set, this, src, offset);\n  var length = this.length;\n  var len = lengthOfArrayLike(src);\n  var index = 0;\n  if (len + offset > length) throw RangeError('Wrong length');\n  while (index < len) this[offset + index] = src[index++];\n}, !WORKS_WITH_OBJECTS_AND_GEERIC_ON_TYPED_ARRAYS || TO_OBJECT_BUG);\n","var arrayWithoutHoles = require(\"./arrayWithoutHoles.js\");\nvar iterableToArray = require(\"./iterableToArray.js\");\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\nvar nonIterableSpread = require(\"./nonIterableSpread.js\");\nfunction _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\nmodule.exports = _toConsumableArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","'use strict';\n\nmodule.exports = ruby;\nruby.displayName = 'ruby';\nruby.aliases = ['rb'];\nfunction ruby(Prism) {\n  /**\n   * Original by Samuel Flores\n   *\n   * Adds the following new token classes:\n   *     constant, builtin, variable, symbol, regex\n   */\n  ;\n  (function (Prism) {\n    Prism.languages.ruby = Prism.languages.extend('clike', {\n      comment: {\n        pattern: /#.*|^=begin\\s[\\s\\S]*?^=end/m,\n        greedy: true\n      },\n      'class-name': {\n        pattern: /(\\b(?:class|module)\\s+|\\bcatch\\s+\\()[\\w.\\\\]+|\\b[A-Z_]\\w*(?=\\s*\\.\\s*new\\b)/,\n        lookbehind: true,\n        inside: {\n          punctuation: /[.\\\\]/\n        }\n      },\n      keyword: /\\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\\b/,\n      operator: /\\.{2,3}|&\\.|===|<?=>|[!=]?~|(?:&&|\\|\\||<<|>>|\\*\\*|[+\\-*/%<>!^&|=])=?|[?:]/,\n      punctuation: /[(){}[\\].,;]/\n    });\n    Prism.languages.insertBefore('ruby', 'operator', {\n      'double-colon': {\n        pattern: /::/,\n        alias: 'punctuation'\n      }\n    });\n    var interpolation = {\n      pattern: /((?:^|[^\\\\])(?:\\\\{2})*)#\\{(?:[^{}]|\\{[^{}]*\\})*\\}/,\n      lookbehind: true,\n      inside: {\n        content: {\n          pattern: /^(#\\{)[\\s\\S]+(?=\\}$)/,\n          lookbehind: true,\n          inside: Prism.languages.ruby\n        },\n        delimiter: {\n          pattern: /^#\\{|\\}$/,\n          alias: 'punctuation'\n        }\n      }\n    };\n    delete Prism.languages.ruby.function;\n    var percentExpression = '(?:' + [/([^a-zA-Z0-9\\s{(\\[<=])(?:(?!\\1)[^\\\\]|\\\\[\\s\\S])*\\1/.source, /\\((?:[^()\\\\]|\\\\[\\s\\S]|\\((?:[^()\\\\]|\\\\[\\s\\S])*\\))*\\)/.source, /\\{(?:[^{}\\\\]|\\\\[\\s\\S]|\\{(?:[^{}\\\\]|\\\\[\\s\\S])*\\})*\\}/.source, /\\[(?:[^\\[\\]\\\\]|\\\\[\\s\\S]|\\[(?:[^\\[\\]\\\\]|\\\\[\\s\\S])*\\])*\\]/.source, /<(?:[^<>\\\\]|\\\\[\\s\\S]|<(?:[^<>\\\\]|\\\\[\\s\\S])*>)*>/.source].join('|') + ')';\n    var symbolName = /(?:\"(?:\\\\.|[^\"\\\\\\r\\n])*\"|(?:\\b[a-zA-Z_]\\w*|[^\\s\\0-\\x7F]+)[?!]?|\\$.)/.source;\n    Prism.languages.insertBefore('ruby', 'keyword', {\n      'regex-literal': [{\n        pattern: RegExp(/%r/.source + percentExpression + /[egimnosux]{0,6}/.source),\n        greedy: true,\n        inside: {\n          interpolation: interpolation,\n          regex: /[\\s\\S]+/\n        }\n      }, {\n        pattern: /(^|[^/])\\/(?!\\/)(?:\\[[^\\r\\n\\]]+\\]|\\\\.|[^[/\\\\\\r\\n])+\\/[egimnosux]{0,6}(?=\\s*(?:$|[\\r\\n,.;})#]))/,\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          interpolation: interpolation,\n          regex: /[\\s\\S]+/\n        }\n      }],\n      variable: /[@$]+[a-zA-Z_]\\w*(?:[?!]|\\b)/,\n      symbol: [{\n        pattern: RegExp(/(^|[^:]):/.source + symbolName),\n        lookbehind: true,\n        greedy: true\n      }, {\n        pattern: RegExp(/([\\r\\n{(,][ \\t]*)/.source + symbolName + /(?=:(?!:))/.source),\n        lookbehind: true,\n        greedy: true\n      }],\n      'method-definition': {\n        pattern: /(\\bdef\\s+)\\w+(?:\\s*\\.\\s*\\w+)?/,\n        lookbehind: true,\n        inside: {\n          function: /\\b\\w+$/,\n          keyword: /^self\\b/,\n          'class-name': /^\\w+/,\n          punctuation: /\\./\n        }\n      }\n    });\n    Prism.languages.insertBefore('ruby', 'string', {\n      'string-literal': [{\n        pattern: RegExp(/%[qQiIwWs]?/.source + percentExpression),\n        greedy: true,\n        inside: {\n          interpolation: interpolation,\n          string: /[\\s\\S]+/\n        }\n      }, {\n        pattern: /(\"|')(?:#\\{[^}]+\\}|#(?!\\{)|\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\#\\r\\n])*\\1/,\n        greedy: true,\n        inside: {\n          interpolation: interpolation,\n          string: /[\\s\\S]+/\n        }\n      }, {\n        pattern: /<<[-~]?([a-z_]\\w*)[\\r\\n](?:.*[\\r\\n])*?[\\t ]*\\1/i,\n        alias: 'heredoc-string',\n        greedy: true,\n        inside: {\n          delimiter: {\n            pattern: /^<<[-~]?[a-z_]\\w*|\\b[a-z_]\\w*$/i,\n            inside: {\n              symbol: /\\b\\w+/,\n              punctuation: /^<<[-~]?/\n            }\n          },\n          interpolation: interpolation,\n          string: /[\\s\\S]+/\n        }\n      }, {\n        pattern: /<<[-~]?'([a-z_]\\w*)'[\\r\\n](?:.*[\\r\\n])*?[\\t ]*\\1/i,\n        alias: 'heredoc-string',\n        greedy: true,\n        inside: {\n          delimiter: {\n            pattern: /^<<[-~]?'[a-z_]\\w*'|\\b[a-z_]\\w*$/i,\n            inside: {\n              symbol: /\\b\\w+/,\n              punctuation: /^<<[-~]?'|'$/\n            }\n          },\n          string: /[\\s\\S]+/\n        }\n      }],\n      'command-literal': [{\n        pattern: RegExp(/%x/.source + percentExpression),\n        greedy: true,\n        inside: {\n          interpolation: interpolation,\n          command: {\n            pattern: /[\\s\\S]+/,\n            alias: 'string'\n          }\n        }\n      }, {\n        pattern: /`(?:#\\{[^}]+\\}|#(?!\\{)|\\\\(?:\\r\\n|[\\s\\S])|[^\\\\`#\\r\\n])*`/,\n        greedy: true,\n        inside: {\n          interpolation: interpolation,\n          command: {\n            pattern: /[\\s\\S]+/,\n            alias: 'string'\n          }\n        }\n      }]\n    });\n    delete Prism.languages.ruby.string;\n    Prism.languages.insertBefore('ruby', 'number', {\n      builtin: /\\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\\b/,\n      constant: /\\b[A-Z][A-Z0-9_]*(?:[?!]|\\b)/\n    });\n    Prism.languages.rb = Prism.languages.ruby;\n  })(Prism);\n}","// eslint-disable-next-line es/no-typed-arrays -- safe\nmodule.exports = typeof ArrayBuffer != 'undefined' && typeof DataView != 'undefined';\n","'use strict';\n\nmodule.exports = swift;\nswift.displayName = 'swift';\nswift.aliases = [];\nfunction swift(Prism) {\n  Prism.languages.swift = {\n    comment: {\n      // Nested comments are supported up to 2 levels\n      pattern: /(^|[^\\\\:])(?:\\/\\/.*|\\/\\*(?:[^/*]|\\/(?!\\*)|\\*(?!\\/)|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/)*\\*\\/)/,\n      lookbehind: true,\n      greedy: true\n    },\n    'string-literal': [\n    // https://docs.swift.org/swift-book/LanguageGuide/StringsAndCharacters.html\n    {\n      pattern: RegExp(/(^|[^\"#])/.source + '(?:' +\n      // single-line string\n      /\"(?:\\\\(?:\\((?:[^()]|\\([^()]*\\))*\\)|\\r\\n|[^(])|[^\\\\\\r\\n\"])*\"/.source + '|' +\n      // multi-line string\n      /\"\"\"(?:\\\\(?:\\((?:[^()]|\\([^()]*\\))*\\)|[^(])|[^\\\\\"]|\"(?!\"\"))*\"\"\"/.source + ')' + /(?![\"#])/.source),\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        interpolation: {\n          pattern: /(\\\\\\()(?:[^()]|\\([^()]*\\))*(?=\\))/,\n          lookbehind: true,\n          inside: null // see below\n        },\n\n        'interpolation-punctuation': {\n          pattern: /^\\)|\\\\\\($/,\n          alias: 'punctuation'\n        },\n        punctuation: /\\\\(?=[\\r\\n])/,\n        string: /[\\s\\S]+/\n      }\n    }, {\n      pattern: RegExp(/(^|[^\"#])(#+)/.source + '(?:' +\n      // single-line string\n      /\"(?:\\\\(?:#+\\((?:[^()]|\\([^()]*\\))*\\)|\\r\\n|[^#])|[^\\\\\\r\\n])*?\"/.source + '|' +\n      // multi-line string\n      /\"\"\"(?:\\\\(?:#+\\((?:[^()]|\\([^()]*\\))*\\)|[^#])|[^\\\\])*?\"\"\"/.source + ')' + '\\\\2'),\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        interpolation: {\n          pattern: /(\\\\#+\\()(?:[^()]|\\([^()]*\\))*(?=\\))/,\n          lookbehind: true,\n          inside: null // see below\n        },\n\n        'interpolation-punctuation': {\n          pattern: /^\\)|\\\\#+\\($/,\n          alias: 'punctuation'\n        },\n        string: /[\\s\\S]+/\n      }\n    }],\n    directive: {\n      // directives with conditions\n      pattern: RegExp(/#/.source + '(?:' + (/(?:elseif|if)\\b/.source + '(?:[ \\t]*' +\n      // This regex is a little complex. It's equivalent to this:\n      //   (?:![ \\t]*)?(?:\\b\\w+\\b(?:[ \\t]*<round>)?|<round>)(?:[ \\t]*(?:&&|\\|\\|))?\n      // where <round> is a general parentheses expression.\n      /(?:![ \\t]*)?(?:\\b\\w+\\b(?:[ \\t]*\\((?:[^()]|\\([^()]*\\))*\\))?|\\((?:[^()]|\\([^()]*\\))*\\))(?:[ \\t]*(?:&&|\\|\\|))?/.source + ')+') + '|' + /(?:else|endif)\\b/.source + ')'),\n      alias: 'property',\n      inside: {\n        'directive-name': /^#\\w+/,\n        boolean: /\\b(?:false|true)\\b/,\n        number: /\\b\\d+(?:\\.\\d+)*\\b/,\n        operator: /!|&&|\\|\\||[<>]=?/,\n        punctuation: /[(),]/\n      }\n    },\n    literal: {\n      pattern: /#(?:colorLiteral|column|dsohandle|file(?:ID|Literal|Path)?|function|imageLiteral|line)\\b/,\n      alias: 'constant'\n    },\n    'other-directive': {\n      pattern: /#\\w+\\b/,\n      alias: 'property'\n    },\n    attribute: {\n      pattern: /@\\w+/,\n      alias: 'atrule'\n    },\n    'function-definition': {\n      pattern: /(\\bfunc\\s+)\\w+/,\n      lookbehind: true,\n      alias: 'function'\n    },\n    label: {\n      // https://docs.swift.org/swift-book/LanguageGuide/ControlFlow.html#ID141\n      pattern: /\\b(break|continue)\\s+\\w+|\\b[a-zA-Z_]\\w*(?=\\s*:\\s*(?:for|repeat|while)\\b)/,\n      lookbehind: true,\n      alias: 'important'\n    },\n    keyword: /\\b(?:Any|Protocol|Self|Type|actor|as|assignment|associatedtype|associativity|async|await|break|case|catch|class|continue|convenience|default|defer|deinit|didSet|do|dynamic|else|enum|extension|fallthrough|fileprivate|final|for|func|get|guard|higherThan|if|import|in|indirect|infix|init|inout|internal|is|isolated|lazy|left|let|lowerThan|mutating|none|nonisolated|nonmutating|open|operator|optional|override|postfix|precedencegroup|prefix|private|protocol|public|repeat|required|rethrows|return|right|safe|self|set|some|static|struct|subscript|super|switch|throw|throws|try|typealias|unowned|unsafe|var|weak|where|while|willSet)\\b/,\n    boolean: /\\b(?:false|true)\\b/,\n    nil: {\n      pattern: /\\bnil\\b/,\n      alias: 'constant'\n    },\n    'short-argument': /\\$\\d+\\b/,\n    omit: {\n      pattern: /\\b_\\b/,\n      alias: 'keyword'\n    },\n    number: /\\b(?:[\\d_]+(?:\\.[\\de_]+)?|0x[a-f0-9_]+(?:\\.[a-f0-9p_]+)?|0b[01_]+|0o[0-7_]+)\\b/i,\n    // A class name must start with an upper-case letter and be either 1 letter long or contain a lower-case letter.\n    'class-name': /\\b[A-Z](?:[A-Z_\\d]*[a-z]\\w*)?\\b/,\n    function: /\\b[a-z_]\\w*(?=\\s*\\()/i,\n    constant: /\\b(?:[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\\b/,\n    // Operators are generic in Swift. Developers can even create new operators (e.g. +++).\n    // https://docs.swift.org/swift-book/ReferenceManual/zzSummaryOfTheGrammar.html#ID481\n    // This regex only supports ASCII operators.\n    operator: /[-+*/%=!<>&|^~?]+|\\.[.\\-+*/%=!<>&|^~?]+/,\n    punctuation: /[{}[\\]();,.:\\\\]/\n  };\n  Prism.languages.swift['string-literal'].forEach(function (rule) {\n    rule.inside['interpolation'].inside = Prism.languages.swift;\n  });\n}","function _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}\nmodule.exports = _createClass, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n  return arr2;\n}\nmodule.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","const React = require(`react`)\nconst { mdx } = require(`@mdx-js/react`)\nconst { useMDXScope } = require(`./context`)\n\nmodule.exports = function MDXRenderer({\n  scope,\n  children,\n  ...props\n}) {\n  const mdxScope = useMDXScope(scope)\n\n  // Memoize the compiled component\n  const End = React.useMemo(() => {\n    if (!children) {\n      return null\n    }\n\n    const fullScope = {\n      // React is here just in case the user doesn't pass them in\n      // in a manual usage of the renderer\n      React,\n      mdx,\n      ...mdxScope,\n    }\n\n    const keys = Object.keys(fullScope)\n    const values = keys.map(key => fullScope[key])\n    const fn = new Function(`_fn`, ...keys, `${children}`)\n\n    return fn({}, ...values)\n  }, [children, scope])\n\n  return React.createElement(End, {...props })\n}\n","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\nvar _extends2 = _interopRequireDefault(require(\"@babel/runtime/helpers/extends\"));\nvar _defineProperty2 = _interopRequireDefault(require(\"@babel/runtime/helpers/defineProperty\"));\nvar _toConsumableArray2 = _interopRequireDefault(require(\"@babel/runtime/helpers/toConsumableArray\"));\nvar _classCallCheck2 = _interopRequireDefault(require(\"@babel/runtime/helpers/classCallCheck\"));\nvar _possibleConstructorReturn2 = _interopRequireDefault(require(\"@babel/runtime/helpers/possibleConstructorReturn\"));\nvar _getPrototypeOf2 = _interopRequireDefault(require(\"@babel/runtime/helpers/getPrototypeOf\"));\nvar _assertThisInitialized2 = _interopRequireDefault(require(\"@babel/runtime/helpers/assertThisInitialized\"));\nvar _createClass2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createClass\"));\nvar _inherits2 = _interopRequireDefault(require(\"@babel/runtime/helpers/inherits\"));\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\nvar _react = _interopRequireDefault(require(\"react\"));\nvar _classnames = _interopRequireDefault(require(\"classnames\"));\nvar _throttle = _interopRequireDefault(require(\"./throttle\"));\nfunction isEqualArray(a, b) {\n  return a.length === b.length && a.every(function (item, index) {\n    return item === b[index];\n  });\n}\nvar Scrollspy = /*#__PURE__*/\nfunction (_React$Component) {\n  (0, _inherits2.default)(Scrollspy, _React$Component);\n  (0, _createClass2.default)(Scrollspy, null, [{\n    key: \"propTypes\",\n    get: function get() {\n      return {\n        items: _propTypes.default.arrayOf(_propTypes.default.string).isRequired,\n        currentClassName: _propTypes.default.string.isRequired,\n        scrolledPastClassName: _propTypes.default.string,\n        style: _propTypes.default.object,\n        componentTag: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.elementType]),\n        offset: _propTypes.default.number,\n        rootEl: _propTypes.default.string,\n        onUpdate: _propTypes.default.func\n      };\n    }\n  }, {\n    key: \"defaultProps\",\n    get: function get() {\n      return {\n        items: [],\n        currentClassName: '',\n        style: {},\n        componentTag: 'ul',\n        offset: 0,\n        onUpdate: function onUpdate() {}\n      };\n    }\n  }]);\n  function Scrollspy(props) {\n    var _this;\n    (0, _classCallCheck2.default)(this, Scrollspy);\n    _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(Scrollspy).call(this, props));\n    _this.state = {\n      targetItems: [],\n      inViewState: [],\n      isScrolledPast: [] // manually bind as ES6 does not apply this\n      // auto binding as React.createClass does\n    };\n\n    _this._handleSpy = _this._handleSpy.bind((0, _assertThisInitialized2.default)(_this));\n    return _this;\n  }\n  (0, _createClass2.default)(Scrollspy, [{\n    key: \"_initSpyTarget\",\n    value: function _initSpyTarget(items) {\n      var targetItems = items.map(function (item) {\n        return document.getElementById(item);\n      });\n      return targetItems;\n    } // https://github.com/makotot/react-scrollspy/pull/45\n  }, {\n    key: \"_fillArray\",\n    value: function _fillArray(array, val) {\n      var newArray = [];\n      for (var i = 0, max = array.length; i < max; i++) {\n        newArray[i] = val;\n      }\n      return newArray;\n    }\n  }, {\n    key: \"_isScrolled\",\n    value: function _isScrolled() {\n      return this._getScrollDimension().scrollTop > 0;\n    }\n  }, {\n    key: \"_getScrollDimension\",\n    value: function _getScrollDimension() {\n      var doc = document;\n      var rootEl = this.props.rootEl;\n      var scrollTop = rootEl ? doc.querySelector(rootEl).scrollTop : doc.documentElement.scrollTop || doc.body.parentNode.scrollTop || doc.body.scrollTop;\n      var scrollHeight = rootEl ? doc.querySelector(rootEl).scrollHeight : doc.documentElement.scrollHeight || doc.body.parentNode.scrollHeight || doc.body.scrollHeight;\n      return {\n        scrollTop: scrollTop,\n        scrollHeight: scrollHeight\n      };\n    }\n  }, {\n    key: \"_getElemsViewState\",\n    value: function _getElemsViewState(targets) {\n      var elemsInView = [];\n      var elemsOutView = [];\n      var viewStatusList = [];\n      var targetItems = targets ? targets : this.state.targetItems;\n      var hasInViewAlready = false;\n      for (var i = 0, max = targetItems.length; i < max; i++) {\n        var currentContent = targetItems[i];\n        var isInView = hasInViewAlready ? false : this._isInView(currentContent);\n        if (isInView) {\n          hasInViewAlready = true;\n          elemsInView.push(currentContent);\n        } else {\n          elemsOutView.push(currentContent);\n        }\n        var isLastItem = i === max - 1;\n        var isScrolled = this._isScrolled(); // https://github.com/makotot/react-scrollspy/pull/26#issue-167413769\n\n        var isLastShortItemAtBottom = this._isAtBottom() && this._isInView(currentContent) && !isInView && isLastItem && isScrolled;\n        if (isLastShortItemAtBottom) {\n          elemsOutView.pop();\n          elemsOutView.push.apply(elemsOutView, (0, _toConsumableArray2.default)(elemsInView));\n          elemsInView = [currentContent];\n          viewStatusList = this._fillArray(viewStatusList, false);\n          isInView = true;\n        }\n        viewStatusList.push(isInView);\n      }\n      return {\n        inView: elemsInView,\n        outView: elemsOutView,\n        viewStatusList: viewStatusList,\n        scrolledPast: this.props.scrolledPastClassName && this._getScrolledPast(viewStatusList)\n      };\n    }\n  }, {\n    key: \"_isInView\",\n    value: function _isInView(el) {\n      if (!el) {\n        return false;\n      }\n      var _this$props = this.props,\n        rootEl = _this$props.rootEl,\n        offset = _this$props.offset;\n      var rootRect;\n      if (rootEl) {\n        rootRect = document.querySelector(rootEl).getBoundingClientRect();\n      }\n      var rect = el.getBoundingClientRect();\n      var winH = rootEl ? rootRect.height : window.innerHeight;\n      var _this$_getScrollDimen = this._getScrollDimension(),\n        scrollTop = _this$_getScrollDimen.scrollTop;\n      var scrollBottom = scrollTop + winH;\n      var elTop = rootEl ? rect.top + scrollTop - rootRect.top + offset : rect.top + scrollTop + offset;\n      var elBottom = elTop + el.offsetHeight;\n      return elTop < scrollBottom && elBottom > scrollTop;\n    }\n  }, {\n    key: \"_isAtBottom\",\n    value: function _isAtBottom() {\n      var rootEl = this.props.rootEl;\n      var _this$_getScrollDimen2 = this._getScrollDimension(),\n        scrollTop = _this$_getScrollDimen2.scrollTop,\n        scrollHeight = _this$_getScrollDimen2.scrollHeight;\n      var winH = rootEl ? document.querySelector(rootEl).getBoundingClientRect().height : window.innerHeight;\n      var scrolledToBottom = scrollTop + winH >= scrollHeight;\n      return scrolledToBottom;\n    }\n  }, {\n    key: \"_getScrolledPast\",\n    value: function _getScrolledPast(viewStatusList) {\n      if (!viewStatusList.some(function (item) {\n        return item;\n      })) {\n        return viewStatusList;\n      }\n      var hasFoundInView = false;\n      var scrolledPastItems = viewStatusList.map(function (item) {\n        if (item && !hasFoundInView) {\n          hasFoundInView = true;\n          return false;\n        }\n        return !hasFoundInView;\n      });\n      return scrolledPastItems;\n    }\n  }, {\n    key: \"_spy\",\n    value: function _spy(targets) {\n      var _this2 = this;\n      var elemensViewState = this._getElemsViewState(targets);\n      var currentStatuses = this.state.inViewState;\n      this.setState({\n        inViewState: elemensViewState.viewStatusList,\n        isScrolledPast: elemensViewState.scrolledPast\n      }, function () {\n        _this2._update(currentStatuses);\n      });\n    }\n  }, {\n    key: \"_update\",\n    value: function _update(prevStatuses) {\n      if (isEqualArray(this.state.inViewState, prevStatuses)) {\n        return;\n      }\n      this.props.onUpdate(this.state.targetItems[this.state.inViewState.indexOf(true)]);\n    }\n  }, {\n    key: \"_handleSpy\",\n    value: function _handleSpy() {\n      (0, _throttle.default)(this._spy(), 100);\n    }\n  }, {\n    key: \"_initFromProps\",\n    value: function _initFromProps() {\n      var targetItems = this._initSpyTarget(this.props.items);\n      this.setState({\n        targetItems: targetItems\n      });\n      this._spy(targetItems);\n    }\n  }, {\n    key: \"offEvent\",\n    value: function offEvent() {\n      var el = this.props.rootEl ? document.querySelector(this.props.rootEl) : window;\n      el.removeEventListener('scroll', this._handleSpy);\n    }\n  }, {\n    key: \"onEvent\",\n    value: function onEvent() {\n      var el = this.props.rootEl ? document.querySelector(this.props.rootEl) : window;\n      el.addEventListener('scroll', this._handleSpy);\n    }\n  }, {\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      this._initFromProps();\n      this.onEvent();\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      this.offEvent();\n    }\n  }, {\n    key: \"UNSAFE_componentWillReceiveProps\",\n    value: function UNSAFE_componentWillReceiveProps() {\n      this._initFromProps();\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this3 = this;\n      var Tag = this.props.componentTag;\n      var _this$props2 = this.props,\n        children = _this$props2.children,\n        className = _this$props2.className,\n        scrolledPastClassName = _this$props2.scrolledPastClassName,\n        style = _this$props2.style;\n      var counter = 0;\n      var items = _react.default.Children.map(children, function (child, idx) {\n        var _classNames;\n        if (!child) {\n          return null;\n        }\n        var ChildTag = child.type;\n        var isScrolledPast = scrolledPastClassName && _this3.state.isScrolledPast[idx];\n        var childClass = (0, _classnames.default)((_classNames = {}, (0, _defineProperty2.default)(_classNames, \"\".concat(child.props.className), child.props.className), (0, _defineProperty2.default)(_classNames, \"\".concat(_this3.props.currentClassName), _this3.state.inViewState[idx]), (0, _defineProperty2.default)(_classNames, \"\".concat(_this3.props.scrolledPastClassName), isScrolledPast), _classNames));\n        return _react.default.createElement(ChildTag, (0, _extends2.default)({}, child.props, {\n          className: childClass,\n          key: counter++\n        }), child.props.children);\n      });\n      var itemClass = (0, _classnames.default)((0, _defineProperty2.default)({}, \"\".concat(className), className));\n      return _react.default.createElement(Tag, {\n        className: itemClass,\n        style: style\n      }, items);\n    }\n  }]);\n  return Scrollspy;\n}(_react.default.Component);\nexports.default = Scrollspy;","'use strict';\n\nmodule.exports = function (str) {\n  return encodeURIComponent(str).replace(/[!'()*]/g, function (x) {\n    return \"%\".concat(x.charCodeAt(0).toString(16).toUpperCase());\n  });\n};","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}\nmodule.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var _typeof = require(\"./typeof.js\")[\"default\"];\nvar assertThisInitialized = require(\"./assertThisInitialized.js\");\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  } else if (call !== void 0) {\n    throw new TypeError(\"Derived constructors may only return object or undefined\");\n  }\n  return assertThisInitialized(self);\n}\nmodule.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _isNativeReflectConstruct() {\n  if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n  if (Reflect.construct.sham) return false;\n  if (typeof Proxy === \"function\") return true;\n  try {\n    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\nmodule.exports = _isNativeReflectConstruct, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","'use strict';\n\nmodule.exports = function (obj, predicate) {\n  var ret = {};\n  var keys = Object.keys(obj);\n  var isArr = Array.isArray(predicate);\n  for (var i = 0; i < keys.length; i++) {\n    var key = keys[i];\n    var val = obj[key];\n    if (isArr ? predicate.indexOf(key) !== -1 : predicate(key, val, obj)) {\n      ret[key] = val;\n    }\n  }\n  return ret;\n};","'use strict';\n\nvar _slicedToArray = require(\"/codebuild/output/src3819837428/src/kushki-docs/node_modules/@babel/runtime/helpers/slicedToArray.js\");\nvar _toConsumableArray = require(\"/codebuild/output/src3819837428/src/kushki-docs/node_modules/@babel/runtime/helpers/toConsumableArray.js\");\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\nrequire(\"core-js/modules/es.array.sort.js\");\nrequire(\"core-js/modules/es.array.reduce.js\");\nvar strictUriEncode = require('strict-uri-encode');\nvar decodeComponent = require('decode-uri-component');\nvar splitOnFirst = require('split-on-first');\nvar filterObject = require('filter-obj');\nvar isNullOrUndefined = function isNullOrUndefined(value) {\n  return value === null || value === undefined;\n};\nfunction encoderForArrayFormat(options) {\n  switch (options.arrayFormat) {\n    case 'index':\n      return function (key) {\n        return function (result, value) {\n          var index = result.length;\n          if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === '') {\n            return result;\n          }\n          if (value === null) {\n            return [].concat(_toConsumableArray(result), [[encode(key, options), '[', index, ']'].join('')]);\n          }\n          return [].concat(_toConsumableArray(result), [[encode(key, options), '[', encode(index, options), ']=', encode(value, options)].join('')]);\n        };\n      };\n    case 'bracket':\n      return function (key) {\n        return function (result, value) {\n          if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === '') {\n            return result;\n          }\n          if (value === null) {\n            return [].concat(_toConsumableArray(result), [[encode(key, options), '[]'].join('')]);\n          }\n          return [].concat(_toConsumableArray(result), [[encode(key, options), '[]=', encode(value, options)].join('')]);\n        };\n      };\n    case 'comma':\n    case 'separator':\n      return function (key) {\n        return function (result, value) {\n          if (value === null || value === undefined || value.length === 0) {\n            return result;\n          }\n          if (result.length === 0) {\n            return [[encode(key, options), '=', encode(value, options)].join('')];\n          }\n          return [[result, encode(value, options)].join(options.arrayFormatSeparator)];\n        };\n      };\n    default:\n      return function (key) {\n        return function (result, value) {\n          if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === '') {\n            return result;\n          }\n          if (value === null) {\n            return [].concat(_toConsumableArray(result), [encode(key, options)]);\n          }\n          return [].concat(_toConsumableArray(result), [[encode(key, options), '=', encode(value, options)].join('')]);\n        };\n      };\n  }\n}\nfunction parserForArrayFormat(options) {\n  var result;\n  switch (options.arrayFormat) {\n    case 'index':\n      return function (key, value, accumulator) {\n        result = /\\[(\\d*)\\]$/.exec(key);\n        key = key.replace(/\\[\\d*\\]$/, '');\n        if (!result) {\n          accumulator[key] = value;\n          return;\n        }\n        if (accumulator[key] === undefined) {\n          accumulator[key] = {};\n        }\n        accumulator[key][result[1]] = value;\n      };\n    case 'bracket':\n      return function (key, value, accumulator) {\n        result = /(\\[\\])$/.exec(key);\n        key = key.replace(/\\[\\]$/, '');\n        if (!result) {\n          accumulator[key] = value;\n          return;\n        }\n        if (accumulator[key] === undefined) {\n          accumulator[key] = [value];\n          return;\n        }\n        accumulator[key] = [].concat(accumulator[key], value);\n      };\n    case 'comma':\n    case 'separator':\n      return function (key, value, accumulator) {\n        var isArray = typeof value === 'string' && value.includes(options.arrayFormatSeparator);\n        var isEncodedArray = typeof value === 'string' && !isArray && decode(value, options).includes(options.arrayFormatSeparator);\n        value = isEncodedArray ? decode(value, options) : value;\n        var newValue = isArray || isEncodedArray ? value.split(options.arrayFormatSeparator).map(function (item) {\n          return decode(item, options);\n        }) : value === null ? value : decode(value, options);\n        accumulator[key] = newValue;\n      };\n    default:\n      return function (key, value, accumulator) {\n        if (accumulator[key] === undefined) {\n          accumulator[key] = value;\n          return;\n        }\n        accumulator[key] = [].concat(accumulator[key], value);\n      };\n  }\n}\nfunction validateArrayFormatSeparator(value) {\n  if (typeof value !== 'string' || value.length !== 1) {\n    throw new TypeError('arrayFormatSeparator must be single character string');\n  }\n}\nfunction encode(value, options) {\n  if (options.encode) {\n    return options.strict ? strictUriEncode(value) : encodeURIComponent(value);\n  }\n  return value;\n}\nfunction decode(value, options) {\n  if (options.decode) {\n    return decodeComponent(value);\n  }\n  return value;\n}\nfunction keysSorter(input) {\n  if (Array.isArray(input)) {\n    return input.sort();\n  }\n  if (typeof input === 'object') {\n    return keysSorter(Object.keys(input)).sort(function (a, b) {\n      return Number(a) - Number(b);\n    }).map(function (key) {\n      return input[key];\n    });\n  }\n  return input;\n}\nfunction removeHash(input) {\n  var hashStart = input.indexOf('#');\n  if (hashStart !== -1) {\n    input = input.slice(0, hashStart);\n  }\n  return input;\n}\nfunction getHash(url) {\n  var hash = '';\n  var hashStart = url.indexOf('#');\n  if (hashStart !== -1) {\n    hash = url.slice(hashStart);\n  }\n  return hash;\n}\nfunction extract(input) {\n  input = removeHash(input);\n  var queryStart = input.indexOf('?');\n  if (queryStart === -1) {\n    return '';\n  }\n  return input.slice(queryStart + 1);\n}\nfunction parseValue(value, options) {\n  if (options.parseNumbers && !Number.isNaN(Number(value)) && typeof value === 'string' && value.trim() !== '') {\n    value = Number(value);\n  } else if (options.parseBooleans && value !== null && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {\n    value = value.toLowerCase() === 'true';\n  }\n  return value;\n}\nfunction parse(query, options) {\n  options = Object.assign({\n    decode: true,\n    sort: true,\n    arrayFormat: 'none',\n    arrayFormatSeparator: ',',\n    parseNumbers: false,\n    parseBooleans: false\n  }, options);\n  validateArrayFormatSeparator(options.arrayFormatSeparator);\n  var formatter = parserForArrayFormat(options);\n\n  // Create an object with no prototype\n  var ret = Object.create(null);\n  if (typeof query !== 'string') {\n    return ret;\n  }\n  query = query.trim().replace(/^[?#&]/, '');\n  if (!query) {\n    return ret;\n  }\n  var _iterator = _createForOfIteratorHelper(query.split('&')),\n    _step;\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var param = _step.value;\n      if (param === '') {\n        continue;\n      }\n      var _splitOnFirst = splitOnFirst(options.decode ? param.replace(/\\+/g, ' ') : param, '='),\n        _splitOnFirst2 = _slicedToArray(_splitOnFirst, 2),\n        _key = _splitOnFirst2[0],\n        _value = _splitOnFirst2[1];\n\n      // Missing `=` should be `null`:\n      // http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters\n      _value = _value === undefined ? null : ['comma', 'separator'].includes(options.arrayFormat) ? _value : decode(_value, options);\n      formatter(decode(_key, options), _value, ret);\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n  for (var _i = 0, _Object$keys = Object.keys(ret); _i < _Object$keys.length; _i++) {\n    var key = _Object$keys[_i];\n    var value = ret[key];\n    if (typeof value === 'object' && value !== null) {\n      for (var _i2 = 0, _Object$keys2 = Object.keys(value); _i2 < _Object$keys2.length; _i2++) {\n        var k = _Object$keys2[_i2];\n        value[k] = parseValue(value[k], options);\n      }\n    } else {\n      ret[key] = parseValue(value, options);\n    }\n  }\n  if (options.sort === false) {\n    return ret;\n  }\n  return (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce(function (result, key) {\n    var value = ret[key];\n    if (Boolean(value) && typeof value === 'object' && !Array.isArray(value)) {\n      // Sort object keys, not values\n      result[key] = keysSorter(value);\n    } else {\n      result[key] = value;\n    }\n    return result;\n  }, Object.create(null));\n}\nexports.extract = extract;\nexports.parse = parse;\nexports.stringify = function (object, options) {\n  if (!object) {\n    return '';\n  }\n  options = Object.assign({\n    encode: true,\n    strict: true,\n    arrayFormat: 'none',\n    arrayFormatSeparator: ','\n  }, options);\n  validateArrayFormatSeparator(options.arrayFormatSeparator);\n  var shouldFilter = function shouldFilter(key) {\n    return options.skipNull && isNullOrUndefined(object[key]) || options.skipEmptyString && object[key] === '';\n  };\n  var formatter = encoderForArrayFormat(options);\n  var objectCopy = {};\n  for (var _i3 = 0, _Object$keys3 = Object.keys(object); _i3 < _Object$keys3.length; _i3++) {\n    var key = _Object$keys3[_i3];\n    if (!shouldFilter(key)) {\n      objectCopy[key] = object[key];\n    }\n  }\n  var keys = Object.keys(objectCopy);\n  if (options.sort !== false) {\n    keys.sort(options.sort);\n  }\n  return keys.map(function (key) {\n    var value = object[key];\n    if (value === undefined) {\n      return '';\n    }\n    if (value === null) {\n      return encode(key, options);\n    }\n    if (Array.isArray(value)) {\n      return value.reduce(formatter(key), []).join('&');\n    }\n    return encode(key, options) + '=' + encode(value, options);\n  }).filter(function (x) {\n    return x.length > 0;\n  }).join('&');\n};\nexports.parseUrl = function (url, options) {\n  options = Object.assign({\n    decode: true\n  }, options);\n  var _splitOnFirst3 = splitOnFirst(url, '#'),\n    _splitOnFirst4 = _slicedToArray(_splitOnFirst3, 2),\n    url_ = _splitOnFirst4[0],\n    hash = _splitOnFirst4[1];\n  return Object.assign({\n    url: url_.split('?')[0] || '',\n    query: parse(extract(url), options)\n  }, options && options.parseFragmentIdentifier && hash ? {\n    fragmentIdentifier: decode(hash, options)\n  } : {});\n};\nexports.stringifyUrl = function (object, options) {\n  options = Object.assign({\n    encode: true,\n    strict: true\n  }, options);\n  var url = removeHash(object.url).split('?')[0] || '';\n  var queryFromUrl = exports.extract(object.url);\n  var parsedQueryFromUrl = exports.parse(queryFromUrl, {\n    sort: false\n  });\n  var query = Object.assign(parsedQueryFromUrl, object.query);\n  var queryString = exports.stringify(query, options);\n  if (queryString) {\n    queryString = \"?\".concat(queryString);\n  }\n  var hash = getHash(object.url);\n  if (object.fragmentIdentifier) {\n    hash = \"#\".concat(encode(object.fragmentIdentifier, options));\n  }\n  return \"\".concat(url).concat(queryString).concat(hash);\n};\nexports.pick = function (input, filter, options) {\n  options = Object.assign({\n    parseFragmentIdentifier: true\n  }, options);\n  var _exports$parseUrl = exports.parseUrl(input, options),\n    url = _exports$parseUrl.url,\n    query = _exports$parseUrl.query,\n    fragmentIdentifier = _exports$parseUrl.fragmentIdentifier;\n  return exports.stringifyUrl({\n    url: url,\n    query: filterObject(query, filter),\n    fragmentIdentifier: fragmentIdentifier\n  }, options);\n};\nexports.exclude = function (input, filter, options) {\n  var exclusionFilter = Array.isArray(filter) ? function (key) {\n    return !filter.includes(key);\n  } : function (key, value) {\n    return !filter(key, value);\n  };\n  return exports.pick(input, exclusionFilter, options);\n};","\"use strict\";\n\nfunction _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, _typeof(obj);\n}\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports[\"default\"] = exports.ParallaxHover = void 0;\nvar _react = _interopRequireWildcard(require(\"react\"));\nvar _styledComponents = _interopRequireDefault(require(\"styled-components\"));\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\nvar _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5;\nfunction _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    \"default\": obj\n  };\n}\nfunction _getRequireWildcardCache(nodeInterop) {\n  if (typeof WeakMap !== \"function\") return null;\n  var cacheBabelInterop = new WeakMap();\n  var cacheNodeInterop = new WeakMap();\n  return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {\n    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;\n  })(nodeInterop);\n}\nfunction _interopRequireWildcard(obj, nodeInterop) {\n  if (!nodeInterop && obj && obj.__esModule) {\n    return obj;\n  }\n  if (obj === null || _typeof(obj) !== \"object\" && typeof obj !== \"function\") {\n    return {\n      \"default\": obj\n    };\n  }\n  var cache = _getRequireWildcardCache(nodeInterop);\n  if (cache && cache.has(obj)) {\n    return cache.get(obj);\n  }\n  var newObj = {};\n  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;\n  for (var key in obj) {\n    if (key !== \"default\" && Object.prototype.hasOwnProperty.call(obj, key)) {\n      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;\n      if (desc && (desc.get || desc.set)) {\n        Object.defineProperty(newObj, key, desc);\n      } else {\n        newObj[key] = obj[key];\n      }\n    }\n  }\n  newObj[\"default\"] = obj;\n  if (cache) {\n    cache.set(obj, newObj);\n  }\n  return newObj;\n}\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    enumerableOnly && (symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    })), keys.push.apply(keys, symbols);\n  }\n  return keys;\n}\nfunction _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = null != arguments[i] ? arguments[i] : {};\n    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {\n      _defineProperty(target, key, source[key]);\n    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {\n      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n    });\n  }\n  return target;\n}\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  Object.defineProperty(subClass, \"prototype\", {\n    writable: false\n  });\n  if (superClass) _setPrototypeOf(subClass, superClass);\n}\nfunction _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n  return _setPrototypeOf(o, p);\n}\nfunction _createSuper(Derived) {\n  var hasNativeReflectConstruct = _isNativeReflectConstruct();\n  return function _createSuperInternal() {\n    var Super = _getPrototypeOf(Derived),\n      result;\n    if (hasNativeReflectConstruct) {\n      var NewTarget = _getPrototypeOf(this).constructor;\n      result = Reflect.construct(Super, arguments, NewTarget);\n    } else {\n      result = Super.apply(this, arguments);\n    }\n    return _possibleConstructorReturn(this, result);\n  };\n}\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  } else if (call !== void 0) {\n    throw new TypeError(\"Derived constructors may only return object or undefined\");\n  }\n  return _assertThisInitialized(self);\n}\nfunction _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n  return self;\n}\nfunction _isNativeReflectConstruct() {\n  if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n  if (Reflect.construct.sham) return false;\n  if (typeof Proxy === \"function\") return true;\n  try {\n    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\nfunction _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}\nfunction _taggedTemplateLiteral(strings, raw) {\n  if (!raw) {\n    raw = strings.slice(0);\n  }\n  return Object.freeze(Object.defineProperties(strings, {\n    raw: {\n      value: Object.freeze(raw)\n    }\n  }));\n}\nvar ParallaxWrapper = _styledComponents[\"default\"].div(_templateObject || (_templateObject = _taggedTemplateLiteral([\"\\n  transform-style: preserve-3d;\\n  transform: perspective(1000px);\\n\"])));\nvar ParallaxContainer = _styledComponents[\"default\"].div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral([\"\\n  position: relative;\\n  width: 100%;\\n  height: 100%;\\n\"])));\nvar ParallaxShadow = _styledComponents[\"default\"].div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral([\"\\n  position: absolute;\\n  width: 95%;\\n  height: 95%;\\n  top: 2.55%;\\n  left: 2.55%;\\n  background: none;\\n\"])));\nvar ParallaxLayer = _styledComponents[\"default\"].div(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral([\"\\n  overflow: hidden;\\n  width: 100%;\\n  height: 100%;\\n  position: absolute;\\n  top: 0;\\n  left: 0;\\n  bottom: 0;\\n  right: 0;\\n\"])));\nvar ParallaxLighting = (0, _styledComponents[\"default\"])(ParallaxLayer)(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral([\"\\n  opacity: 0;\\n\"])));\nvar initialState = {\n  rotateX: 0,\n  rotateY: 0,\n  scale: 1,\n  shine: 0,\n  isHovered: false\n};\nvar ParallaxHover = /*#__PURE__*/function (_Component) {\n  _inherits(ParallaxHover, _Component);\n  var _super = _createSuper(ParallaxHover);\n  function ParallaxHover(props) {\n    var _this;\n    _classCallCheck(this, ParallaxHover);\n    _this = _super.call(this, props);\n    _defineProperty(_assertThisInitialized(_this), \"buildTransitionTimingString\", function () {\n      var depth = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n      var START_SPEED = 160;\n      var MAX_SPEED = 260;\n      var DEPTH_MODIFIER = 15;\n      var speedModifier;\n      if (depth > 0) {\n        speedModifier = START_SPEED + depth * DEPTH_MODIFIER;\n      } else if (depth > 10) {\n        speedModifier = MAX_SPEED;\n      }\n      return {\n        transition: \"all \".concat(speedModifier, \"ms ease-out\")\n      };\n    });\n    _defineProperty(_assertThisInitialized(_this), \"handleParallaxBegin\", function () {\n      _this.setState({\n        isHovered: true,\n        shine: _this.props.shine\n      });\n    });\n    _defineProperty(_assertThisInitialized(_this), \"handleParallaxEnd\", function () {\n      _this.setState(initialState);\n    });\n    _defineProperty(_assertThisInitialized(_this), \"handleParallaxMove\", function (_ref) {\n      var pageX = _ref.pageX,\n        pageY = _ref.pageY;\n      var _this$props = _this.props,\n        width = _this$props.width,\n        height = _this$props.height,\n        rotation = _this$props.rotation,\n        scale = _this$props.scale;\n      var _window = window,\n        scrollTop = _window.scrollY,\n        scrollLeft = _window.scrollX;\n      var bounds = _this.wrapper.getBoundingClientRect();\n      var centerX = width / 2;\n      var centerY = height / 2;\n      var widthMultiplier = 360 / width;\n      var offsetX = (pageX - bounds.left - scrollLeft) / width;\n      var offsetY = (pageY - bounds.top - scrollTop) / height;\n      var deltaX = pageX - bounds.left - scrollLeft - centerX;\n      var deltaY = pageY - bounds.top - scrollTop - centerY;\n      var rotateX = (deltaY - offsetY) * (rotation / 100 * widthMultiplier);\n      var rotateY = (offsetX - deltaX) * (rotation / 100 * widthMultiplier);\n      var angleRad = Math.atan2(deltaY, deltaX);\n      var angleRaw = angleRad * 180 / Math.PI - 90;\n      var angle = angleRaw < 0 ? angleRaw + 360 : angleRaw;\n      _this.setState({\n        angle: angle,\n        rotateX: rotateX,\n        rotateY: rotateY,\n        scale: scale\n      });\n    });\n    _this.state = initialState;\n    return _this;\n  }\n  _createClass(ParallaxHover, [{\n    key: \"buildTransformStrings\",\n    value: function buildTransformStrings() {\n      var depth = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n      var _this$state = this.state,\n        isHovered = _this$state.isHovered,\n        rotateX = _this$state.rotateX,\n        rotateY = _this$state.rotateY,\n        scale = _this$state.scale;\n      var scaleModifier = isHovered ? 1 + scale / 100 : 1;\n      var rotationXModifier = Math.floor(rotateX / depth);\n      var rotationYModifier = Math.floor(rotateY / depth);\n      var transformString = \"scale(\".concat(scaleModifier, \") rotateX(\").concat(rotationXModifier, \"deg) rotateY(\").concat(rotationYModifier, \"deg)\");\n      return {\n        WebkitTransform: transformString,\n        MozTransform: transformString,\n        MsTransform: transformString,\n        OTransform: transformString,\n        transform: transformString\n      };\n    }\n  }, {\n    key: \"calculateDistance\",\n    value: function calculateDistance(bounds, offsetX, offsetY) {\n      var distanceX = Math.pow(offsetX - bounds.width / 2, 2);\n      var distanceY = Math.pow(offsetY - bounds.height / 2, 2);\n      return Math.floor(Math.sqrt(distanceX + distanceY));\n    }\n  }, {\n    key: \"calculateShineFromCenter\",\n    value: function calculateShineFromCenter(current) {\n      var _this$props2 = this.props,\n        width = _this$props2.width,\n        height = _this$props2.height,\n        shine = _this$props2.shine;\n      var max = Math.max(width, height);\n      return current / max * shine;\n    }\n  }, {\n    key: \"renderLayers\",\n    value: function renderLayers() {\n      var _this2 = this;\n      var _this$props3 = this.props,\n        borderRadius = _this$props3.borderRadius,\n        children = _this$props3.children,\n        height = _this$props3.height,\n        width = _this$props3.width;\n      var style = function style(depth) {\n        return _objectSpread({\n          height: \"\".concat(height, \"px\"),\n          width: \"\".concat(width, \"px\"),\n          borderRadius: \"\".concat(borderRadius, \"px\")\n        }, _this2.buildTransitionTimingString(depth));\n      };\n      if (!Array.isArray(children)) {\n        return /*#__PURE__*/_react[\"default\"].createElement(ParallaxLayer, {\n          style: style(1),\n          className: \"parallaxHover__layer\"\n        }, children);\n      }\n      return children.map(function (layer, i) {\n        return /*#__PURE__*/_react[\"default\"].createElement(ParallaxLayer, {\n          style: style(i + 2),\n          className: \"parallaxHover__layer\",\n          key: i\n        }, layer);\n      });\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this3 = this;\n      var _this$state2 = this.state,\n        angle = _this$state2.angle,\n        isHovered = _this$state2.isHovered,\n        shine = _this$state2.shine,\n        rotateX = _this$state2.rotateX;\n      var _this$props4 = this.props,\n        children = _this$props4.children,\n        borderRadius = _this$props4.borderRadius,\n        shadow = _this$props4.shadow,\n        width = _this$props4.width,\n        height = _this$props4.height;\n      var shadowPositionModifier = rotateX + shadow * shadow / 2;\n      var shadowBlurModifier = 20 + shadow * shadow;\n      var opacityModifier = isHovered ? 1 : 0;\n      var lightingShineModifier = shine * 0.1;\n      var wrapperStyles = {\n        width: width,\n        height: height\n      };\n      var innerContainerStyles = _objectSpread(_objectSpread({}, this.buildTransformStrings(1)), this.buildTransitionTimingString(1)); // prettier-ignore\n\n      var shadowStyles = _objectSpread(_objectSpread({}, this.buildTransitionTimingString(2)), {}, {\n        borderRadius: borderRadius + 'px',\n        opacity: opacityModifier,\n        boxShadow: \"\\n        0px \".concat(shadowPositionModifier, \"px \").concat(shadowBlurModifier, \"px rgba(0, 0, 0, 0.5),\\n        0px \").concat(shadowPositionModifier * 0.33, \"px \").concat(shadowBlurModifier * 0.33, \"px 5px rgba(0, 0, 0, 0.5)\")\n      });\n      var lightingStyles = _objectSpread(_objectSpread({}, this.buildTransitionTimingString(children.length)), {}, {\n        borderRadius: borderRadius + 'px',\n        opacity: opacityModifier,\n        backgroundImage: \"linear-gradient(\".concat(angle, \"deg, rgba(255,255,255, \").concat(lightingShineModifier, \") 0%, rgba(255,255,255,0) 80%)\")\n      });\n      return /*#__PURE__*/_react[\"default\"].createElement(ParallaxWrapper, {\n        className: \"parallaxHover__outter\",\n        onMouseEnter: this.handleParallaxBegin,\n        onMouseLeave: this.handleParallaxEnd,\n        onMouseMove: this.handleParallaxMove,\n        onTouchStart: this.handleParallaxBegin,\n        onTouchMove: this.handleParallaxEnd,\n        onTouchEnd: this.handleParallaxMove,\n        style: wrapperStyles,\n        ref: function ref(wrapper) {\n          _this3.wrapper = wrapper;\n        }\n      }, /*#__PURE__*/_react[\"default\"].createElement(ParallaxContainer, {\n        style: innerContainerStyles\n      }, /*#__PURE__*/_react[\"default\"].createElement(ParallaxShadow, {\n        className: \"parallaxHover__shadow\",\n        style: shadowStyles\n      }), this.renderLayers(), /*#__PURE__*/_react[\"default\"].createElement(ParallaxLighting, {\n        className: \"parallaxHover__lighting\",\n        style: lightingStyles\n      })));\n    }\n  }]);\n  return ParallaxHover;\n}(_react.Component);\nexports.ParallaxHover = ParallaxHover;\nParallaxHover.defaultProps = {\n  /** How fast the item scales up and down in MS */\n  speed: 100,\n  /** Rotation modifier */\n  rotation: 5,\n  /** Shadow darkness modifier */\n  shadow: 5,\n  /** Light shine brightness modifer */\n  shine: 5,\n  /** Default height */\n  height: 200,\n  /** Default width */\n  width: 200,\n  /** Default border radius */\n  borderRadius: 0\n};\nParallaxHover.propTypes = {\n  children: _propTypes[\"default\"].any,\n  width: _propTypes[\"default\"].number.isRequired,\n  height: _propTypes[\"default\"].number.isRequired,\n  shadow: _propTypes[\"default\"].number,\n  rotation: _propTypes[\"default\"].number,\n  shine: _propTypes[\"default\"].number,\n  borderRadius: _propTypes[\"default\"].number\n};\nvar _default = ParallaxHover;\nexports[\"default\"] = _default;","function memoize(fn) {\n  var cache = Object.create(null);\n  return function (arg) {\n    if (cache[arg] === undefined) cache[arg] = fn(arg);\n    return cache[arg];\n  };\n}\nexport default memoize;","import memoize from '@emotion/memoize';\nvar reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|abbr|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|download|draggable|encType|enterKeyHint|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|translate|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|incremental|fallback|inert|itemProp|itemScope|itemType|itemID|itemRef|on|option|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/; // https://esbench.com/bench/5bfee68a4cd7e6009ef61d23\n\nvar isPropValid = /* #__PURE__ */memoize(function (prop) {\n  return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111\n  /* o */ && prop.charCodeAt(1) === 110\n  /* n */ && prop.charCodeAt(2) < 91;\n}\n/* Z+1 */);\n\nexport default isPropValid;","function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}\nmodule.exports = _defineProperty, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\nmodule.exports = _classCallCheck, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _iterableToArrayLimit(arr, i) {\n  var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"];\n  if (_i == null) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _s, _e;\n  try {\n    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n  return _arr;\n}\nmodule.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","\"use strict\";\n\nfunction _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, _typeof(obj);\n}\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.CopyToClipboard = void 0;\nvar _react = _interopRequireDefault(require(\"react\"));\nvar _copyToClipboard = _interopRequireDefault(require(\"copy-to-clipboard\"));\nvar _excluded = [\"text\", \"onCopy\", \"options\", \"children\"];\nfunction _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    \"default\": obj\n  };\n}\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    enumerableOnly && (symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    })), keys.push.apply(keys, symbols);\n  }\n  return keys;\n}\nfunction _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = null != arguments[i] ? arguments[i] : {};\n    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {\n      _defineProperty(target, key, source[key]);\n    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {\n      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n    });\n  }\n  return target;\n}\nfunction _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n  var target = _objectWithoutPropertiesLoose(source, excluded);\n  var key, i;\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n    for (i = 0; i < sourceSymbolKeys.length; i++) {\n      key = sourceSymbolKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n      target[key] = source[key];\n    }\n  }\n  return target;\n}\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n  return target;\n}\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  Object.defineProperty(subClass, \"prototype\", {\n    writable: false\n  });\n  if (superClass) _setPrototypeOf(subClass, superClass);\n}\nfunction _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n  return _setPrototypeOf(o, p);\n}\nfunction _createSuper(Derived) {\n  var hasNativeReflectConstruct = _isNativeReflectConstruct();\n  return function _createSuperInternal() {\n    var Super = _getPrototypeOf(Derived),\n      result;\n    if (hasNativeReflectConstruct) {\n      var NewTarget = _getPrototypeOf(this).constructor;\n      result = Reflect.construct(Super, arguments, NewTarget);\n    } else {\n      result = Super.apply(this, arguments);\n    }\n    return _possibleConstructorReturn(this, result);\n  };\n}\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  } else if (call !== void 0) {\n    throw new TypeError(\"Derived constructors may only return object or undefined\");\n  }\n  return _assertThisInitialized(self);\n}\nfunction _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n  return self;\n}\nfunction _isNativeReflectConstruct() {\n  if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n  if (Reflect.construct.sham) return false;\n  if (typeof Proxy === \"function\") return true;\n  try {\n    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\nfunction _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}\nvar CopyToClipboard = /*#__PURE__*/function (_React$PureComponent) {\n  _inherits(CopyToClipboard, _React$PureComponent);\n  var _super = _createSuper(CopyToClipboard);\n  function CopyToClipboard() {\n    var _this;\n    _classCallCheck(this, CopyToClipboard);\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n    _this = _super.call.apply(_super, [this].concat(args));\n    _defineProperty(_assertThisInitialized(_this), \"onClick\", function (event) {\n      var _this$props = _this.props,\n        text = _this$props.text,\n        onCopy = _this$props.onCopy,\n        children = _this$props.children,\n        options = _this$props.options;\n      var elem = _react[\"default\"].Children.only(children);\n      var result = (0, _copyToClipboard[\"default\"])(text, options);\n      if (onCopy) {\n        onCopy(text, result);\n      } // Bypass onClick if it was present\n\n      if (elem && elem.props && typeof elem.props.onClick === 'function') {\n        elem.props.onClick(event);\n      }\n    });\n    return _this;\n  }\n  _createClass(CopyToClipboard, [{\n    key: \"render\",\n    value: function render() {\n      var _this$props2 = this.props,\n        _text = _this$props2.text,\n        _onCopy = _this$props2.onCopy,\n        _options = _this$props2.options,\n        children = _this$props2.children,\n        props = _objectWithoutProperties(_this$props2, _excluded);\n      var elem = _react[\"default\"].Children.only(children);\n      return /*#__PURE__*/_react[\"default\"].cloneElement(elem, _objectSpread(_objectSpread({}, props), {}, {\n        onClick: this.onClick\n      }));\n    }\n  }]);\n  return CopyToClipboard;\n}(_react[\"default\"].PureComponent);\nexports.CopyToClipboard = CopyToClipboard;\n_defineProperty(CopyToClipboard, \"defaultProps\", {\n  onCopy: undefined,\n  options: undefined\n});","var setPrototypeOf = require(\"./setPrototypeOf.js\");\nvar isNativeReflectConstruct = require(\"./isNativeReflectConstruct.js\");\nfunction _construct(Parent, args, Class) {\n  if (isNativeReflectConstruct()) {\n    module.exports = _construct = Reflect.construct.bind(), module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  } else {\n    module.exports = _construct = function _construct(Parent, args, Class) {\n      var a = [null];\n      a.push.apply(a, args);\n      var Constructor = Function.bind.apply(Parent, a);\n      var instance = new Constructor();\n      if (Class) setPrototypeOf(instance, Class.prototype);\n      return instance;\n    }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  }\n  return _construct.apply(null, arguments);\n}\nmodule.exports = _construct, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","import \"core-js/modules/es.typed-array.set.js\";\nimport \"core-js/modules/es.typed-array.sort.js\";\nimport \"core-js/modules/es.array.reduce.js\";\nimport { typeOf as e, isElement as t, isValidElementType as n } from \"react-is\";\nimport r, { useState as o, useContext as s, useMemo as i, useEffect as a, useRef as c, createElement as u, useDebugValue as l, useLayoutEffect as d } from \"react\";\nimport h from \"shallowequal\";\nimport p from \"@emotion/stylis\";\nimport f from \"@emotion/unitless\";\nimport m from \"@emotion/is-prop-valid\";\nimport y from \"hoist-non-react-statics\";\nfunction v() {\n  return (v = Object.assign || function (e) {\n    for (var t = 1; t < arguments.length; t++) {\n      var n = arguments[t];\n      for (var r in n) {\n        Object.prototype.hasOwnProperty.call(n, r) && (e[r] = n[r]);\n      }\n    }\n    return e;\n  }).apply(this, arguments);\n}\nvar g = function g(e, t) {\n    for (var n = [e[0]], r = 0, o = t.length; r < o; r += 1) {\n      n.push(t[r], e[r + 1]);\n    }\n    return n;\n  },\n  S = function S(t) {\n    return null !== t && \"object\" == typeof t && \"[object Object]\" === (t.toString ? t.toString() : Object.prototype.toString.call(t)) && !e(t);\n  },\n  w = Object.freeze([]),\n  E = Object.freeze({});\nfunction b(e) {\n  return \"function\" == typeof e;\n}\nfunction _(e) {\n  return \"production\" !== process.env.NODE_ENV && \"string\" == typeof e && e || e.displayName || e.name || \"Component\";\n}\nfunction N(e) {\n  return e && \"string\" == typeof e.styledComponentId;\n}\nvar A = \"undefined\" != typeof process && (process.env.REACT_APP_SC_ATTR || process.env.SC_ATTR) || \"data-styled\",\n  C = \"5.3.6\",\n  I = \"undefined\" != typeof window && \"HTMLElement\" in window,\n  P = Boolean(\"boolean\" == typeof SC_DISABLE_SPEEDY ? SC_DISABLE_SPEEDY : \"undefined\" != typeof process && void 0 !== process.env.REACT_APP_SC_DISABLE_SPEEDY && \"\" !== process.env.REACT_APP_SC_DISABLE_SPEEDY ? \"false\" !== process.env.REACT_APP_SC_DISABLE_SPEEDY && process.env.REACT_APP_SC_DISABLE_SPEEDY : \"undefined\" != typeof process && void 0 !== process.env.SC_DISABLE_SPEEDY && \"\" !== process.env.SC_DISABLE_SPEEDY ? \"false\" !== process.env.SC_DISABLE_SPEEDY && process.env.SC_DISABLE_SPEEDY : \"production\" !== process.env.NODE_ENV),\n  O = {},\n  R = \"production\" !== process.env.NODE_ENV ? {\n    1: \"Cannot create styled-component for component: %s.\\n\\n\",\n    2: \"Can't collect styles once you've consumed a `ServerStyleSheet`'s styles! `ServerStyleSheet` is a one off instance for each server-side render cycle.\\n\\n- Are you trying to reuse it across renders?\\n- Are you accidentally calling collectStyles twice?\\n\\n\",\n    3: \"Streaming SSR is only supported in a Node.js environment; Please do not try to call this method in the browser.\\n\\n\",\n    4: \"The `StyleSheetManager` expects a valid target or sheet prop!\\n\\n- Does this error occur on the client and is your target falsy?\\n- Does this error occur on the server and is the sheet falsy?\\n\\n\",\n    5: \"The clone method cannot be used on the client!\\n\\n- Are you running in a client-like environment on the server?\\n- Are you trying to run SSR on the client?\\n\\n\",\n    6: \"Trying to insert a new style tag, but the given Node is unmounted!\\n\\n- Are you using a custom target that isn't mounted?\\n- Does your document not have a valid head element?\\n- Have you accidentally removed a style tag manually?\\n\\n\",\n    7: 'ThemeProvider: Please return an object from your \"theme\" prop function, e.g.\\n\\n```js\\ntheme={() => ({})}\\n```\\n\\n',\n    8: 'ThemeProvider: Please make your \"theme\" prop an object.\\n\\n',\n    9: \"Missing document `<head>`\\n\\n\",\n    10: \"Cannot find a StyleSheet instance. Usually this happens if there are multiple copies of styled-components loaded at once. Check out this issue for how to troubleshoot and fix the common cases where this situation can happen: https://github.com/styled-components/styled-components/issues/1941#issuecomment-417862021\\n\\n\",\n    11: \"_This error was replaced with a dev-time warning, it will be deleted for v4 final._ [createGlobalStyle] received children which will not be rendered. Please use the component without passing children elements.\\n\\n\",\n    12: \"It seems you are interpolating a keyframe declaration (%s) into an untagged string. This was supported in styled-components v3, but is not longer supported in v4 as keyframes are now injected on-demand. Please wrap your string in the css\\\\`\\\\` helper which ensures the styles are injected correctly. See https://www.styled-components.com/docs/api#css\\n\\n\",\n    13: \"%s is not a styled component and cannot be referred to via component selector. See https://www.styled-components.com/docs/advanced#referring-to-other-components for more details.\\n\\n\",\n    14: 'ThemeProvider: \"theme\" prop is required.\\n\\n',\n    15: \"A stylis plugin has been supplied that is not named. We need a name for each plugin to be able to prevent styling collisions between different stylis configurations within the same app. Before you pass your plugin to `<StyleSheetManager stylisPlugins={[]}>`, please make sure each plugin is uniquely-named, e.g.\\n\\n```js\\nObject.defineProperty(importedPlugin, 'name', { value: 'some-unique-name' });\\n```\\n\\n\",\n    16: \"Reached the limit of how many styled components may be created at group %s.\\nYou may only create up to 1,073,741,824 components. If you're creating components dynamically,\\nas for instance in your render method then you may be running into this limitation.\\n\\n\",\n    17: \"CSSStyleSheet could not be found on HTMLStyleElement.\\nHas styled-components' style tag been unmounted or altered by another script?\\n\"\n  } : {};\nfunction D() {\n  for (var e = arguments.length <= 0 ? void 0 : arguments[0], t = [], n = 1, r = arguments.length; n < r; n += 1) {\n    t.push(n < 0 || arguments.length <= n ? void 0 : arguments[n]);\n  }\n  return t.forEach(function (t) {\n    e = e.replace(/%[a-z]/, t);\n  }), e;\n}\nfunction j(e) {\n  for (var t = arguments.length, n = new Array(t > 1 ? t - 1 : 0), r = 1; r < t; r++) {\n    n[r - 1] = arguments[r];\n  }\n  throw \"production\" === process.env.NODE_ENV ? new Error(\"An error occurred. See https://git.io/JUIaE#\" + e + \" for more information.\" + (n.length > 0 ? \" Args: \" + n.join(\", \") : \"\")) : new Error(D.apply(void 0, [R[e]].concat(n)).trim());\n}\nvar T = function () {\n    function e(e) {\n      this.groupSizes = new Uint32Array(512), this.length = 512, this.tag = e;\n    }\n    var t = e.prototype;\n    return t.indexOfGroup = function (e) {\n      for (var t = 0, n = 0; n < e; n++) {\n        t += this.groupSizes[n];\n      }\n      return t;\n    }, t.insertRules = function (e, t) {\n      if (e >= this.groupSizes.length) {\n        for (var n = this.groupSizes, r = n.length, o = r; e >= o;) {\n          (o <<= 1) < 0 && j(16, \"\" + e);\n        }\n        this.groupSizes = new Uint32Array(o), this.groupSizes.set(n), this.length = o;\n        for (var s = r; s < o; s++) {\n          this.groupSizes[s] = 0;\n        }\n      }\n      for (var i = this.indexOfGroup(e + 1), a = 0, c = t.length; a < c; a++) {\n        this.tag.insertRule(i, t[a]) && (this.groupSizes[e]++, i++);\n      }\n    }, t.clearGroup = function (e) {\n      if (e < this.length) {\n        var t = this.groupSizes[e],\n          n = this.indexOfGroup(e),\n          r = n + t;\n        this.groupSizes[e] = 0;\n        for (var o = n; o < r; o++) {\n          this.tag.deleteRule(n);\n        }\n      }\n    }, t.getGroup = function (e) {\n      var t = \"\";\n      if (e >= this.length || 0 === this.groupSizes[e]) return t;\n      for (var n = this.groupSizes[e], r = this.indexOfGroup(e), o = r + n, s = r; s < o; s++) {\n        t += this.tag.getRule(s) + \"/*!sc*/\\n\";\n      }\n      return t;\n    }, e;\n  }(),\n  x = new Map(),\n  k = new Map(),\n  V = 1,\n  B = function B(e) {\n    if (x.has(e)) return x.get(e);\n    for (; k.has(V);) {\n      V++;\n    }\n    var t = V++;\n    return \"production\" !== process.env.NODE_ENV && ((0 | t) < 0 || t > 1 << 30) && j(16, \"\" + t), x.set(e, t), k.set(t, e), t;\n  },\n  z = function z(e) {\n    return k.get(e);\n  },\n  M = function M(e, t) {\n    t >= V && (V = t + 1), x.set(e, t), k.set(t, e);\n  },\n  G = \"style[\" + A + '][data-styled-version=\"5.3.6\"]',\n  L = new RegExp(\"^\" + A + '\\\\.g(\\\\d+)\\\\[id=\"([\\\\w\\\\d-]+)\"\\\\].*?\"([^\"]*)'),\n  F = function F(e, t, n) {\n    for (var r, o = n.split(\",\"), s = 0, i = o.length; s < i; s++) {\n      (r = o[s]) && e.registerName(t, r);\n    }\n  },\n  Y = function Y(e, t) {\n    for (var n = (t.textContent || \"\").split(\"/*!sc*/\\n\"), r = [], o = 0, s = n.length; o < s; o++) {\n      var i = n[o].trim();\n      if (i) {\n        var a = i.match(L);\n        if (a) {\n          var c = 0 | parseInt(a[1], 10),\n            u = a[2];\n          0 !== c && (M(u, c), F(e, u, a[3]), e.getTag().insertRules(c, r)), r.length = 0;\n        } else r.push(i);\n      }\n    }\n  },\n  q = function q() {\n    return \"undefined\" != typeof __webpack_nonce__ ? __webpack_nonce__ : null;\n  },\n  H = function H(e) {\n    var t = document.head,\n      n = e || t,\n      r = document.createElement(\"style\"),\n      o = function (e) {\n        for (var t = e.childNodes, n = t.length; n >= 0; n--) {\n          var r = t[n];\n          if (r && 1 === r.nodeType && r.hasAttribute(A)) return r;\n        }\n      }(n),\n      s = void 0 !== o ? o.nextSibling : null;\n    r.setAttribute(A, \"active\"), r.setAttribute(\"data-styled-version\", \"5.3.6\");\n    var i = q();\n    return i && r.setAttribute(\"nonce\", i), n.insertBefore(r, s), r;\n  },\n  $ = function () {\n    function e(e) {\n      var t = this.element = H(e);\n      t.appendChild(document.createTextNode(\"\")), this.sheet = function (e) {\n        if (e.sheet) return e.sheet;\n        for (var t = document.styleSheets, n = 0, r = t.length; n < r; n++) {\n          var o = t[n];\n          if (o.ownerNode === e) return o;\n        }\n        j(17);\n      }(t), this.length = 0;\n    }\n    var t = e.prototype;\n    return t.insertRule = function (e, t) {\n      try {\n        return this.sheet.insertRule(t, e), this.length++, !0;\n      } catch (e) {\n        return !1;\n      }\n    }, t.deleteRule = function (e) {\n      this.sheet.deleteRule(e), this.length--;\n    }, t.getRule = function (e) {\n      var t = this.sheet.cssRules[e];\n      return void 0 !== t && \"string\" == typeof t.cssText ? t.cssText : \"\";\n    }, e;\n  }(),\n  W = function () {\n    function e(e) {\n      var t = this.element = H(e);\n      this.nodes = t.childNodes, this.length = 0;\n    }\n    var t = e.prototype;\n    return t.insertRule = function (e, t) {\n      if (e <= this.length && e >= 0) {\n        var n = document.createTextNode(t),\n          r = this.nodes[e];\n        return this.element.insertBefore(n, r || null), this.length++, !0;\n      }\n      return !1;\n    }, t.deleteRule = function (e) {\n      this.element.removeChild(this.nodes[e]), this.length--;\n    }, t.getRule = function (e) {\n      return e < this.length ? this.nodes[e].textContent : \"\";\n    }, e;\n  }(),\n  U = function () {\n    function e(e) {\n      this.rules = [], this.length = 0;\n    }\n    var t = e.prototype;\n    return t.insertRule = function (e, t) {\n      return e <= this.length && (this.rules.splice(e, 0, t), this.length++, !0);\n    }, t.deleteRule = function (e) {\n      this.rules.splice(e, 1), this.length--;\n    }, t.getRule = function (e) {\n      return e < this.length ? this.rules[e] : \"\";\n    }, e;\n  }(),\n  J = I,\n  X = {\n    isServer: !I,\n    useCSSOMInjection: !P\n  },\n  Z = function () {\n    function e(e, t, n) {\n      void 0 === e && (e = E), void 0 === t && (t = {}), this.options = v({}, X, {}, e), this.gs = t, this.names = new Map(n), this.server = !!e.isServer, !this.server && I && J && (J = !1, function (e) {\n        for (var t = document.querySelectorAll(G), n = 0, r = t.length; n < r; n++) {\n          var o = t[n];\n          o && \"active\" !== o.getAttribute(A) && (Y(e, o), o.parentNode && o.parentNode.removeChild(o));\n        }\n      }(this));\n    }\n    e.registerId = function (e) {\n      return B(e);\n    };\n    var t = e.prototype;\n    return t.reconstructWithOptions = function (t, n) {\n      return void 0 === n && (n = !0), new e(v({}, this.options, {}, t), this.gs, n && this.names || void 0);\n    }, t.allocateGSInstance = function (e) {\n      return this.gs[e] = (this.gs[e] || 0) + 1;\n    }, t.getTag = function () {\n      return this.tag || (this.tag = (n = (t = this.options).isServer, r = t.useCSSOMInjection, o = t.target, e = n ? new U(o) : r ? new $(o) : new W(o), new T(e)));\n      var e, t, n, r, o;\n    }, t.hasNameForId = function (e, t) {\n      return this.names.has(e) && this.names.get(e).has(t);\n    }, t.registerName = function (e, t) {\n      if (B(e), this.names.has(e)) this.names.get(e).add(t);else {\n        var n = new Set();\n        n.add(t), this.names.set(e, n);\n      }\n    }, t.insertRules = function (e, t, n) {\n      this.registerName(e, t), this.getTag().insertRules(B(e), n);\n    }, t.clearNames = function (e) {\n      this.names.has(e) && this.names.get(e).clear();\n    }, t.clearRules = function (e) {\n      this.getTag().clearGroup(B(e)), this.clearNames(e);\n    }, t.clearTag = function () {\n      this.tag = void 0;\n    }, t.toString = function () {\n      return function (e) {\n        for (var t = e.getTag(), n = t.length, r = \"\", o = 0; o < n; o++) {\n          var s = z(o);\n          if (void 0 !== s) {\n            var i = e.names.get(s),\n              a = t.getGroup(o);\n            if (i && a && i.size) {\n              var c = A + \".g\" + o + '[id=\"' + s + '\"]',\n                u = \"\";\n              void 0 !== i && i.forEach(function (e) {\n                e.length > 0 && (u += e + \",\");\n              }), r += \"\" + a + c + '{content:\"' + u + '\"}/*!sc*/\\n';\n            }\n          }\n        }\n        return r;\n      }(this);\n    }, e;\n  }(),\n  K = /(a)(d)/gi,\n  Q = function Q(e) {\n    return String.fromCharCode(e + (e > 25 ? 39 : 97));\n  };\nfunction ee(e) {\n  var t,\n    n = \"\";\n  for (t = Math.abs(e); t > 52; t = t / 52 | 0) {\n    n = Q(t % 52) + n;\n  }\n  return (Q(t % 52) + n).replace(K, \"$1-$2\");\n}\nvar te = function te(e, t) {\n    for (var n = t.length; n;) {\n      e = 33 * e ^ t.charCodeAt(--n);\n    }\n    return e;\n  },\n  ne = function ne(e) {\n    return te(5381, e);\n  };\nfunction re(e) {\n  for (var t = 0; t < e.length; t += 1) {\n    var n = e[t];\n    if (b(n) && !N(n)) return !1;\n  }\n  return !0;\n}\nvar oe = ne(\"5.3.6\"),\n  se = function () {\n    function e(e, t, n) {\n      this.rules = e, this.staticRulesId = \"\", this.isStatic = \"production\" === process.env.NODE_ENV && (void 0 === n || n.isStatic) && re(e), this.componentId = t, this.baseHash = te(oe, t), this.baseStyle = n, Z.registerId(t);\n    }\n    return e.prototype.generateAndInjectStyles = function (e, t, n) {\n      var r = this.componentId,\n        o = [];\n      if (this.baseStyle && o.push(this.baseStyle.generateAndInjectStyles(e, t, n)), this.isStatic && !n.hash) {\n        if (this.staticRulesId && t.hasNameForId(r, this.staticRulesId)) o.push(this.staticRulesId);else {\n          var s = Ne(this.rules, e, t, n).join(\"\"),\n            i = ee(te(this.baseHash, s) >>> 0);\n          if (!t.hasNameForId(r, i)) {\n            var a = n(s, \".\" + i, void 0, r);\n            t.insertRules(r, i, a);\n          }\n          o.push(i), this.staticRulesId = i;\n        }\n      } else {\n        for (var c = this.rules.length, u = te(this.baseHash, n.hash), l = \"\", d = 0; d < c; d++) {\n          var h = this.rules[d];\n          if (\"string\" == typeof h) l += h, \"production\" !== process.env.NODE_ENV && (u = te(u, h + d));else if (h) {\n            var p = Ne(h, e, t, n),\n              f = Array.isArray(p) ? p.join(\"\") : p;\n            u = te(u, f + d), l += f;\n          }\n        }\n        if (l) {\n          var m = ee(u >>> 0);\n          if (!t.hasNameForId(r, m)) {\n            var y = n(l, \".\" + m, void 0, r);\n            t.insertRules(r, m, y);\n          }\n          o.push(m);\n        }\n      }\n      return o.join(\" \");\n    }, e;\n  }(),\n  ie = /^\\s*\\/\\/.*$/gm,\n  ae = [\":\", \"[\", \".\", \"#\"];\nfunction ce(e) {\n  var t,\n    n,\n    r,\n    o,\n    s = void 0 === e ? E : e,\n    i = s.options,\n    a = void 0 === i ? E : i,\n    c = s.plugins,\n    u = void 0 === c ? w : c,\n    l = new p(a),\n    d = [],\n    h = function (e) {\n      function t(t) {\n        if (t) try {\n          e(t + \"}\");\n        } catch (e) {}\n      }\n      return function (n, r, o, s, i, a, c, u, l, d) {\n        switch (n) {\n          case 1:\n            if (0 === l && 64 === r.charCodeAt(0)) return e(r + \";\"), \"\";\n            break;\n          case 2:\n            if (0 === u) return r + \"/*|*/\";\n            break;\n          case 3:\n            switch (u) {\n              case 102:\n              case 112:\n                return e(o[0] + r), \"\";\n              default:\n                return r + (0 === d ? \"/*|*/\" : \"\");\n            }\n          case -2:\n            r.split(\"/*|*/}\").forEach(t);\n        }\n      };\n    }(function (e) {\n      d.push(e);\n    }),\n    f = function f(e, r, s) {\n      return 0 === r && -1 !== ae.indexOf(s[n.length]) || s.match(o) ? e : \".\" + t;\n    };\n  function m(e, s, i, a) {\n    void 0 === a && (a = \"&\");\n    var c = e.replace(ie, \"\"),\n      u = s && i ? i + \" \" + s + \" { \" + c + \" }\" : c;\n    return t = a, n = s, r = new RegExp(\"\\\\\" + n + \"\\\\b\", \"g\"), o = new RegExp(\"(\\\\\" + n + \"\\\\b){2,}\"), l(i || !s ? \"\" : s, u);\n  }\n  return l.use([].concat(u, [function (e, t, o) {\n    2 === e && o.length && o[0].lastIndexOf(n) > 0 && (o[0] = o[0].replace(r, f));\n  }, h, function (e) {\n    if (-2 === e) {\n      var t = d;\n      return d = [], t;\n    }\n  }])), m.hash = u.length ? u.reduce(function (e, t) {\n    return t.name || j(15), te(e, t.name);\n  }, 5381).toString() : \"\", m;\n}\nvar ue = r.createContext(),\n  le = ue.Consumer,\n  de = r.createContext(),\n  he = (de.Consumer, new Z()),\n  pe = ce();\nfunction fe() {\n  return s(ue) || he;\n}\nfunction me() {\n  return s(de) || pe;\n}\nfunction ye(e) {\n  var t = o(e.stylisPlugins),\n    n = t[0],\n    s = t[1],\n    c = fe(),\n    u = i(function () {\n      var t = c;\n      return e.sheet ? t = e.sheet : e.target && (t = t.reconstructWithOptions({\n        target: e.target\n      }, !1)), e.disableCSSOMInjection && (t = t.reconstructWithOptions({\n        useCSSOMInjection: !1\n      })), t;\n    }, [e.disableCSSOMInjection, e.sheet, e.target]),\n    l = i(function () {\n      return ce({\n        options: {\n          prefix: !e.disableVendorPrefixes\n        },\n        plugins: n\n      });\n    }, [e.disableVendorPrefixes, n]);\n  return a(function () {\n    h(n, e.stylisPlugins) || s(e.stylisPlugins);\n  }, [e.stylisPlugins]), r.createElement(ue.Provider, {\n    value: u\n  }, r.createElement(de.Provider, {\n    value: l\n  }, \"production\" !== process.env.NODE_ENV ? r.Children.only(e.children) : e.children));\n}\nvar ve = function () {\n    function e(e, t) {\n      var n = this;\n      this.inject = function (e, t) {\n        void 0 === t && (t = pe);\n        var r = n.name + t.hash;\n        e.hasNameForId(n.id, r) || e.insertRules(n.id, r, t(n.rules, r, \"@keyframes\"));\n      }, this.toString = function () {\n        return j(12, String(n.name));\n      }, this.name = e, this.id = \"sc-keyframes-\" + e, this.rules = t;\n    }\n    return e.prototype.getName = function (e) {\n      return void 0 === e && (e = pe), this.name + e.hash;\n    }, e;\n  }(),\n  ge = /([A-Z])/,\n  Se = /([A-Z])/g,\n  we = /^ms-/,\n  Ee = function Ee(e) {\n    return \"-\" + e.toLowerCase();\n  };\nfunction be(e) {\n  return ge.test(e) ? e.replace(Se, Ee).replace(we, \"-ms-\") : e;\n}\nvar _e = function _e(e) {\n  return null == e || !1 === e || \"\" === e;\n};\nfunction Ne(e, n, r, o) {\n  if (Array.isArray(e)) {\n    for (var s, i = [], a = 0, c = e.length; a < c; a += 1) {\n      \"\" !== (s = Ne(e[a], n, r, o)) && (Array.isArray(s) ? i.push.apply(i, s) : i.push(s));\n    }\n    return i;\n  }\n  if (_e(e)) return \"\";\n  if (N(e)) return \".\" + e.styledComponentId;\n  if (b(e)) {\n    if (\"function\" != typeof (l = e) || l.prototype && l.prototype.isReactComponent || !n) return e;\n    var u = e(n);\n    return \"production\" !== process.env.NODE_ENV && t(u) && console.warn(_(e) + \" is not a styled component and cannot be referred to via component selector. See https://www.styled-components.com/docs/advanced#referring-to-other-components for more details.\"), Ne(u, n, r, o);\n  }\n  var l;\n  return e instanceof ve ? r ? (e.inject(r, o), e.getName(o)) : e : S(e) ? function e(t, n) {\n    var r,\n      o,\n      s = [];\n    for (var i in t) {\n      t.hasOwnProperty(i) && !_e(t[i]) && (Array.isArray(t[i]) && t[i].isCss || b(t[i]) ? s.push(be(i) + \":\", t[i], \";\") : S(t[i]) ? s.push.apply(s, e(t[i], i)) : s.push(be(i) + \": \" + (r = i, null == (o = t[i]) || \"boolean\" == typeof o || \"\" === o ? \"\" : \"number\" != typeof o || 0 === o || r in f ? String(o).trim() : o + \"px\") + \";\"));\n    }\n    return n ? [n + \" {\"].concat(s, [\"}\"]) : s;\n  }(e) : e.toString();\n}\nvar Ae = function Ae(e) {\n  return Array.isArray(e) && (e.isCss = !0), e;\n};\nfunction Ce(e) {\n  for (var t = arguments.length, n = new Array(t > 1 ? t - 1 : 0), r = 1; r < t; r++) {\n    n[r - 1] = arguments[r];\n  }\n  return b(e) || S(e) ? Ae(Ne(g(w, [e].concat(n)))) : 0 === n.length && 1 === e.length && \"string\" == typeof e[0] ? e : Ae(Ne(g(e, n)));\n}\nvar Ie = /invalid hook call/i,\n  Pe = new Set(),\n  Oe = function Oe(e, t) {\n    if (\"production\" !== process.env.NODE_ENV) {\n      var n = \"The component \" + e + (t ? ' with the id of \"' + t + '\"' : \"\") + \" has been created dynamically.\\nYou may see this warning because you've called styled inside another component.\\nTo resolve this only create new StyledComponents outside of any render method and function component.\",\n        r = console.error;\n      try {\n        var o = !0;\n        console.error = function (e) {\n          if (Ie.test(e)) o = !1, Pe.delete(n);else {\n            for (var t = arguments.length, s = new Array(t > 1 ? t - 1 : 0), i = 1; i < t; i++) {\n              s[i - 1] = arguments[i];\n            }\n            r.apply(void 0, [e].concat(s));\n          }\n        }, c(), o && !Pe.has(n) && (console.warn(n), Pe.add(n));\n      } catch (e) {\n        Ie.test(e.message) && Pe.delete(n);\n      } finally {\n        console.error = r;\n      }\n    }\n  },\n  Re = function Re(e, t, n) {\n    return void 0 === n && (n = E), e.theme !== n.theme && e.theme || t || n.theme;\n  },\n  De = /[!\"#$%&'()*+,./:;<=>?@[\\\\\\]^`{|}~-]+/g,\n  je = /(^-|-$)/g;\nfunction Te(e) {\n  return e.replace(De, \"-\").replace(je, \"\");\n}\nvar xe = function xe(e) {\n  return ee(ne(e) >>> 0);\n};\nfunction ke(e) {\n  return \"string\" == typeof e && (\"production\" === process.env.NODE_ENV || e.charAt(0) === e.charAt(0).toLowerCase());\n}\nvar Ve = function Ve(e) {\n    return \"function\" == typeof e || \"object\" == typeof e && null !== e && !Array.isArray(e);\n  },\n  Be = function Be(e) {\n    return \"__proto__\" !== e && \"constructor\" !== e && \"prototype\" !== e;\n  };\nfunction ze(e, t, n) {\n  var r = e[n];\n  Ve(t) && Ve(r) ? Me(r, t) : e[n] = t;\n}\nfunction Me(e) {\n  for (var t = arguments.length, n = new Array(t > 1 ? t - 1 : 0), r = 1; r < t; r++) {\n    n[r - 1] = arguments[r];\n  }\n  for (var o = 0, s = n; o < s.length; o++) {\n    var i = s[o];\n    if (Ve(i)) for (var a in i) {\n      Be(a) && ze(e, i[a], a);\n    }\n  }\n  return e;\n}\nvar Ge = r.createContext(),\n  Le = Ge.Consumer;\nfunction Fe(e) {\n  var t = s(Ge),\n    n = i(function () {\n      return function (e, t) {\n        if (!e) return j(14);\n        if (b(e)) {\n          var n = e(t);\n          return \"production\" === process.env.NODE_ENV || null !== n && !Array.isArray(n) && \"object\" == typeof n ? n : j(7);\n        }\n        return Array.isArray(e) || \"object\" != typeof e ? j(8) : t ? v({}, t, {}, e) : e;\n      }(e.theme, t);\n    }, [e.theme, t]);\n  return e.children ? r.createElement(Ge.Provider, {\n    value: n\n  }, e.children) : null;\n}\nvar Ye = {};\nfunction qe(e, t, n) {\n  var o = N(e),\n    i = !ke(e),\n    a = t.attrs,\n    c = void 0 === a ? w : a,\n    d = t.componentId,\n    h = void 0 === d ? function (e, t) {\n      var n = \"string\" != typeof e ? \"sc\" : Te(e);\n      Ye[n] = (Ye[n] || 0) + 1;\n      var r = n + \"-\" + xe(\"5.3.6\" + n + Ye[n]);\n      return t ? t + \"-\" + r : r;\n    }(t.displayName, t.parentComponentId) : d,\n    p = t.displayName,\n    f = void 0 === p ? function (e) {\n      return ke(e) ? \"styled.\" + e : \"Styled(\" + _(e) + \")\";\n    }(e) : p,\n    g = t.displayName && t.componentId ? Te(t.displayName) + \"-\" + t.componentId : t.componentId || h,\n    S = o && e.attrs ? Array.prototype.concat(e.attrs, c).filter(Boolean) : c,\n    A = t.shouldForwardProp;\n  o && e.shouldForwardProp && (A = t.shouldForwardProp ? function (n, r, o) {\n    return e.shouldForwardProp(n, r, o) && t.shouldForwardProp(n, r, o);\n  } : e.shouldForwardProp);\n  var C,\n    I = new se(n, g, o ? e.componentStyle : void 0),\n    P = I.isStatic && 0 === c.length,\n    O = function O(e, t) {\n      return function (e, t, n, r) {\n        var o = e.attrs,\n          i = e.componentStyle,\n          a = e.defaultProps,\n          c = e.foldedComponentIds,\n          d = e.shouldForwardProp,\n          h = e.styledComponentId,\n          p = e.target;\n        \"production\" !== process.env.NODE_ENV && l(h);\n        var f = function (e, t, n) {\n            void 0 === e && (e = E);\n            var r = v({}, t, {\n                theme: e\n              }),\n              o = {};\n            return n.forEach(function (e) {\n              var t,\n                n,\n                s,\n                i = e;\n              for (t in b(i) && (i = i(r)), i) {\n                r[t] = o[t] = \"className\" === t ? (n = o[t], s = i[t], n && s ? n + \" \" + s : n || s) : i[t];\n              }\n            }), [r, o];\n          }(Re(t, s(Ge), a) || E, t, o),\n          y = f[0],\n          g = f[1],\n          S = function (e, t, n, r) {\n            var o = fe(),\n              s = me(),\n              i = t ? e.generateAndInjectStyles(E, o, s) : e.generateAndInjectStyles(n, o, s);\n            return \"production\" !== process.env.NODE_ENV && l(i), \"production\" !== process.env.NODE_ENV && !t && r && r(i), i;\n          }(i, r, y, \"production\" !== process.env.NODE_ENV ? e.warnTooManyClasses : void 0),\n          w = n,\n          _ = g.$as || t.$as || g.as || t.as || p,\n          N = ke(_),\n          A = g !== t ? v({}, t, {}, g) : t,\n          C = {};\n        for (var I in A) {\n          \"$\" !== I[0] && \"as\" !== I && (\"forwardedAs\" === I ? C.as = A[I] : (d ? d(I, m, _) : !N || m(I)) && (C[I] = A[I]));\n        }\n        return t.style && g.style !== t.style && (C.style = v({}, t.style, {}, g.style)), C.className = Array.prototype.concat(c, h, S !== h ? S : null, t.className, g.className).filter(Boolean).join(\" \"), C.ref = w, u(_, C);\n      }(C, e, t, P);\n    };\n  return O.displayName = f, (C = r.forwardRef(O)).attrs = S, C.componentStyle = I, C.displayName = f, C.shouldForwardProp = A, C.foldedComponentIds = o ? Array.prototype.concat(e.foldedComponentIds, e.styledComponentId) : w, C.styledComponentId = g, C.target = o ? e.target : e, C.withComponent = function (e) {\n    var r = t.componentId,\n      o = function (e, t) {\n        if (null == e) return {};\n        var n,\n          r,\n          o = {},\n          s = Object.keys(e);\n        for (r = 0; r < s.length; r++) {\n          n = s[r], t.indexOf(n) >= 0 || (o[n] = e[n]);\n        }\n        return o;\n      }(t, [\"componentId\"]),\n      s = r && r + \"-\" + (ke(e) ? e : Te(_(e)));\n    return qe(e, v({}, o, {\n      attrs: S,\n      componentId: s\n    }), n);\n  }, Object.defineProperty(C, \"defaultProps\", {\n    get: function get() {\n      return this._foldedDefaultProps;\n    },\n    set: function set(t) {\n      this._foldedDefaultProps = o ? Me({}, e.defaultProps, t) : t;\n    }\n  }), \"production\" !== process.env.NODE_ENV && (Oe(f, g), C.warnTooManyClasses = function (e, t) {\n    var n = {},\n      r = !1;\n    return function (o) {\n      if (!r && (n[o] = !0, Object.keys(n).length >= 200)) {\n        var s = t ? ' with the id of \"' + t + '\"' : \"\";\n        console.warn(\"Over 200 classes were generated for component \" + e + s + \".\\nConsider using the attrs method, together with a style object for frequently changed styles.\\nExample:\\n  const Component = styled.div.attrs(props => ({\\n    style: {\\n      background: props.background,\\n    },\\n  }))`width: 100%;`\\n\\n  <Component />\"), r = !0, n = {};\n      }\n    };\n  }(f, g)), C.toString = function () {\n    return \".\" + C.styledComponentId;\n  }, i && y(C, e, {\n    attrs: !0,\n    componentStyle: !0,\n    displayName: !0,\n    foldedComponentIds: !0,\n    shouldForwardProp: !0,\n    styledComponentId: !0,\n    target: !0,\n    withComponent: !0\n  }), C;\n}\nvar He = function He(e) {\n  return function e(t, r, o) {\n    if (void 0 === o && (o = E), !n(r)) return j(1, String(r));\n    var s = function s() {\n      return t(r, o, Ce.apply(void 0, arguments));\n    };\n    return s.withConfig = function (n) {\n      return e(t, r, v({}, o, {}, n));\n    }, s.attrs = function (n) {\n      return e(t, r, v({}, o, {\n        attrs: Array.prototype.concat(o.attrs, n).filter(Boolean)\n      }));\n    }, s;\n  }(qe, e);\n};\n[\"a\", \"abbr\", \"address\", \"area\", \"article\", \"aside\", \"audio\", \"b\", \"base\", \"bdi\", \"bdo\", \"big\", \"blockquote\", \"body\", \"br\", \"button\", \"canvas\", \"caption\", \"cite\", \"code\", \"col\", \"colgroup\", \"data\", \"datalist\", \"dd\", \"del\", \"details\", \"dfn\", \"dialog\", \"div\", \"dl\", \"dt\", \"em\", \"embed\", \"fieldset\", \"figcaption\", \"figure\", \"footer\", \"form\", \"h1\", \"h2\", \"h3\", \"h4\", \"h5\", \"h6\", \"head\", \"header\", \"hgroup\", \"hr\", \"html\", \"i\", \"iframe\", \"img\", \"input\", \"ins\", \"kbd\", \"keygen\", \"label\", \"legend\", \"li\", \"link\", \"main\", \"map\", \"mark\", \"marquee\", \"menu\", \"menuitem\", \"meta\", \"meter\", \"nav\", \"noscript\", \"object\", \"ol\", \"optgroup\", \"option\", \"output\", \"p\", \"param\", \"picture\", \"pre\", \"progress\", \"q\", \"rp\", \"rt\", \"ruby\", \"s\", \"samp\", \"script\", \"section\", \"select\", \"small\", \"source\", \"span\", \"strong\", \"style\", \"sub\", \"summary\", \"sup\", \"table\", \"tbody\", \"td\", \"textarea\", \"tfoot\", \"th\", \"thead\", \"time\", \"title\", \"tr\", \"track\", \"u\", \"ul\", \"var\", \"video\", \"wbr\", \"circle\", \"clipPath\", \"defs\", \"ellipse\", \"foreignObject\", \"g\", \"image\", \"line\", \"linearGradient\", \"marker\", \"mask\", \"path\", \"pattern\", \"polygon\", \"polyline\", \"radialGradient\", \"rect\", \"stop\", \"svg\", \"text\", \"textPath\", \"tspan\"].forEach(function (e) {\n  He[e] = He(e);\n});\nvar $e = function () {\n  function e(e, t) {\n    this.rules = e, this.componentId = t, this.isStatic = re(e), Z.registerId(this.componentId + 1);\n  }\n  var t = e.prototype;\n  return t.createStyles = function (e, t, n, r) {\n    var o = r(Ne(this.rules, t, n, r).join(\"\"), \"\"),\n      s = this.componentId + e;\n    n.insertRules(s, s, o);\n  }, t.removeStyles = function (e, t) {\n    t.clearRules(this.componentId + e);\n  }, t.renderStyles = function (e, t, n, r) {\n    e > 2 && Z.registerId(this.componentId + e), this.removeStyles(e, n), this.createStyles(e, t, n, r);\n  }, e;\n}();\nfunction We(e) {\n  for (var t = arguments.length, n = new Array(t > 1 ? t - 1 : 0), o = 1; o < t; o++) {\n    n[o - 1] = arguments[o];\n  }\n  var i = Ce.apply(void 0, [e].concat(n)),\n    a = \"sc-global-\" + xe(JSON.stringify(i)),\n    u = new $e(i, a);\n  function l(e) {\n    var t = fe(),\n      n = me(),\n      o = s(Ge),\n      l = c(t.allocateGSInstance(a)).current;\n    return \"production\" !== process.env.NODE_ENV && r.Children.count(e.children) && console.warn(\"The global style component \" + a + \" was given child JSX. createGlobalStyle does not render children.\"), \"production\" !== process.env.NODE_ENV && i.some(function (e) {\n      return \"string\" == typeof e && -1 !== e.indexOf(\"@import\");\n    }) && console.warn(\"Please do not use @import CSS syntax in createGlobalStyle at this time, as the CSSOM APIs we use in production do not handle it well. Instead, we recommend using a library such as react-helmet to inject a typical <link> meta tag to the stylesheet, or simply embedding it manually in your index.html <head> section for a simpler app.\"), t.server && h(l, e, t, o, n), d(function () {\n      if (!t.server) return h(l, e, t, o, n), function () {\n        return u.removeStyles(l, t);\n      };\n    }, [l, e, t, o, n]), null;\n  }\n  function h(e, t, n, r, o) {\n    if (u.isStatic) u.renderStyles(e, O, n, o);else {\n      var s = v({}, t, {\n        theme: Re(t, r, l.defaultProps)\n      });\n      u.renderStyles(e, s, n, o);\n    }\n  }\n  return \"production\" !== process.env.NODE_ENV && Oe(a), r.memo(l);\n}\nfunction Ue(e) {\n  \"production\" !== process.env.NODE_ENV && \"undefined\" != typeof navigator && \"ReactNative\" === navigator.product && console.warn(\"`keyframes` cannot be used on ReactNative, only on the web. To do animation in ReactNative please use Animated.\");\n  for (var t = arguments.length, n = new Array(t > 1 ? t - 1 : 0), r = 1; r < t; r++) {\n    n[r - 1] = arguments[r];\n  }\n  var o = Ce.apply(void 0, [e].concat(n)).join(\"\"),\n    s = xe(o);\n  return new ve(s, o);\n}\nvar Je = function () {\n    function e() {\n      var e = this;\n      this._emitSheetCSS = function () {\n        var t = e.instance.toString();\n        if (!t) return \"\";\n        var n = q();\n        return \"<style \" + [n && 'nonce=\"' + n + '\"', A + '=\"true\"', 'data-styled-version=\"5.3.6\"'].filter(Boolean).join(\" \") + \">\" + t + \"</style>\";\n      }, this.getStyleTags = function () {\n        return e.sealed ? j(2) : e._emitSheetCSS();\n      }, this.getStyleElement = function () {\n        var t;\n        if (e.sealed) return j(2);\n        var n = ((t = {})[A] = \"\", t[\"data-styled-version\"] = \"5.3.6\", t.dangerouslySetInnerHTML = {\n            __html: e.instance.toString()\n          }, t),\n          o = q();\n        return o && (n.nonce = o), [r.createElement(\"style\", v({}, n, {\n          key: \"sc-0-0\"\n        }))];\n      }, this.seal = function () {\n        e.sealed = !0;\n      }, this.instance = new Z({\n        isServer: !0\n      }), this.sealed = !1;\n    }\n    var t = e.prototype;\n    return t.collectStyles = function (e) {\n      return this.sealed ? j(2) : r.createElement(ye, {\n        sheet: this.instance\n      }, e);\n    }, t.interleaveWithNodeStream = function (e) {\n      return j(3);\n    }, e;\n  }(),\n  Xe = function Xe(e) {\n    var t = r.forwardRef(function (t, n) {\n      var o = s(Ge),\n        i = e.defaultProps,\n        a = Re(t, o, i);\n      return \"production\" !== process.env.NODE_ENV && void 0 === a && console.warn('[withTheme] You are not using a ThemeProvider nor passing a theme prop or a theme in defaultProps in component class \"' + _(e) + '\"'), r.createElement(e, v({}, t, {\n        theme: a,\n        ref: n\n      }));\n    });\n    return y(t, e), t.displayName = \"WithTheme(\" + _(e) + \")\", t;\n  },\n  Ze = function Ze() {\n    return s(Ge);\n  },\n  Ke = {\n    StyleSheet: Z,\n    masterSheet: he\n  };\n\"production\" !== process.env.NODE_ENV && \"undefined\" != typeof navigator && \"ReactNative\" === navigator.product && console.warn(\"It looks like you've imported 'styled-components' on React Native.\\nPerhaps you're looking to import 'styled-components/native'?\\nRead more about this at https://www.styled-components.com/docs/basics#react-native\"), \"production\" !== process.env.NODE_ENV && \"test\" !== process.env.NODE_ENV && \"undefined\" != typeof window && (window[\"__styled-components-init__\"] = window[\"__styled-components-init__\"] || 0, 1 === window[\"__styled-components-init__\"] && console.warn(\"It looks like there are several instances of 'styled-components' initialized in this application. This may cause dynamic styles to not render properly, errors during the rehydration process, a missing theme prop, and makes your application bigger without good reason.\\n\\nSee https://s-c.sh/2BAXzed for more info.\"), window[\"__styled-components-init__\"] += 1);\nexport default He;\nexport { Je as ServerStyleSheet, le as StyleSheetConsumer, ue as StyleSheetContext, ye as StyleSheetManager, Le as ThemeConsumer, Ge as ThemeContext, Fe as ThemeProvider, Ke as __PRIVATE__, We as createGlobalStyle, Ce as css, N as isStyledComponent, Ue as keyframes, Ze as useTheme, C as version, Xe as withTheme };","function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\nmodule.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nmodule.exports = _nonIterableRest, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","export function stringToSlug(str: string) {\n  str = str.replace(/^\\s+|\\s+$/g, ''); // trim\n  str = str.toLowerCase();\n\n  // remove accents, swap ñ for n, etc\n  const from = 'àáäâèéëêìíïîòóöôùúüûñç·/_,:;';\n  const to   = 'aaaaeeeeiiiioooouuuunc------';\n  for (let i=0, l=from.length ; i<l ; i++) {\n      str = str.replace(new RegExp(from.charAt(i), 'g'), to.charAt(i));\n  }\n\n  str = str.replace(/[^a-z0-9 -]/g, '') // remove invalid chars\n      .replace(/\\s+/g, '-') // collapse whitespace and replace by -\n      .replace(/-+/g, '-'); // collapse dashes\n\n  return str;\n}\n\nexport function flatDeep(arr: any[], d = 1): any[] {\n  return d > 0 ? arr.reduce((acc, val) => acc.concat(Array.isArray(val) ? flatDeep(val, d - 1) : val), []) : arr.slice();\n};\n","import React from 'react'\n\nimport './styles.scss'\n\ninterface AsideProps {\n  children?: React.ReactNode\n  title: string\n  type?: 'note' | 'info' | 'danger'\n}\n\nconst Aside: React.FC<AsideProps> = ({children, title, type}) => {\n  const className = type || 'info'\n\n  return (\n    <aside className={`\n      article-aside\n      aside--${className}\n    `}>\n      {title && <h5>{title}</h5>}\n      {children}\n    </aside>\n  )\n}\n\nexport default Aside\n","import \"core-js/modules/es.regexp.flags.js\";\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 * prism-react-renderer:\n * This file has been modified to remove:\n * - globals and window dependency\n * - worker support\n * - highlightAll and other element dependent methods\n * - _.hooks helpers\n * - UMD/node-specific hacks\n * It has also been run through prettier\n */\n\nvar Prism = function () {\n  // Private helper vars\n  var lang = /(?:^|\\s)lang(?:uage)?-([\\w-]+)(?=\\s|$)/i;\n  var uniqueId = 0;\n\n  // The grammar object for plaintext\n  var plainTextGrammar = {};\n  var _ = {\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       * 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       * 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        return obj['__id'];\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;\n        var id;\n        switch (_.util.type(o)) {\n          case 'Object':\n            id = _.util.objId(o);\n            if (visited[id]) {\n              return visited[id];\n            }\n            clone = /** @type {Record<string, any>} */{};\n            visited[id] = clone;\n            for (var key in o) {\n              if (o.hasOwnProperty(key)) {\n                clone[key] = deepClone(o[key], visited);\n              }\n            }\n            return (/** @type {any} */clone\n            );\n          case 'Array':\n            id = _.util.objId(o);\n            if (visited[id]) {\n              return visited[id];\n            }\n            clone = [];\n            visited[id] = clone;\n            /** @type {Array} */ /** @type {any} */o.forEach(function (v, i) {\n              clone[i] = deepClone(v, visited);\n            });\n            return (/** @type {any} */clone\n            );\n          default:\n            return o;\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) {\n          var m = lang.exec(element.className);\n          if (m) {\n            return m[1].toLowerCase();\n          }\n          element = element.parentElement;\n        }\n        return 'none';\n      },\n      /**\n       * Sets the Prism `language-xxxx` class of the given element.\n       *\n       * @param {Element} element\n       * @param {string} language\n       * @returns {void}\n       */\n      setLanguage: function setLanguage(element, language) {\n        // remove all `language-xxxx` classes\n        // (this might leave behind a leading space)\n        element.className = element.className.replace(RegExp(lang, 'gi'), '');\n\n        // add the new `language-xxxx` class\n        // (using `classList` will automatically clean up spaces for us)\n        element.classList.add('language-' + language);\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        while (element) {\n          var classList = element.classList;\n          if (classList.contains(className)) {\n            return true;\n          }\n          if (classList.contains(no)) {\n            return false;\n          }\n          element = element.parentElement;\n        }\n        return !!defaultActivation;\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       * The grammar for plain, unformatted text.\n       */\n      plain: plainTextGrammar,\n      plaintext: plainTextGrammar,\n      text: plainTextGrammar,\n      txt: plainTextGrammar,\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        for (var key in redef) {\n          lang[key] = redef[key];\n        }\n        return lang;\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 || /** @type {any} */_.languages;\n        var grammar = root[inside];\n        /** @type {Grammar} */\n        var ret = {};\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            }\n\n            // Do not insert token which also occur in insert. See #1525\n            if (!insert.hasOwnProperty(token)) {\n              ret[token] = grammar[token];\n            }\n          }\n        }\n        var old = root[inside];\n        root[inside] = ret;\n\n        // Update references in other language definitions\n        _.languages.DFS(_.languages, function (key, value) {\n          if (value === old && key != inside) {\n            this[key] = ret;\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        for (var i in o) {\n          if (o.hasOwnProperty(i)) {\n            callback.call(o, i, o[i], type || i);\n            var property = o[i];\n            var propertyType = _.util.type(property);\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     * 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      _.hooks.run('before-tokenize', env);\n      env.tokens = _.tokenize(env.code, env.grammar);\n      _.hooks.run('after-tokenize', env);\n      return Token.stringify(_.util.encode(env.tokens), env.language);\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      if (rest) {\n        for (var token in rest) {\n          grammar[token] = rest[token];\n        }\n        delete grammar.rest;\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     * @namespace\n     * @memberof Prism\n     * @public\n     */\n    hooks: {\n      all: {},\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       * 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        if (!callbacks || !callbacks.length) {\n          return;\n        }\n        for (var i = 0, callback; callback = callbacks[i++];) {\n          callback(env);\n        }\n      }\n    },\n    Token: Token\n  };\n\n  // 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  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    this.content = content;\n    /**\n     * The alias(es) of the token.\n     *\n     * @type {string|string[]}\n     * @see GrammarToken\n     * @public\n     */\n    this.alias = alias;\n    // Copy of the full string this token was created from\n    this.length = (matchedStr || '').length | 0;\n  }\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  Token.stringify = function stringify(o, language) {\n    if (typeof o == 'string') {\n      return o;\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    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    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    _.hooks.run('wrap', env);\n    var attributes = '';\n    for (var name in env.attributes) {\n      attributes += ' ' + name + '=\"' + (env.attributes[name] || '').replace(/\"/g, '&quot;') + '\"';\n    }\n    return '<' + env.tag + ' class=\"' + env.classes.join(' ') + '\"' + attributes + '>' + env.content + '</' + env.tag + '>';\n  };\n\n  /**\n   * @param {RegExp} pattern\n   * @param {number} pos\n   * @param {string} text\n   * @param {boolean} lookbehind\n   * @returns {RegExpExecArray | null}\n   */\n  function matchPattern(pattern, pos, text, lookbehind) {\n    pattern.lastIndex = pos;\n    var match = pattern.exec(text);\n    if (match && lookbehind && match[1]) {\n      // change the match to remove the text matched by the Prism lookbehind group\n      var lookbehindLength = match[1].length;\n      match.index += lookbehindLength;\n      match[0] = match[0].slice(lookbehindLength);\n    }\n    return match;\n  }\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  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      var patterns = grammar[token];\n      patterns = Array.isArray(patterns) ? patterns : [patterns];\n      for (var j = 0; j < patterns.length; ++j) {\n        if (rematch && rematch.cause == token + ',' + j) {\n          return;\n        }\n        var patternObj = patterns[j];\n        var inside = patternObj.inside;\n        var lookbehind = !!patternObj.lookbehind;\n        var greedy = !!patternObj.greedy;\n        var alias = patternObj.alias;\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\n        /** @type {RegExp} */\n        var pattern = patternObj.pattern || patternObj;\n        for (\n        // 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          var str = currentNode.value;\n          if (tokenList.length > text.length) {\n            // Something went terribly wrong, ABORT, ABORT!\n            return;\n          }\n          if (str instanceof Token) {\n            continue;\n          }\n          var removeCount = 1; // this is the to parameter of removeBetween\n          var match;\n          if (greedy) {\n            match = matchPattern(pattern, pos, text, lookbehind);\n            if (!match || match.index >= text.length) {\n              break;\n            }\n            var from = match.index;\n            var to = match.index + match[0].length;\n            var p = pos;\n\n            // find the node that contains the match\n            p += currentNode.value.length;\n            while (from >= p) {\n              currentNode = currentNode.next;\n              p += currentNode.value.length;\n            }\n            // adjust pos (and p)\n            p -= currentNode.value.length;\n            pos = p;\n\n            // the current node is a Token, then the match starts inside another Token, which is invalid\n            if (currentNode.value instanceof Token) {\n              continue;\n            }\n\n            // find the last node which is affected by this match\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            removeCount--;\n\n            // replace with the new match\n            str = text.slice(pos, p);\n            match.index -= pos;\n          } else {\n            match = matchPattern(pattern, 0, str, lookbehind);\n            if (!match) {\n              continue;\n            }\n          }\n\n          // eslint-disable-next-line no-redeclare\n          var from = match.index;\n          var matchStr = match[0];\n          var before = str.slice(0, from);\n          var after = str.slice(from + matchStr.length);\n          var reach = pos + str.length;\n          if (rematch && reach > rematch.reach) {\n            rematch.reach = reach;\n          }\n          var removeFrom = currentNode.prev;\n          if (before) {\n            removeFrom = addAfter(tokenList, removeFrom, before);\n            pos += before.length;\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          if (after) {\n            addAfter(tokenList, currentNode, after);\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\n            /** @type {RematchOptions} */\n            var nestedRematch = {\n              cause: token + ',' + j,\n              reach: reach\n            };\n            matchGrammar(text, tokenList, grammar, currentNode.prev, pos, nestedRematch);\n\n            // the reach might have been extended because of the rematching\n            if (rematch && nestedRematch.reach > rematch.reach) {\n              rematch.reach = nestedRematch.reach;\n            }\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  function LinkedList() {\n    /** @type {LinkedListNode<T>} */\n    var head = {\n      value: null,\n      prev: null,\n      next: null\n    };\n    /** @type {LinkedListNode<T>} */\n    var tail = {\n      value: null,\n      prev: head,\n      next: null\n    };\n    head.next = tail;\n\n    /** @type {LinkedListNode<T>} */\n    this.head = head;\n    /** @type {LinkedListNode<T>} */\n    this.tail = tail;\n    this.length = 0;\n  }\n\n  /**\n   * Adds a new node with the given value to the list.\n   *\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  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   *\n   * @param {LinkedList<T>} list\n   * @param {LinkedListNode<T>} node\n   * @param {number} count\n   * @template T\n   */\n  function removeRange(list, node, count) {\n    var next = node.next;\n    for (var i = 0; i < count && next !== list.tail; i++) {\n      next = next.next;\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  function toArray(list) {\n    var array = [];\n    var node = list.head.next;\n    while (node !== list.tail) {\n      array.push(node.value);\n      node = node.next;\n    }\n    return array;\n  }\n  return _;\n}();\nvar prism = Prism;\nPrism.default = Prism;\n\n/* This content is auto-generated to include some prismjs language components: */\n\n/* \"prismjs/components/prism-markup\" */\n\nprism.languages.markup = {\n  'comment': {\n    pattern: /<!--(?:(?!<!--)[\\s\\S])*?-->/,\n    greedy: true\n  },\n  'prolog': {\n    pattern: /<\\?[\\s\\S]+?\\?>/,\n    greedy: true\n  },\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/i,\n      'name': /[^\\s<>'\"]+/\n    }\n  },\n  'cdata': {\n    pattern: /<!\\[CDATA\\[[\\s\\S]*?\\]\\]>/i,\n    greedy: true\n  },\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      'special-attr': [],\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(/(<__[^>]*>)(?:<!\\[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});\nObject.defineProperty(prism.languages.markup.tag, 'addAttribute', {\n  /**\n   * Adds an pattern to highlight languages embedded in HTML attributes.\n   *\n   * An example of an inlined language is CSS with `style` attributes.\n   *\n   * @param {string} attrName 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   * addAttribute('style', 'css');\n   */\n  value: function value(attrName, lang) {\n    prism.languages.markup.tag.inside['special-attr'].push({\n      pattern: RegExp(/(^|[\"'\\s])/.source + '(?:' + attrName + ')' + /\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s'\">=]+(?=[\\s>]))/.source, 'i'),\n      lookbehind: true,\n      inside: {\n        'attr-name': /^[^\\s=]+/,\n        'attr-value': {\n          pattern: /=[\\s\\S]+/,\n          inside: {\n            'value': {\n              pattern: /(^=\\s*([\"']|(?![\"'])))\\S[\\s\\S]*(?=\\2$)/,\n              lookbehind: true,\n              alias: [lang, 'language-' + lang],\n              inside: prism.languages[lang]\n            },\n            'punctuation': [{\n              pattern: /^=/,\n              alias: 'attr-equals'\n            }, /\"|'/]\n          }\n        }\n      }\n    });\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/* \"prismjs/components/prism-bash\" */\n\n(function (Prism) {\n  // $ set | grep '^[A-Z][^[:space:]]*=' | cut -d= -f1 | tr '\\n' '|'\n  // + LC_ALL, RANDOM, REPLY, SECONDS.\n  // + make sure PS1..4 are here as they are not always set,\n  // - some useless things.\n  var envVars = '\\\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_CURRENT_DESKTOP|XDG_DATA_DIRS|XDG_GREETER_DATA_DIR|XDG_MENU_PREFIX|XDG_RUNTIME_DIR|XDG_SEAT|XDG_SEAT_PATH|XDG_SESSION_DESKTOP|XDG_SESSION_ID|XDG_SESSION_PATH|XDG_SESSION_TYPE|XDG_VTNR|XMODIFIERS)\\\\b';\n  var commandAfterHeredoc = {\n    pattern: /(^([\"']?)\\w+\\2)[ \\t]+\\S.*/,\n    lookbehind: true,\n    alias: 'punctuation',\n    // this looks reasonably well in all themes\n    inside: null // see below\n  };\n\n  var insideString = {\n    'bash': commandAfterHeredoc,\n    'environment': {\n      pattern: RegExp('\\\\$' + envVars),\n      alias: 'constant'\n    },\n    'variable': [\n    // [0]: Arithmetic Environment\n    {\n      pattern: /\\$?\\(\\([\\s\\S]+?\\)\\)/,\n      greedy: true,\n      inside: {\n        // If there is a $ sign at the beginning highlight $(( and )) as variable\n        'variable': [{\n          pattern: /(^\\$\\(\\([\\s\\S]+)\\)\\)/,\n          lookbehind: true\n        }, /^\\$\\(\\(/],\n        'number': /\\b0x[\\dA-Fa-f]+\\b|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:[Ee]-?\\d+)?/,\n        // Operators according to https://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic\n        'operator': /--|\\+\\+|\\*\\*=?|<<=?|>>=?|&&|\\|\\||[=!+\\-*/%<>^&|]=?|[?~:]/,\n        // If there is no $ sign at the beginning highlight (( and )) as punctuation\n        'punctuation': /\\(\\(?|\\)\\)?|,|;/\n      }\n    },\n    // [1]: Command Substitution\n    {\n      pattern: /\\$\\((?:\\([^)]+\\)|[^()])+\\)|`[^`]+`/,\n      greedy: true,\n      inside: {\n        'variable': /^\\$\\(|^`|\\)$|`$/\n      }\n    },\n    // [2]: Brace expansion\n    {\n      pattern: /\\$\\{[^}]+\\}/,\n      greedy: true,\n      inside: {\n        'operator': /:[-=?+]?|[!\\/]|##?|%%?|\\^\\^?|,,?/,\n        'punctuation': /[\\[\\]]/,\n        'environment': {\n          pattern: RegExp('(\\\\{)' + envVars),\n          lookbehind: true,\n          alias: 'constant'\n        }\n      }\n    }, /\\$(?:\\w+|[#?*!@$])/],\n    // Escape sequences from echo and printf's manuals, and escaped quotes.\n    'entity': /\\\\(?:[abceEfnrtv\\\\\"]|O?[0-7]{1,3}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{1,2})/\n  };\n  Prism.languages.bash = {\n    'shebang': {\n      pattern: /^#!\\s*\\/.*/,\n      alias: 'important'\n    },\n    'comment': {\n      pattern: /(^|[^\"{\\\\$])#.*/,\n      lookbehind: true\n    },\n    'function-name': [\n    // a) function foo {\n    // b) foo() {\n    // c) function foo() {\n    // but not “foo {”\n    {\n      // a) and c)\n      pattern: /(\\bfunction\\s+)[\\w-]+(?=(?:\\s*\\(?:\\s*\\))?\\s*\\{)/,\n      lookbehind: true,\n      alias: 'function'\n    }, {\n      // b)\n      pattern: /\\b[\\w-]+(?=\\s*\\(\\s*\\)\\s*\\{)/,\n      alias: 'function'\n    }],\n    // Highlight variable names as variables in for and select beginnings.\n    'for-or-select': {\n      pattern: /(\\b(?:for|select)\\s+)\\w+(?=\\s+in\\s)/,\n      alias: 'variable',\n      lookbehind: true\n    },\n    // Highlight variable names as variables in the left-hand part\n    // of assignments (“=” and “+=”).\n    'assign-left': {\n      pattern: /(^|[\\s;|&]|[<>]\\()\\w+(?=\\+?=)/,\n      inside: {\n        'environment': {\n          pattern: RegExp('(^|[\\\\s;|&]|[<>]\\\\()' + envVars),\n          lookbehind: true,\n          alias: 'constant'\n        }\n      },\n      alias: 'variable',\n      lookbehind: true\n    },\n    'string': [\n    // Support for Here-documents https://en.wikipedia.org/wiki/Here_document\n    {\n      pattern: /((?:^|[^<])<<-?\\s*)(\\w+)\\s[\\s\\S]*?(?:\\r?\\n|\\r)\\2/,\n      lookbehind: true,\n      greedy: true,\n      inside: insideString\n    },\n    // Here-document with quotes around the tag\n    // → No expansion (so no “inside”).\n    {\n      pattern: /((?:^|[^<])<<-?\\s*)([\"'])(\\w+)\\2\\s[\\s\\S]*?(?:\\r?\\n|\\r)\\3/,\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        'bash': commandAfterHeredoc\n      }\n    },\n    // “Normal” string\n    {\n      // https://www.gnu.org/software/bash/manual/html_node/Double-Quotes.html\n      pattern: /(^|[^\\\\](?:\\\\\\\\)*)\"(?:\\\\[\\s\\S]|\\$\\([^)]+\\)|\\$(?!\\()|`[^`]+`|[^\"\\\\`$])*\"/,\n      lookbehind: true,\n      greedy: true,\n      inside: insideString\n    }, {\n      // https://www.gnu.org/software/bash/manual/html_node/Single-Quotes.html\n      pattern: /(^|[^$\\\\])'[^']*'/,\n      lookbehind: true,\n      greedy: true\n    }, {\n      // https://www.gnu.org/software/bash/manual/html_node/ANSI_002dC-Quoting.html\n      pattern: /\\$'(?:[^'\\\\]|\\\\[\\s\\S])*'/,\n      greedy: true,\n      inside: {\n        'entity': insideString.entity\n      }\n    }],\n    'environment': {\n      pattern: RegExp('\\\\$?' + envVars),\n      alias: 'constant'\n    },\n    'variable': insideString.variable,\n    'function': {\n      pattern: /(^|[\\s;|&]|[<>]\\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cat|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|composer|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|docker|docker-compose|du|egrep|eject|env|ethtool|expand|expect|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|git|gparted|grep|groupadd|groupdel|groupmod|groups|grub-mkconfig|gzip|halt|head|hg|history|host|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|ip|jobs|join|kill|killall|less|link|ln|locate|logname|logrotate|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mmv|more|most|mount|mtools|mtr|mutt|mv|nano|nc|netstat|nice|nl|node|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|podman|podman-compose|popd|pr|printcap|printenv|ps|pushd|pv|quota|quotacheck|quotactl|ram|rar|rcp|reboot|remsync|rename|renice|rev|rm|rmdir|rpm|rsync|scp|screen|sdiff|sed|sendmail|seq|service|sftp|sh|shellcheck|shuf|shutdown|sleep|slocate|sort|split|ssh|stat|strace|su|sudo|sum|suspend|swapon|sync|tac|tail|tar|tee|time|timeout|top|touch|tr|traceroute|tsort|tty|umount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vcpkg|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|zip|zsh|zypper)(?=$|[)\\s;|&])/,\n      lookbehind: true\n    },\n    'keyword': {\n      pattern: /(^|[\\s;|&]|[<>]\\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\\s;|&])/,\n      lookbehind: true\n    },\n    // https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html\n    'builtin': {\n      pattern: /(^|[\\s;|&]|[<>]\\()(?:\\.|:|alias|bind|break|builtin|caller|cd|command|continue|declare|echo|enable|eval|exec|exit|export|getopts|hash|help|let|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|set|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\\s;|&])/,\n      lookbehind: true,\n      // Alias added to make those easier to distinguish from strings.\n      alias: 'class-name'\n    },\n    'boolean': {\n      pattern: /(^|[\\s;|&]|[<>]\\()(?:false|true)(?=$|[)\\s;|&])/,\n      lookbehind: true\n    },\n    'file-descriptor': {\n      pattern: /\\B&\\d\\b/,\n      alias: 'important'\n    },\n    'operator': {\n      // Lots of redirections here, but not just that.\n      pattern: /\\d?<>|>\\||\\+=|=[=~]?|!=?|<<[<-]?|[&\\d]?>>|\\d[<>]&?|[<>][&=]?|&[>&]?|\\|[&|]?/,\n      inside: {\n        'file-descriptor': {\n          pattern: /^\\d/,\n          alias: 'important'\n        }\n      }\n    },\n    'punctuation': /\\$?\\(\\(?|\\)\\)?|\\.\\.|[{}[\\];\\\\]/,\n    'number': {\n      pattern: /(^|\\s)(?:[1-9]\\d*|0)(?:[.,]\\d+)?\\b/,\n      lookbehind: true\n    }\n  };\n  commandAfterHeredoc.inside = Prism.languages.bash;\n  /* Patterns in command substitution. */\n\n  var toBeCopied = ['comment', 'function-name', 'for-or-select', 'assign-left', 'string', 'environment', 'function', 'keyword', 'builtin', 'boolean', 'file-descriptor', 'operator', 'punctuation', 'number'];\n  var inside = insideString.variable[1].inside;\n  for (var i = 0; i < toBeCopied.length; i++) {\n    inside[toBeCopied[i]] = Prism.languages.bash[toBeCopied[i]];\n  }\n  Prism.languages.shell = Prism.languages.bash;\n})(prism);\n/* \"prismjs/components/prism-clike\" */\n\nprism.languages.clike = {\n  'comment': [{\n    pattern: /(^|[^\\\\])\\/\\*[\\s\\S]*?(?:\\*\\/|$)/,\n    lookbehind: true,\n    greedy: 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|extends|implements|instanceof|interface|new|trait)\\s+|\\bcatch\\s+\\()[\\w.\\\\]+/i,\n    lookbehind: true,\n    inside: {\n      'punctuation': /[.\\\\]/\n    }\n  },\n  'keyword': /\\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\\b/,\n  'boolean': /\\b(?:false|true)\\b/,\n  'function': /\\b\\w+(?=\\()/,\n  'number': /\\b0x[\\da-f]+\\b|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e[+-]?\\d+)?/i,\n  'operator': /[<>]=?|[!=]=?=?|--?|\\+\\+?|&&?|\\|\\|?|[?*/~^%]/,\n  'punctuation': /[{}[\\];(),.:]/\n};\n/* \"prismjs/components/prism-c\" */\n\nprism.languages.c = prism.languages.extend('clike', {\n  'comment': {\n    pattern: /\\/\\/(?:[^\\r\\n\\\\]|\\\\(?:\\r\\n?|\\n|(?![\\r\\n])))*|\\/\\*[\\s\\S]*?(?:\\*\\/|$)/,\n    greedy: true\n  },\n  'string': {\n    // https://en.cppreference.com/w/c/language/string_literal\n    pattern: /\"(?:\\\\(?:\\r\\n|[\\s\\S])|[^\"\\\\\\r\\n])*\"/,\n    greedy: true\n  },\n  'class-name': {\n    pattern: /(\\b(?:enum|struct)\\s+(?:__attribute__\\s*\\(\\([\\s\\S]*?\\)\\)\\s*)?)\\w+|\\b[a-z]\\w*_t\\b/,\n    lookbehind: true\n  },\n  'keyword': /\\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\\b/,\n  'function': /\\b[a-z_]\\w*(?=\\s*\\()/i,\n  'number': /(?:\\b0x(?:[\\da-f]+(?:\\.[\\da-f]*)?|\\.[\\da-f]+)(?:p[+-]?\\d+)?|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e[+-]?\\d+)?)[ful]{0,4}/i,\n  'operator': />>=?|<<=?|->|([-+&|:])\\1|[?:~]|[-+*/%&|^!=<>]=?/\n});\nprism.languages.insertBefore('c', 'string', {\n  'char': {\n    // https://en.cppreference.com/w/c/language/character_constant\n    pattern: /'(?:\\\\(?:\\r\\n|[\\s\\S])|[^'\\\\\\r\\n]){0,32}'/,\n    greedy: true\n  }\n});\nprism.languages.insertBefore('c', 'string', {\n  'macro': {\n    // allow for multiline macro definitions\n    // spaces after the # character compile fine with gcc\n    pattern: /(^[\\t ]*)#\\s*[a-z](?:[^\\r\\n\\\\/]|\\/(?!\\*)|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/|\\\\(?:\\r\\n|[\\s\\S]))*/im,\n    lookbehind: true,\n    greedy: true,\n    alias: 'property',\n    inside: {\n      'string': [{\n        // highlight the path of the include statement as a string\n        pattern: /^(#\\s*include\\s*)<[^>]+>/,\n        lookbehind: true\n      }, prism.languages.c['string']],\n      'char': prism.languages.c['char'],\n      'comment': prism.languages.c['comment'],\n      'macro-name': [{\n        pattern: /(^#\\s*define\\s+)\\w+\\b(?!\\()/i,\n        lookbehind: true\n      }, {\n        pattern: /(^#\\s*define\\s+)\\w+\\b(?=\\()/i,\n        lookbehind: true,\n        alias: 'function'\n      }],\n      // highlight macro directives as keywords\n      'directive': {\n        pattern: /^(#\\s*)[a-z]+/,\n        lookbehind: true,\n        alias: 'keyword'\n      },\n      'directive-hash': /^#/,\n      'punctuation': /##|\\\\(?=[\\r\\n])/,\n      'expression': {\n        pattern: /\\S[\\s\\S]*/,\n        inside: prism.languages.c\n      }\n    }\n  }\n});\nprism.languages.insertBefore('c', 'function', {\n  // highlight predefined macros as constants\n  'constant': /\\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\\b/\n});\ndelete prism.languages.c['boolean'];\n/* \"prismjs/components/prism-cpp\" */\n\n(function (Prism) {\n  var keyword = /\\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\\b/;\n  var modName = /\\b(?!<keyword>)\\w+(?:\\s*\\.\\s*\\w+)*\\b/.source.replace(/<keyword>/g, function () {\n    return keyword.source;\n  });\n  Prism.languages.cpp = Prism.languages.extend('c', {\n    'class-name': [{\n      pattern: RegExp(/(\\b(?:class|concept|enum|struct|typename)\\s+)(?!<keyword>)\\w+/.source.replace(/<keyword>/g, function () {\n        return keyword.source;\n      })),\n      lookbehind: true\n    },\n    // This is intended to capture the class name of method implementations like:\n    //   void foo::bar() const {}\n    // However! The `foo` in the above example could also be a namespace, so we only capture the class name if\n    // it starts with an uppercase letter. This approximation should give decent results.\n    /\\b[A-Z]\\w*(?=\\s*::\\s*\\w+\\s*\\()/,\n    // This will capture the class name before destructors like:\n    //   Foo::~Foo() {}\n    /\\b[A-Z_]\\w*(?=\\s*::\\s*~\\w+\\s*\\()/i,\n    // This also intends to capture the class name of method implementations but here the class has template\n    // parameters, so it can't be a namespace (until C++ adds generic namespaces).\n    /\\b\\w+(?=\\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\\s*::\\s*\\w+\\s*\\()/],\n    'keyword': keyword,\n    'number': {\n      pattern: /(?:\\b0b[01']+|\\b0x(?:[\\da-f']+(?:\\.[\\da-f']*)?|\\.[\\da-f']+)(?:p[+-]?[\\d']+)?|(?:\\b[\\d']+(?:\\.[\\d']*)?|\\B\\.[\\d']+)(?:e[+-]?[\\d']+)?)[ful]{0,4}/i,\n      greedy: true\n    },\n    'operator': />>=?|<<=?|->|--|\\+\\+|&&|\\|\\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\\b/,\n    'boolean': /\\b(?:false|true)\\b/\n  });\n  Prism.languages.insertBefore('cpp', 'string', {\n    'module': {\n      // https://en.cppreference.com/w/cpp/language/modules\n      pattern: RegExp(/(\\b(?:import|module)\\s+)/.source + '(?:' +\n      // header-name\n      /\"(?:\\\\(?:\\r\\n|[\\s\\S])|[^\"\\\\\\r\\n])*\"|<[^<>\\r\\n]*>/.source + '|' +\n      // module name or partition or both\n      /<mod-name>(?:\\s*:\\s*<mod-name>)?|:\\s*<mod-name>/.source.replace(/<mod-name>/g, function () {\n        return modName;\n      }) + ')'),\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        'string': /^[<\"][\\s\\S]+/,\n        'operator': /:/,\n        'punctuation': /\\./\n      }\n    },\n    'raw-string': {\n      pattern: /R\"([^()\\\\ ]{0,16})\\([\\s\\S]*?\\)\\1\"/,\n      alias: 'string',\n      greedy: true\n    }\n  });\n  Prism.languages.insertBefore('cpp', 'keyword', {\n    'generic-function': {\n      pattern: /\\b(?!operator\\b)[a-z_]\\w*\\s*<(?:[^<>]|<[^<>]*>)*>(?=\\s*\\()/i,\n      inside: {\n        'function': /^\\w+/,\n        'generic': {\n          pattern: /<[\\s\\S]+/,\n          alias: 'class-name',\n          inside: Prism.languages.cpp\n        }\n      }\n    }\n  });\n  Prism.languages.insertBefore('cpp', 'operator', {\n    'double-colon': {\n      pattern: /::/,\n      alias: 'punctuation'\n    }\n  });\n  Prism.languages.insertBefore('cpp', 'class-name', {\n    // the base clause is an optional list of parent classes\n    // https://en.cppreference.com/w/cpp/language/class\n    'base-clause': {\n      pattern: /(\\b(?:class|struct)\\s+\\w+\\s*:\\s*)[^;{}\"'\\s]+(?:\\s+[^;{}\"'\\s]+)*(?=\\s*[;{])/,\n      lookbehind: true,\n      greedy: true,\n      inside: Prism.languages.extend('cpp', {})\n    }\n  });\n  Prism.languages.insertBefore('inside', 'double-colon', {\n    // All untokenized words that are not namespaces should be class names\n    'class-name': /\\b[a-z_]\\w*\\b(?!\\s*::)/i\n  }, Prism.languages.cpp['base-clause']);\n})(prism);\n/* \"prismjs/components/prism-css\" */\n\n(function (Prism) {\n  var string = /(?:\"(?:\\\\(?:\\r\\n|[\\s\\S])|[^\"\\\\\\r\\n])*\"|'(?:\\\\(?:\\r\\n|[\\s\\S])|[^'\\\\\\r\\n])*')/;\n  Prism.languages.css = {\n    'comment': /\\/\\*[\\s\\S]*?\\*\\//,\n    'atrule': {\n      pattern: /@[\\w-](?:[^;{\\s]|\\s+(?![\\s{]))*(?:;|(?=\\s*\\{))/,\n      inside: {\n        'rule': /^@[\\w-]+/,\n        'selector-function-argument': {\n          pattern: /(\\bselector\\s*\\(\\s*(?![\\s)]))(?:[^()\\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': {\n      pattern: RegExp('(^|[{}\\\\s])[^{}\\\\s](?:[^{};\"\\'\\\\s]|\\\\s+(?![\\\\s{])|' + string.source + ')*(?=\\\\s*\\\\{)'),\n      lookbehind: true\n    },\n    'string': {\n      pattern: string,\n      greedy: true\n    },\n    'property': {\n      pattern: /(^|[^-\\w\\xA0-\\uFFFF])(?!\\s)[-_a-z\\xA0-\\uFFFF](?:(?!\\s)[-\\w\\xA0-\\uFFFF])*(?=\\s*:)/i,\n      lookbehind: true\n    },\n    'important': /!important\\b/i,\n    'function': {\n      pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\\()/i,\n      lookbehind: true\n    },\n    'punctuation': /[(){};:,]/\n  };\n  Prism.languages.css['atrule'].inside.rest = Prism.languages.css;\n  var markup = Prism.languages.markup;\n  if (markup) {\n    markup.tag.addInlined('style', 'css');\n    markup.tag.addAttribute('style', 'css');\n  }\n})(prism);\n/* \"prismjs/components/prism-css-extras\" */\n\n(function (Prism) {\n  var string = /(\"|')(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/;\n  var selectorInside;\n  Prism.languages.css.selector = {\n    pattern: Prism.languages.css.selector.pattern,\n    lookbehind: true,\n    inside: selectorInside = {\n      'pseudo-element': /:(?:after|before|first-letter|first-line|selection)|::[-\\w]+/,\n      'pseudo-class': /:[-\\w]+/,\n      'class': /\\.[-\\w]+/,\n      'id': /#[-\\w]+/,\n      'attribute': {\n        pattern: RegExp('\\\\[(?:[^[\\\\]\"\\']|' + string.source + ')*\\\\]'),\n        greedy: true,\n        inside: {\n          'punctuation': /^\\[|\\]$/,\n          'case-sensitivity': {\n            pattern: /(\\s)[si]$/i,\n            lookbehind: true,\n            alias: 'keyword'\n          },\n          'namespace': {\n            pattern: /^(\\s*)(?:(?!\\s)[-*\\w\\xA0-\\uFFFF])*\\|(?!=)/,\n            lookbehind: true,\n            inside: {\n              'punctuation': /\\|$/\n            }\n          },\n          'attr-name': {\n            pattern: /^(\\s*)(?:(?!\\s)[-\\w\\xA0-\\uFFFF])+/,\n            lookbehind: true\n          },\n          'attr-value': [string, {\n            pattern: /(=\\s*)(?:(?!\\s)[-\\w\\xA0-\\uFFFF])+(?=\\s*$)/,\n            lookbehind: true\n          }],\n          'operator': /[|~*^$]?=/\n        }\n      },\n      'n-th': [{\n        pattern: /(\\(\\s*)[+-]?\\d*[\\dn](?:\\s*[+-]\\s*\\d+)?(?=\\s*\\))/,\n        lookbehind: true,\n        inside: {\n          'number': /[\\dn]+/,\n          'operator': /[+-]/\n        }\n      }, {\n        pattern: /(\\(\\s*)(?:even|odd)(?=\\s*\\))/i,\n        lookbehind: true\n      }],\n      'combinator': />|\\+|~|\\|\\|/,\n      // the `tag` token has been existed and removed.\n      // because we can't find a perfect tokenize to match it.\n      // if you want to add it, please read https://github.com/PrismJS/prism/pull/2373 first.\n      'punctuation': /[(),]/\n    }\n  };\n  Prism.languages.css['atrule'].inside['selector-function-argument'].inside = selectorInside;\n  Prism.languages.insertBefore('css', 'property', {\n    'variable': {\n      pattern: /(^|[^-\\w\\xA0-\\uFFFF])--(?!\\s)[-_a-z\\xA0-\\uFFFF](?:(?!\\s)[-\\w\\xA0-\\uFFFF])*/i,\n      lookbehind: true\n    }\n  });\n  var unit = {\n    pattern: /(\\b\\d+)(?:%|[a-z]+(?![\\w-]))/,\n    lookbehind: true\n  }; // 123 -123 .123 -.123 12.3 -12.3\n\n  var number = {\n    pattern: /(^|[^\\w.-])-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)/,\n    lookbehind: true\n  };\n  Prism.languages.insertBefore('css', 'function', {\n    'operator': {\n      pattern: /(\\s)[+\\-*\\/](?=\\s)/,\n      lookbehind: true\n    },\n    // CAREFUL!\n    // Previewers and Inline color use hexcode and color.\n    'hexcode': {\n      pattern: /\\B#[\\da-f]{3,8}\\b/i,\n      alias: 'color'\n    },\n    'color': [{\n      pattern: /(^|[^\\w-])(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Transparent|Turquoise|Violet|Wheat|White|WhiteSmoke|Yellow|YellowGreen)(?![\\w-])/i,\n      lookbehind: true\n    }, {\n      pattern: /\\b(?:hsl|rgb)\\(\\s*\\d{1,3}\\s*,\\s*\\d{1,3}%?\\s*,\\s*\\d{1,3}%?\\s*\\)\\B|\\b(?:hsl|rgb)a\\(\\s*\\d{1,3}\\s*,\\s*\\d{1,3}%?\\s*,\\s*\\d{1,3}%?\\s*,\\s*(?:0|0?\\.\\d+|1)\\s*\\)\\B/i,\n      inside: {\n        'unit': unit,\n        'number': number,\n        'function': /[\\w-]+(?=\\()/,\n        'punctuation': /[(),]/\n      }\n    }],\n    // it's important that there is no boundary assertion after the hex digits\n    'entity': /\\\\[\\da-f]{1,8}/i,\n    'unit': unit,\n    'number': number\n  });\n})(prism);\n/* \"prismjs/components/prism-javascript\" */\n\nprism.languages.javascript = prism.languages.extend('clike', {\n  'class-name': [prism.languages.clike['class-name'], {\n    pattern: /(^|[^$\\w\\xA0-\\uFFFF])(?!\\s)[_$A-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*(?=\\.(?:constructor|prototype))/,\n    lookbehind: true\n  }],\n  'keyword': [{\n    pattern: /((?:^|\\})\\s*)catch\\b/,\n    lookbehind: true\n  }, {\n    pattern: /(^|[^.]|\\.\\.\\.\\s*)\\b(?:as|assert(?=\\s*\\{)|async(?=\\s*(?:function\\b|\\(|[$\\w\\xA0-\\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\\s*(?:\\{|$))|for|from(?=\\s*(?:['\"]|$))|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  // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)\n  'function': /#?(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*(?=\\s*(?:\\.\\s*(?:apply|bind|call)\\s*)?\\()/,\n  'number': {\n    pattern: RegExp(/(^|[^\\w$])/.source + '(?:' + (\n    // constant\n    /NaN|Infinity/.source + '|' +\n    // binary integer\n    /0[bB][01]+(?:_[01]+)*n?/.source + '|' +\n    // octal integer\n    /0[oO][0-7]+(?:_[0-7]+)*n?/.source + '|' +\n    // hexadecimal integer\n    /0[xX][\\dA-Fa-f]+(?:_[\\dA-Fa-f]+)*n?/.source + '|' +\n    // decimal bigint\n    /\\d+(?:_\\d+)*n/.source + '|' +\n    // decimal number (integer or float) but no bigint\n    /(?:\\d+(?:_\\d+)*(?:\\.(?:\\d+(?:_\\d+)*)?)?|\\.\\d+(?:_\\d+)*)(?:[Ee][+-]?\\d+(?:_\\d+)*)?/.source) + ')' + /(?![\\w$])/.source),\n    lookbehind: true\n  },\n  'operator': /--|\\+\\+|\\*\\*=?|=>|&&=?|\\|\\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\\.{3}|\\?\\?=?|\\?\\.?|[~:]/\n});\nprism.languages.javascript['class-name'][0].pattern = /(\\b(?:class|extends|implements|instanceof|interface|new)\\s+)[\\w.\\\\]+/;\nprism.languages.insertBefore('javascript', 'keyword', {\n  'regex': {\n    // eslint-disable-next-line regexp/no-dupe-characters-character-class\n    pattern: /((?:^|[^$\\w\\xA0-\\uFFFF.\"'\\])\\s]|\\b(?:return|yield))\\s*)\\/(?:\\[(?:[^\\]\\\\\\r\\n]|\\\\.)*\\]|\\\\.|[^/\\\\\\[\\r\\n])+\\/[dgimyus]{0,7}(?=(?:\\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-delimiter': /^\\/|\\/$/,\n      'regex-flags': /^[a-z]+$/\n    }\n  },\n  // This must be declared before keyword because we use \"function\" inside the look-forward\n  'function-variable': {\n    pattern: /#?(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*(?=\\s*[=:]\\s*(?:async\\s*)?(?:\\bfunction\\b|(?:\\((?:[^()]|\\([^()]*\\))*\\)|(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*)\\s*=>))/,\n    alias: 'function'\n  },\n  'parameter': [{\n    pattern: /(function(?:\\s+(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*)?\\s*\\(\\s*)(?!\\s)(?:[^()\\s]|\\s+(?![\\s)])|\\([^()]*\\))+(?=\\s*\\))/,\n    lookbehind: true,\n    inside: prism.languages.javascript\n  }, {\n    pattern: /(^|[^$\\w\\xA0-\\uFFFF])(?!\\s)[_$a-z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*(?=\\s*=>)/i,\n    lookbehind: true,\n    inside: prism.languages.javascript\n  }, {\n    pattern: /(\\(\\s*)(?!\\s)(?:[^()\\s]|\\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]))(?:(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*\\s*)\\(\\s*|\\]\\s*\\(\\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  'hashbang': {\n    pattern: /^#!.*/,\n    greedy: true,\n    alias: 'comment'\n  },\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  'string-property': {\n    pattern: /((?:^|[,{])[ \\t]*)([\"'])(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\2)[^\\\\\\r\\n])*\\2(?=\\s*:)/m,\n    lookbehind: true,\n    greedy: true,\n    alias: 'property'\n  }\n});\nprism.languages.insertBefore('javascript', 'operator', {\n  'literal-property': {\n    pattern: /((?:^|[,{])[ \\t]*)(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*(?=\\s*:)/m,\n    lookbehind: true,\n    alias: 'property'\n  }\n});\nif (prism.languages.markup) {\n  prism.languages.markup.tag.addInlined('script', 'javascript'); // add attribute support for all DOM events.\n  // https://developer.mozilla.org/en-US/docs/Web/Events#Standard_events\n\n  prism.languages.markup.tag.addAttribute(/on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source, 'javascript');\n}\nprism.languages.js = prism.languages.javascript;\n/* \"prismjs/components/prism-coffeescript\" */\n\n(function (Prism) {\n  // Ignore comments starting with { to privilege string interpolation highlighting\n  var comment = /#(?!\\{).+/;\n  var interpolation = {\n    pattern: /#\\{[^}]+\\}/,\n    alias: 'variable'\n  };\n  Prism.languages.coffeescript = Prism.languages.extend('javascript', {\n    'comment': comment,\n    'string': [\n    // Strings are multiline\n    {\n      pattern: /'(?:\\\\[\\s\\S]|[^\\\\'])*'/,\n      greedy: true\n    }, {\n      // Strings are multiline\n      pattern: /\"(?:\\\\[\\s\\S]|[^\\\\\"])*\"/,\n      greedy: true,\n      inside: {\n        'interpolation': interpolation\n      }\n    }],\n    'keyword': /\\b(?:and|break|by|catch|class|continue|debugger|delete|do|each|else|extend|extends|false|finally|for|if|in|instanceof|is|isnt|let|loop|namespace|new|no|not|null|of|off|on|or|own|return|super|switch|then|this|throw|true|try|typeof|undefined|unless|until|when|while|window|with|yes|yield)\\b/,\n    'class-member': {\n      pattern: /@(?!\\d)\\w+/,\n      alias: 'variable'\n    }\n  });\n  Prism.languages.insertBefore('coffeescript', 'comment', {\n    'multiline-comment': {\n      pattern: /###[\\s\\S]+?###/,\n      alias: 'comment'\n    },\n    // Block regexp can contain comments and interpolation\n    'block-regex': {\n      pattern: /\\/{3}[\\s\\S]*?\\/{3}/,\n      alias: 'regex',\n      inside: {\n        'comment': comment,\n        'interpolation': interpolation\n      }\n    }\n  });\n  Prism.languages.insertBefore('coffeescript', 'string', {\n    'inline-javascript': {\n      pattern: /`(?:\\\\[\\s\\S]|[^\\\\`])*`/,\n      inside: {\n        'delimiter': {\n          pattern: /^`|`$/,\n          alias: 'punctuation'\n        },\n        'script': {\n          pattern: /[\\s\\S]+/,\n          alias: 'language-javascript',\n          inside: Prism.languages.javascript\n        }\n      }\n    },\n    // Block strings\n    'multiline-string': [{\n      pattern: /'''[\\s\\S]*?'''/,\n      greedy: true,\n      alias: 'string'\n    }, {\n      pattern: /\"\"\"[\\s\\S]*?\"\"\"/,\n      greedy: true,\n      alias: 'string',\n      inside: {\n        interpolation: interpolation\n      }\n    }]\n  });\n  Prism.languages.insertBefore('coffeescript', 'keyword', {\n    // Object property\n    'property': /(?!\\d)\\w+(?=\\s*:(?!:))/\n  });\n  delete Prism.languages.coffeescript['template-string'];\n  Prism.languages.coffee = Prism.languages.coffeescript;\n})(prism);\n/* \"prismjs/components/prism-yaml\" */\n\n(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]*(?:$|,|\\]|\\}|(?:[\\r\\n]\\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  Prism.languages.yaml = {\n    'scalar': {\n      pattern: RegExp(/([\\-:]\\s*(?:\\s<<prop>>[ \\t]+)?[|>])[ \\t]*(?:((?:\\r?\\n|\\r)[ \\t]+)\\S[^\\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(/false|true/.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);\n/* \"prismjs/components/prism-markdown\" */\n\n(function (Prism) {\n  // Allow only one line break\n  var inner = /(?:\\\\.|[^\\\\\\n\\r]|(?:\\n|\\r\\n?)(?![\\r\\n]))/.source;\n  /**\n   * This function is intended for the creation of the bold or italic pattern.\n   *\n   * This also adds a lookbehind group to the given pattern to ensure that the pattern is not backslash-escaped.\n   *\n   * _Note:_ Keep in mind that this adds a capturing group.\n   *\n   * @param {string} pattern\n   * @returns {RegExp}\n   */\n\n  function createInline(pattern) {\n    pattern = pattern.replace(/<inner>/g, function () {\n      return inner;\n    });\n    return RegExp(/((?:^|[^\\\\])(?:\\\\{2})*)/.source + '(?:' + pattern + ')');\n  }\n  var tableCell = /(?:\\\\.|``(?:[^`\\r\\n]|`(?!`))+``|`[^`\\r\\n]+`|[^\\\\|\\r\\n`])+/.source;\n  var tableRow = /\\|?__(?:\\|__)+\\|?(?:(?:\\n|\\r\\n?)|(?![\\s\\S]))/.source.replace(/__/g, function () {\n    return tableCell;\n  });\n  var tableLine = /\\|?[ \\t]*:?-{3,}:?[ \\t]*(?:\\|[ \\t]*:?-{3,}:?[ \\t]*)+\\|?(?:\\n|\\r\\n?)/.source;\n  Prism.languages.markdown = Prism.languages.extend('markup', {});\n  Prism.languages.insertBefore('markdown', 'prolog', {\n    'front-matter-block': {\n      pattern: /(^(?:\\s*[\\r\\n])?)---(?!.)[\\s\\S]*?[\\r\\n]---(?!.)/,\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        'punctuation': /^---|---$/,\n        'front-matter': {\n          pattern: /\\S+(?:\\s+\\S+)*/,\n          alias: ['yaml', 'language-yaml'],\n          inside: Prism.languages.yaml\n        }\n      }\n    },\n    'blockquote': {\n      // > ...\n      pattern: /^>(?:[\\t ]*>)*/m,\n      alias: 'punctuation'\n    },\n    'table': {\n      pattern: RegExp('^' + tableRow + tableLine + '(?:' + tableRow + ')*', 'm'),\n      inside: {\n        'table-data-rows': {\n          pattern: RegExp('^(' + tableRow + tableLine + ')(?:' + tableRow + ')*$'),\n          lookbehind: true,\n          inside: {\n            'table-data': {\n              pattern: RegExp(tableCell),\n              inside: Prism.languages.markdown\n            },\n            'punctuation': /\\|/\n          }\n        },\n        'table-line': {\n          pattern: RegExp('^(' + tableRow + ')' + tableLine + '$'),\n          lookbehind: true,\n          inside: {\n            'punctuation': /\\||:?-{3,}:?/\n          }\n        },\n        'table-header-row': {\n          pattern: RegExp('^' + tableRow + '$'),\n          inside: {\n            'table-header': {\n              pattern: RegExp(tableCell),\n              alias: 'important',\n              inside: Prism.languages.markdown\n            },\n            'punctuation': /\\|/\n          }\n        }\n      }\n    },\n    'code': [{\n      // Prefixed by 4 spaces or 1 tab and preceded by an empty line\n      pattern: /((?:^|\\n)[ \\t]*\\n|(?:^|\\r\\n?)[ \\t]*\\r\\n?)(?: {4}|\\t).+(?:(?:\\n|\\r\\n?)(?: {4}|\\t).+)*/,\n      lookbehind: true,\n      alias: 'keyword'\n    }, {\n      // ```optional language\n      // code block\n      // ```\n      pattern: /^```[\\s\\S]*?^```$/m,\n      greedy: true,\n      inside: {\n        'code-block': {\n          pattern: /^(```.*(?:\\n|\\r\\n?))[\\s\\S]+?(?=(?:\\n|\\r\\n?)^```$)/m,\n          lookbehind: true\n        },\n        'code-language': {\n          pattern: /^(```).+/,\n          lookbehind: true\n        },\n        'punctuation': /```/\n      }\n    }],\n    'title': [{\n      // title 1\n      // =======\n      // title 2\n      // -------\n      pattern: /\\S.*(?:\\n|\\r\\n?)(?:==+|--+)(?=[ \\t]*$)/m,\n      alias: 'important',\n      inside: {\n        punctuation: /==+$|--+$/\n      }\n    }, {\n      // # title 1\n      // ###### title 6\n      pattern: /(^\\s*)#.+/m,\n      lookbehind: true,\n      alias: 'important',\n      inside: {\n        punctuation: /^#+|#+$/\n      }\n    }],\n    'hr': {\n      // ***\n      // ---\n      // * * *\n      // -----------\n      pattern: /(^\\s*)([*-])(?:[\\t ]*\\2){2,}(?=\\s*$)/m,\n      lookbehind: true,\n      alias: 'punctuation'\n    },\n    'list': {\n      // * item\n      // + item\n      // - item\n      // 1. item\n      pattern: /(^\\s*)(?:[*+-]|\\d+\\.)(?=[\\t ].)/m,\n      lookbehind: true,\n      alias: 'punctuation'\n    },\n    'url-reference': {\n      // [id]: http://example.com \"Optional title\"\n      // [id]: http://example.com 'Optional title'\n      // [id]: http://example.com (Optional title)\n      // [id]: <http://example.com> \"Optional title\"\n      pattern: /!?\\[[^\\]]+\\]:[\\t ]+(?:\\S+|<(?:\\\\.|[^>\\\\])+>)(?:[\\t ]+(?:\"(?:\\\\.|[^\"\\\\])*\"|'(?:\\\\.|[^'\\\\])*'|\\((?:\\\\.|[^)\\\\])*\\)))?/,\n      inside: {\n        'variable': {\n          pattern: /^(!?\\[)[^\\]]+/,\n          lookbehind: true\n        },\n        'string': /(?:\"(?:\\\\.|[^\"\\\\])*\"|'(?:\\\\.|[^'\\\\])*'|\\((?:\\\\.|[^)\\\\])*\\))$/,\n        'punctuation': /^[\\[\\]!:]|[<>]/\n      },\n      alias: 'url'\n    },\n    'bold': {\n      // **strong**\n      // __strong__\n      // allow one nested instance of italic text using the same delimiter\n      pattern: createInline(/\\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\\b|\\*\\*(?:(?!\\*)<inner>|\\*(?:(?!\\*)<inner>)+\\*)+\\*\\*/.source),\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        'content': {\n          pattern: /(^..)[\\s\\S]+(?=..$)/,\n          lookbehind: true,\n          inside: {} // see below\n        },\n\n        'punctuation': /\\*\\*|__/\n      }\n    },\n    'italic': {\n      // *em*\n      // _em_\n      // allow one nested instance of bold text using the same delimiter\n      pattern: createInline(/\\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\\b|\\*(?:(?!\\*)<inner>|\\*\\*(?:(?!\\*)<inner>)+\\*\\*)+\\*/.source),\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        'content': {\n          pattern: /(^.)[\\s\\S]+(?=.$)/,\n          lookbehind: true,\n          inside: {} // see below\n        },\n\n        'punctuation': /[*_]/\n      }\n    },\n    'strike': {\n      // ~~strike through~~\n      // ~strike~\n      // eslint-disable-next-line regexp/strict\n      pattern: createInline(/(~~?)(?:(?!~)<inner>)+\\2/.source),\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        'content': {\n          pattern: /(^~~?)[\\s\\S]+(?=\\1$)/,\n          lookbehind: true,\n          inside: {} // see below\n        },\n\n        'punctuation': /~~?/\n      }\n    },\n    'code-snippet': {\n      // `code`\n      // ``code``\n      pattern: /(^|[^\\\\`])(?:``[^`\\r\\n]+(?:`[^`\\r\\n]+)*``(?!`)|`[^`\\r\\n]+`(?!`))/,\n      lookbehind: true,\n      greedy: true,\n      alias: ['code', 'keyword']\n    },\n    'url': {\n      // [example](http://example.com \"Optional title\")\n      // [example][id]\n      // [example] [id]\n      pattern: createInline(/!?\\[(?:(?!\\])<inner>)+\\](?:\\([^\\s)]+(?:[\\t ]+\"(?:\\\\.|[^\"\\\\])*\")?\\)|[ \\t]?\\[(?:(?!\\])<inner>)+\\])/.source),\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        'operator': /^!/,\n        'content': {\n          pattern: /(^\\[)[^\\]]+(?=\\])/,\n          lookbehind: true,\n          inside: {} // see below\n        },\n\n        'variable': {\n          pattern: /(^\\][ \\t]?\\[)[^\\]]+(?=\\]$)/,\n          lookbehind: true\n        },\n        'url': {\n          pattern: /(^\\]\\()[^\\s)]+/,\n          lookbehind: true\n        },\n        'string': {\n          pattern: /(^[ \\t]+)\"(?:\\\\.|[^\"\\\\])*\"(?=\\)$)/,\n          lookbehind: true\n        }\n      }\n    }\n  });\n  ['url', 'bold', 'italic', 'strike'].forEach(function (token) {\n    ['url', 'bold', 'italic', 'strike', 'code-snippet'].forEach(function (inside) {\n      if (token !== inside) {\n        Prism.languages.markdown[token].inside.content.inside[inside] = Prism.languages.markdown[inside];\n      }\n    });\n  });\n  Prism.hooks.add('after-tokenize', function (env) {\n    if (env.language !== 'markdown' && env.language !== 'md') {\n      return;\n    }\n    function walkTokens(tokens) {\n      if (!tokens || typeof tokens === 'string') {\n        return;\n      }\n      for (var i = 0, l = tokens.length; i < l; i++) {\n        var token = tokens[i];\n        if (token.type !== 'code') {\n          walkTokens(token.content);\n          continue;\n        }\n        /*\n         * Add the correct `language-xxxx` class to this code block. Keep in mind that the `code-language` token\n         * is optional. But the grammar is defined so that there is only one case we have to handle:\n         *\n         * token.content = [\n         *     <span class=\"punctuation\">```</span>,\n         *     <span class=\"code-language\">xxxx</span>,\n         *     '\\n', // exactly one new lines (\\r or \\n or \\r\\n)\n         *     <span class=\"code-block\">...</span>,\n         *     '\\n', // exactly one new lines again\n         *     <span class=\"punctuation\">```</span>\n         * ];\n         */\n\n        var codeLang = token.content[1];\n        var codeBlock = token.content[3];\n        if (codeLang && codeBlock && codeLang.type === 'code-language' && codeBlock.type === 'code-block' && typeof codeLang.content === 'string') {\n          // this might be a language that Prism does not support\n          // do some replacements to support C++, C#, and F#\n          var lang = codeLang.content.replace(/\\b#/g, 'sharp').replace(/\\b\\+\\+/g, 'pp'); // only use the first word\n\n          lang = (/[a-z][\\w-]*/i.exec(lang) || [''])[0].toLowerCase();\n          var alias = 'language-' + lang; // add alias\n\n          if (!codeBlock.alias) {\n            codeBlock.alias = [alias];\n          } else if (typeof codeBlock.alias === 'string') {\n            codeBlock.alias = [codeBlock.alias, alias];\n          } else {\n            codeBlock.alias.push(alias);\n          }\n        }\n      }\n    }\n    walkTokens(env.tokens);\n  });\n  Prism.hooks.add('wrap', function (env) {\n    if (env.type !== 'code-block') {\n      return;\n    }\n    var codeLang = '';\n    for (var i = 0, l = env.classes.length; i < l; i++) {\n      var cls = env.classes[i];\n      var match = /language-(.+)/.exec(cls);\n      if (match) {\n        codeLang = match[1];\n        break;\n      }\n    }\n    var grammar = Prism.languages[codeLang];\n    if (!grammar) {\n      if (codeLang && codeLang !== 'none' && Prism.plugins.autoloader) {\n        var id = 'md-' + new Date().valueOf() + '-' + Math.floor(Math.random() * 1e16);\n        env.attributes['id'] = id;\n        Prism.plugins.autoloader.loadLanguages(codeLang, function () {\n          var ele = document.getElementById(id);\n          if (ele) {\n            ele.innerHTML = Prism.highlight(ele.textContent, Prism.languages[codeLang], codeLang);\n          }\n        });\n      }\n    } else {\n      env.content = Prism.highlight(textContent(env.content), grammar, codeLang);\n    }\n  });\n  var tagPattern = RegExp(Prism.languages.markup.tag.pattern.source, 'gi');\n  /**\n   * A list of known entity names.\n   *\n   * This will always be incomplete to save space. The current list is the one used by lowdash's unescape function.\n   *\n   * @see {@link https://github.com/lodash/lodash/blob/2da024c3b4f9947a48517639de7560457cd4ec6c/unescape.js#L2}\n   */\n\n  var KNOWN_ENTITY_NAMES = {\n    'amp': '&',\n    'lt': '<',\n    'gt': '>',\n    'quot': '\"'\n  }; // IE 11 doesn't support `String.fromCodePoint`\n\n  var fromCodePoint = String.fromCodePoint || String.fromCharCode;\n  /**\n   * Returns the text content of a given HTML source code string.\n   *\n   * @param {string} html\n   * @returns {string}\n   */\n\n  function textContent(html) {\n    // remove all tags\n    var text = html.replace(tagPattern, ''); // decode known entities\n\n    text = text.replace(/&(\\w{1,8}|#x?[\\da-f]{1,8});/gi, function (m, code) {\n      code = code.toLowerCase();\n      if (code[0] === '#') {\n        var value;\n        if (code[1] === 'x') {\n          value = parseInt(code.slice(2), 16);\n        } else {\n          value = Number(code.slice(1));\n        }\n        return fromCodePoint(value);\n      } else {\n        var known = KNOWN_ENTITY_NAMES[code];\n        if (known) {\n          return known;\n        } // unable to decode\n\n        return m;\n      }\n    });\n    return text;\n  }\n  Prism.languages.md = Prism.languages.markdown;\n})(prism);\n/* \"prismjs/components/prism-graphql\" */\n\nprism.languages.graphql = {\n  'comment': /#.*/,\n  'description': {\n    pattern: /(?:\"\"\"(?:[^\"]|(?!\"\"\")\")*\"\"\"|\"(?:\\\\.|[^\\\\\"\\r\\n])*\")(?=\\s*[a-z_])/i,\n    greedy: true,\n    alias: 'string',\n    inside: {\n      'language-markdown': {\n        pattern: /(^\"(?:\"\")?)(?!\\1)[\\s\\S]+(?=\\1$)/,\n        lookbehind: true,\n        inside: prism.languages.markdown\n      }\n    }\n  },\n  'string': {\n    pattern: /\"\"\"(?:[^\"]|(?!\"\"\")\")*\"\"\"|\"(?:\\\\.|[^\\\\\"\\r\\n])*\"/,\n    greedy: true\n  },\n  'number': /(?:\\B-|\\b)\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?\\b/i,\n  'boolean': /\\b(?:false|true)\\b/,\n  'variable': /\\$[a-z_]\\w*/i,\n  'directive': {\n    pattern: /@[a-z_]\\w*/i,\n    alias: 'function'\n  },\n  'attr-name': {\n    pattern: /\\b[a-z_]\\w*(?=\\s*(?:\\((?:[^()\"]|\"(?:\\\\.|[^\\\\\"\\r\\n])*\")*\\))?:)/i,\n    greedy: true\n  },\n  'atom-input': {\n    pattern: /\\b[A-Z]\\w*Input\\b/,\n    alias: 'class-name'\n  },\n  'scalar': /\\b(?:Boolean|Float|ID|Int|String)\\b/,\n  'constant': /\\b[A-Z][A-Z_\\d]*\\b/,\n  'class-name': {\n    pattern: /(\\b(?:enum|implements|interface|on|scalar|type|union)\\s+|&\\s*|:\\s*|\\[)[A-Z_]\\w*/,\n    lookbehind: true\n  },\n  'fragment': {\n    pattern: /(\\bfragment\\s+|\\.{3}\\s*(?!on\\b))[a-zA-Z_]\\w*/,\n    lookbehind: true,\n    alias: 'function'\n  },\n  'definition-mutation': {\n    pattern: /(\\bmutation\\s+)[a-zA-Z_]\\w*/,\n    lookbehind: true,\n    alias: 'function'\n  },\n  'definition-query': {\n    pattern: /(\\bquery\\s+)[a-zA-Z_]\\w*/,\n    lookbehind: true,\n    alias: 'function'\n  },\n  'keyword': /\\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\\b/,\n  'operator': /[!=|&]|\\.{3}/,\n  'property-query': /\\w+(?=\\s*\\()/,\n  'object': /\\w+(?=\\s*\\{)/,\n  'punctuation': /[!(){}\\[\\]:=,]/,\n  'property': /\\w+/\n};\nprism.hooks.add('after-tokenize', function afterTokenizeGraphql(env) {\n  if (env.language !== 'graphql') {\n    return;\n  }\n  /**\n   * get the graphql token stream that we want to customize\n   *\n   * @typedef {InstanceType<import(\"./prism-core\")[\"Token\"]>} Token\n   * @type {Token[]}\n   */\n\n  var validTokens = env.tokens.filter(function (token) {\n    return typeof token !== 'string' && token.type !== 'comment' && token.type !== 'scalar';\n  });\n  var currentIndex = 0;\n  /**\n   * Returns whether the token relative to the current index has the given type.\n   *\n   * @param {number} offset\n   * @returns {Token | undefined}\n   */\n\n  function getToken(offset) {\n    return validTokens[currentIndex + offset];\n  }\n  /**\n   * Returns whether the token relative to the current index has the given type.\n   *\n   * @param {readonly string[]} types\n   * @param {number} [offset=0]\n   * @returns {boolean}\n   */\n\n  function isTokenType(types, offset) {\n    offset = offset || 0;\n    for (var i = 0; i < types.length; i++) {\n      var token = getToken(i + offset);\n      if (!token || token.type !== types[i]) {\n        return false;\n      }\n    }\n    return true;\n  }\n  /**\n   * Returns the index of the closing bracket to an opening bracket.\n   *\n   * It is assumed that `token[currentIndex - 1]` is an opening bracket.\n   *\n   * If no closing bracket could be found, `-1` will be returned.\n   *\n   * @param {RegExp} open\n   * @param {RegExp} close\n   * @returns {number}\n   */\n\n  function findClosingBracket(open, close) {\n    var stackHeight = 1;\n    for (var i = currentIndex; i < validTokens.length; i++) {\n      var token = validTokens[i];\n      var content = token.content;\n      if (token.type === 'punctuation' && typeof content === 'string') {\n        if (open.test(content)) {\n          stackHeight++;\n        } else if (close.test(content)) {\n          stackHeight--;\n          if (stackHeight === 0) {\n            return i;\n          }\n        }\n      }\n    }\n    return -1;\n  }\n  /**\n   * Adds an alias to the given token.\n   *\n   * @param {Token} token\n   * @param {string} alias\n   * @returns {void}\n   */\n\n  function addAlias(token, alias) {\n    var aliases = token.alias;\n    if (!aliases) {\n      token.alias = aliases = [];\n    } else if (!Array.isArray(aliases)) {\n      token.alias = aliases = [aliases];\n    }\n    aliases.push(alias);\n  }\n  for (; currentIndex < validTokens.length;) {\n    var startToken = validTokens[currentIndex++]; // add special aliases for mutation tokens\n\n    if (startToken.type === 'keyword' && startToken.content === 'mutation') {\n      // any array of the names of all input variables (if any)\n      var inputVariables = [];\n      if (isTokenType(['definition-mutation', 'punctuation']) && getToken(1).content === '(') {\n        // definition\n        currentIndex += 2; // skip 'definition-mutation' and 'punctuation'\n\n        var definitionEnd = findClosingBracket(/^\\($/, /^\\)$/);\n        if (definitionEnd === -1) {\n          continue;\n        } // find all input variables\n\n        for (; currentIndex < definitionEnd; currentIndex++) {\n          var t = getToken(0);\n          if (t.type === 'variable') {\n            addAlias(t, 'variable-input');\n            inputVariables.push(t.content);\n          }\n        }\n        currentIndex = definitionEnd + 1;\n      }\n      if (isTokenType(['punctuation', 'property-query']) && getToken(0).content === '{') {\n        currentIndex++; // skip opening bracket\n\n        addAlias(getToken(0), 'property-mutation');\n        if (inputVariables.length > 0) {\n          var mutationEnd = findClosingBracket(/^\\{$/, /^\\}$/);\n          if (mutationEnd === -1) {\n            continue;\n          } // give references to input variables a special alias\n\n          for (var i = currentIndex; i < mutationEnd; i++) {\n            var varToken = validTokens[i];\n            if (varToken.type === 'variable' && inputVariables.indexOf(varToken.content) >= 0) {\n              addAlias(varToken, 'variable-input');\n            }\n          }\n        }\n      }\n    }\n  }\n});\n/* \"prismjs/components/prism-sql\" */\n\nprism.languages.sql = {\n  'comment': {\n    pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|(?:--|\\/\\/|#).*)/,\n    lookbehind: true\n  },\n  'variable': [{\n    pattern: /@([\"'`])(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])+\\1/,\n    greedy: true\n  }, /@[\\w.$]+/],\n  'string': {\n    pattern: /(^|[^@\\\\])(\"|')(?:\\\\[\\s\\S]|(?!\\2)[^\\\\]|\\2\\2)*\\2/,\n    greedy: true,\n    lookbehind: true\n  },\n  'identifier': {\n    pattern: /(^|[^@\\\\])`(?:\\\\[\\s\\S]|[^`\\\\]|``)*`/,\n    greedy: true,\n    lookbehind: true,\n    inside: {\n      'punctuation': /^`|`$/\n    }\n  },\n  'function': /\\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\\s*\\()/i,\n  // Should we highlight user defined functions too?\n  'keyword': /\\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR(?:ACTER|SET)?|CHECK(?:POINT)?|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMNS?|COMMENT|COMMIT(?:TED)?|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS(?:TABLE)?|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|CYCLE|DATA(?:BASES?)?|DATE(?:TIME)?|DAY|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITERS?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE|ELSE(?:IF)?|ENABLE|ENCLOSED|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPED?|EXCEPT|EXEC(?:UTE)?|EXISTS|EXIT|EXPLAIN|EXTENDED|FETCH|FIELDS|FILE|FILLFACTOR|FIRST|FIXED|FLOAT|FOLLOWING|FOR(?: EACH ROW)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|FROM|FULL|FUNCTION|GEOMETRY(?:COLLECTION)?|GLOBAL|GOTO|GRANT|GROUP|HANDLER|HASH|HAVING|HOLDLOCK|HOUR|IDENTITY(?:COL|_INSERT)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|ISOLATION|ITERATE|JOIN|KEYS?|KILL|LANGUAGE|LAST|LEAVE|LEFT|LEVEL|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|LOOP|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|NEXT|NO|NONCLUSTERED|NULLIF|NUMERIC|OFF?|OFFSETS?|ON|OPEN(?:DATASOURCE|QUERY|ROWSET)?|OPTIMIZE|OPTION(?:ALLY)?|ORDER|OUT(?:ER|FILE)?|OVER|PARTIAL|PARTITION|PERCENT|PIVOT|PLAN|POINT|POLYGON|PRECEDING|PRECISION|PREPARE|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READS?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEAT(?:ABLE)?|REPLACE|REPLICATION|REQUIRE|RESIGNAL|RESTORE|RESTRICT|RETURN(?:ING|S)?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\\b/i,\n  'boolean': /\\b(?:FALSE|NULL|TRUE)\\b/i,\n  'number': /\\b0x[\\da-f]+\\b|\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+\\b/i,\n  'operator': /[-+*\\/=%^~]|&&?|\\|\\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\\b(?:AND|BETWEEN|DIV|ILIKE|IN|IS|LIKE|NOT|OR|REGEXP|RLIKE|SOUNDS LIKE|XOR)\\b/i,\n  'punctuation': /[;[\\]()`,.]/\n};\n/* \"prismjs/components/prism-js-templates\" */\n\n(function (Prism) {\n  var templateString = Prism.languages.javascript['template-string']; // see the pattern in prism-javascript.js\n\n  var templateLiteralPattern = templateString.pattern.source;\n  var interpolationObject = templateString.inside['interpolation'];\n  var interpolationPunctuationObject = interpolationObject.inside['interpolation-punctuation'];\n  var interpolationPattern = interpolationObject.pattern.source;\n  /**\n   * Creates a new pattern to match a template string with a special tag.\n   *\n   * This will return `undefined` if there is no grammar with the given language id.\n   *\n   * @param {string} language The language id of the embedded language. E.g. `markdown`.\n   * @param {string} tag The regex pattern to match the tag.\n   * @returns {object | undefined}\n   * @example\n   * createTemplate('css', /\\bcss/.source);\n   */\n\n  function createTemplate(language, tag) {\n    if (!Prism.languages[language]) {\n      return undefined;\n    }\n    return {\n      pattern: RegExp('((?:' + tag + ')\\\\s*)' + templateLiteralPattern),\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        'template-punctuation': {\n          pattern: /^`|`$/,\n          alias: 'string'\n        },\n        'embedded-code': {\n          pattern: /[\\s\\S]+/,\n          alias: language\n        }\n      }\n    };\n  }\n  Prism.languages.javascript['template-string'] = [\n  // styled-jsx:\n  //   css`a { color: #25F; }`\n  // styled-components:\n  //   styled.h1`color: red;`\n  createTemplate('css', /\\b(?:styled(?:\\([^)]*\\))?(?:\\s*\\.\\s*\\w+(?:\\([^)]*\\))*)*|css(?:\\s*\\.\\s*(?:global|resolve))?|createGlobalStyle|keyframes)/.source),\n  // html`<p></p>`\n  // div.innerHTML = `<p></p>`\n  createTemplate('html', /\\bhtml|\\.\\s*(?:inner|outer)HTML\\s*\\+?=/.source),\n  // svg`<path fill=\"#fff\" d=\"M55.37 ...\"/>`\n  createTemplate('svg', /\\bsvg/.source),\n  // md`# h1`, markdown`## h2`\n  createTemplate('markdown', /\\b(?:markdown|md)/.source),\n  // gql`...`, graphql`...`, graphql.experimental`...`\n  createTemplate('graphql', /\\b(?:gql|graphql(?:\\s*\\.\\s*experimental)?)/.source),\n  // sql`...`\n  createTemplate('sql', /\\bsql/.source),\n  // vanilla template string\n  templateString].filter(Boolean);\n  /**\n   * Returns a specific placeholder literal for the given language.\n   *\n   * @param {number} counter\n   * @param {string} language\n   * @returns {string}\n   */\n\n  function getPlaceholder(counter, language) {\n    return '___' + language.toUpperCase() + '_' + counter + '___';\n  }\n  /**\n   * Returns the tokens of `Prism.tokenize` but also runs the `before-tokenize` and `after-tokenize` hooks.\n   *\n   * @param {string} code\n   * @param {any} grammar\n   * @param {string} language\n   * @returns {(string|Token)[]}\n   */\n\n  function tokenizeWithHooks(code, grammar, language) {\n    var env = {\n      code: code,\n      grammar: grammar,\n      language: language\n    };\n    Prism.hooks.run('before-tokenize', env);\n    env.tokens = Prism.tokenize(env.code, env.grammar);\n    Prism.hooks.run('after-tokenize', env);\n    return env.tokens;\n  }\n  /**\n   * Returns the token of the given JavaScript interpolation expression.\n   *\n   * @param {string} expression The code of the expression. E.g. `\"${42}\"`\n   * @returns {Token}\n   */\n\n  function tokenizeInterpolationExpression(expression) {\n    var tempGrammar = {};\n    tempGrammar['interpolation-punctuation'] = interpolationPunctuationObject;\n    /** @type {Array} */\n\n    var tokens = Prism.tokenize(expression, tempGrammar);\n    if (tokens.length === 3) {\n      /**\n       * The token array will look like this\n       * [\n       *     [\"interpolation-punctuation\", \"${\"]\n       *     \"...\" // JavaScript expression of the interpolation\n       *     [\"interpolation-punctuation\", \"}\"]\n       * ]\n       */\n      var args = [1, 1];\n      args.push.apply(args, tokenizeWithHooks(tokens[1], Prism.languages.javascript, 'javascript'));\n      tokens.splice.apply(tokens, args);\n    }\n    return new Prism.Token('interpolation', tokens, interpolationObject.alias, expression);\n  }\n  /**\n   * Tokenizes the given code with support for JavaScript interpolation expressions mixed in.\n   *\n   * This function has 3 phases:\n   *\n   * 1. Replace all JavaScript interpolation expression with a placeholder.\n   *    The placeholder will have the syntax of a identify of the target language.\n   * 2. Tokenize the code with placeholders.\n   * 3. Tokenize the interpolation expressions and re-insert them into the tokenize code.\n   *    The insertion only works if a placeholder hasn't been \"ripped apart\" meaning that the placeholder has been\n   *    tokenized as two tokens by the grammar of the embedded language.\n   *\n   * @param {string} code\n   * @param {object} grammar\n   * @param {string} language\n   * @returns {Token}\n   */\n\n  function tokenizeEmbedded(code, grammar, language) {\n    // 1. First filter out all interpolations\n    // because they might be escaped, we need a lookbehind, so we use Prism\n\n    /** @type {(Token|string)[]} */\n    var _tokens = Prism.tokenize(code, {\n      'interpolation': {\n        pattern: RegExp(interpolationPattern),\n        lookbehind: true\n      }\n    }); // replace all interpolations with a placeholder which is not in the code already\n\n    var placeholderCounter = 0;\n    /** @type {Object<string, string>} */\n\n    var placeholderMap = {};\n    var embeddedCode = _tokens.map(function (token) {\n      if (typeof token === 'string') {\n        return token;\n      } else {\n        var interpolationExpression = token.content;\n        var placeholder;\n        while (code.indexOf(placeholder = getPlaceholder(placeholderCounter++, language)) !== -1) {\n          /* noop */\n        }\n        placeholderMap[placeholder] = interpolationExpression;\n        return placeholder;\n      }\n    }).join(''); // 2. Tokenize the embedded code\n\n    var embeddedTokens = tokenizeWithHooks(embeddedCode, grammar, language); // 3. Re-insert the interpolation\n\n    var placeholders = Object.keys(placeholderMap);\n    placeholderCounter = 0;\n    /**\n     *\n     * @param {(Token|string)[]} tokens\n     * @returns {void}\n     */\n\n    function walkTokens(tokens) {\n      for (var i = 0; i < tokens.length; i++) {\n        if (placeholderCounter >= placeholders.length) {\n          return;\n        }\n        var token = tokens[i];\n        if (typeof token === 'string' || typeof token.content === 'string') {\n          var placeholder = placeholders[placeholderCounter];\n          var s = typeof token === 'string' ? token : /** @type {string} */\n          token.content;\n          var index = s.indexOf(placeholder);\n          if (index !== -1) {\n            ++placeholderCounter;\n            var before = s.substring(0, index);\n            var middle = tokenizeInterpolationExpression(placeholderMap[placeholder]);\n            var after = s.substring(index + placeholder.length);\n            var replacement = [];\n            if (before) {\n              replacement.push(before);\n            }\n            replacement.push(middle);\n            if (after) {\n              var afterTokens = [after];\n              walkTokens(afterTokens);\n              replacement.push.apply(replacement, afterTokens);\n            }\n            if (typeof token === 'string') {\n              tokens.splice.apply(tokens, [i, 1].concat(replacement));\n              i += replacement.length - 1;\n            } else {\n              token.content = replacement;\n            }\n          }\n        } else {\n          var content = token.content;\n          if (Array.isArray(content)) {\n            walkTokens(content);\n          } else {\n            walkTokens([content]);\n          }\n        }\n      }\n    }\n    walkTokens(embeddedTokens);\n    return new Prism.Token(language, embeddedTokens, 'language-' + language, code);\n  }\n  /**\n   * The languages for which JS templating will handle tagged template literals.\n   *\n   * JS templating isn't active for only JavaScript but also related languages like TypeScript, JSX, and TSX.\n   */\n\n  var supportedLanguages = {\n    'javascript': true,\n    'js': true,\n    'typescript': true,\n    'ts': true,\n    'jsx': true,\n    'tsx': true\n  };\n  Prism.hooks.add('after-tokenize', function (env) {\n    if (!(env.language in supportedLanguages)) {\n      return;\n    }\n    /**\n     * Finds and tokenizes all template strings with an embedded languages.\n     *\n     * @param {(Token | string)[]} tokens\n     * @returns {void}\n     */\n\n    function findTemplateStrings(tokens) {\n      for (var i = 0, l = tokens.length; i < l; i++) {\n        var token = tokens[i];\n        if (typeof token === 'string') {\n          continue;\n        }\n        var content = token.content;\n        if (!Array.isArray(content)) {\n          if (typeof content !== 'string') {\n            findTemplateStrings([content]);\n          }\n          continue;\n        }\n        if (token.type === 'template-string') {\n          /**\n           * A JavaScript template-string token will look like this:\n           *\n           * [\"template-string\", [\n           *     [\"template-punctuation\", \"`\"],\n           *     (\n           *         An array of \"string\" and \"interpolation\" tokens. This is the simple string case.\n           *         or\n           *         [\"embedded-code\", \"...\"] This is the token containing the embedded code.\n           *                                  It also has an alias which is the language of the embedded code.\n           *     ),\n           *     [\"template-punctuation\", \"`\"]\n           * ]]\n           */\n          var embedded = content[1];\n          if (content.length === 3 && typeof embedded !== 'string' && embedded.type === 'embedded-code') {\n            // get string content\n            var code = stringContent(embedded);\n            var alias = embedded.alias;\n            var language = Array.isArray(alias) ? alias[0] : alias;\n            var grammar = Prism.languages[language];\n            if (!grammar) {\n              // the embedded language isn't registered.\n              continue;\n            }\n            content[1] = tokenizeEmbedded(code, grammar, language);\n          }\n        } else {\n          findTemplateStrings(content);\n        }\n      }\n    }\n    findTemplateStrings(env.tokens);\n  });\n  /**\n   * Returns the string content of a token or token stream.\n   *\n   * @param {string | Token | (string | Token)[]} value\n   * @returns {string}\n   */\n\n  function stringContent(value) {\n    if (typeof value === 'string') {\n      return value;\n    } else if (Array.isArray(value)) {\n      return value.map(stringContent).join('');\n    } else {\n      return stringContent(value.content);\n    }\n  }\n})(prism);\n/* \"prismjs/components/prism-typescript\" */\n\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)(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*(?:\\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,\n      lookbehind: true,\n      greedy: true,\n      inside: null // see below\n    },\n\n    'builtin': /\\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\\b/\n  }); // The keywords TypeScript adds to JavaScript\n\n  Prism.languages.typescript.keyword.push(/\\b(?:abstract|declare|is|keyof|readonly|require)\\b/,\n  // keywords that have to be followed by an identifier\n  /\\b(?:asserts|infer|interface|module|namespace|type)\\b(?=\\s*(?:[{_$a-zA-Z\\xA0-\\uFFFF]|$))/,\n  // This is for `import type *, {}`\n  /\\btype\\b(?=\\s*(?:[\\{*]|$))/); // doesn't work with TS because TS is too complex\n\n  delete Prism.languages.typescript['parameter'];\n  delete Prism.languages.typescript['literal-property']; // 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    'decorator': {\n      pattern: /@[$\\w\\xA0-\\uFFFF]+/,\n      inside: {\n        'at': {\n          pattern: /^@/,\n          alias: 'operator'\n        },\n        'function': /^[\\s\\S]+/\n      }\n    },\n    'generic-function': {\n      // e.g. foo<T extends \"bar\" | \"baz\">( ...\n      pattern: /#?(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*\\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\\s*\\()/,\n      greedy: true,\n      inside: {\n        'function': /^#?(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\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/* \"prismjs/components/prism-js-extras\" */\n\n(function (Prism) {\n  Prism.languages.insertBefore('javascript', 'function-variable', {\n    'method-variable': {\n      pattern: RegExp('(\\\\.\\\\s*)' + Prism.languages.javascript['function-variable'].pattern.source),\n      lookbehind: true,\n      alias: ['function-variable', 'method', 'function', 'property-access']\n    }\n  });\n  Prism.languages.insertBefore('javascript', 'function', {\n    'method': {\n      pattern: RegExp('(\\\\.\\\\s*)' + Prism.languages.javascript['function'].source),\n      lookbehind: true,\n      alias: ['function', 'property-access']\n    }\n  });\n  Prism.languages.insertBefore('javascript', 'constant', {\n    'known-class-name': [{\n      // standard built-ins\n      // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects\n      pattern: /\\b(?:(?:Float(?:32|64)|(?:Int|Uint)(?:8|16|32)|Uint8Clamped)?Array|ArrayBuffer|BigInt|Boolean|DataView|Date|Error|Function|Intl|JSON|(?:Weak)?(?:Map|Set)|Math|Number|Object|Promise|Proxy|Reflect|RegExp|String|Symbol|WebAssembly)\\b/,\n      alias: 'class-name'\n    }, {\n      // errors\n      pattern: /\\b(?:[A-Z]\\w*)Error\\b/,\n      alias: 'class-name'\n    }]\n  });\n  /**\n   * Replaces the `<ID>` placeholder in the given pattern with a pattern for general JS identifiers.\n   *\n   * @param {string} source\n   * @param {string} [flags]\n   * @returns {RegExp}\n   */\n\n  function withId(source, flags) {\n    return RegExp(source.replace(/<ID>/g, function () {\n      return /(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*/.source;\n    }), flags);\n  }\n  Prism.languages.insertBefore('javascript', 'keyword', {\n    'imports': {\n      // https://tc39.es/ecma262/#sec-imports\n      pattern: withId(/(\\bimport\\b\\s*)(?:<ID>(?:\\s*,\\s*(?:\\*\\s*as\\s+<ID>|\\{[^{}]*\\}))?|\\*\\s*as\\s+<ID>|\\{[^{}]*\\})(?=\\s*\\bfrom\\b)/.source),\n      lookbehind: true,\n      inside: Prism.languages.javascript\n    },\n    'exports': {\n      // https://tc39.es/ecma262/#sec-exports\n      pattern: withId(/(\\bexport\\b\\s*)(?:\\*(?:\\s*as\\s+<ID>)?(?=\\s*\\bfrom\\b)|\\{[^{}]*\\})/.source),\n      lookbehind: true,\n      inside: Prism.languages.javascript\n    }\n  });\n  Prism.languages.javascript['keyword'].unshift({\n    pattern: /\\b(?:as|default|export|from|import)\\b/,\n    alias: 'module'\n  }, {\n    pattern: /\\b(?:await|break|catch|continue|do|else|finally|for|if|return|switch|throw|try|while|yield)\\b/,\n    alias: 'control-flow'\n  }, {\n    pattern: /\\bnull\\b/,\n    alias: ['null', 'nil']\n  }, {\n    pattern: /\\bundefined\\b/,\n    alias: 'nil'\n  });\n  Prism.languages.insertBefore('javascript', 'operator', {\n    'spread': {\n      pattern: /\\.{3}/,\n      alias: 'operator'\n    },\n    'arrow': {\n      pattern: /=>/,\n      alias: 'operator'\n    }\n  });\n  Prism.languages.insertBefore('javascript', 'punctuation', {\n    'property-access': {\n      pattern: withId(/(\\.\\s*)#?<ID>/.source),\n      lookbehind: true\n    },\n    'maybe-class-name': {\n      pattern: /(^|[^$\\w\\xA0-\\uFFFF])[A-Z][$\\w\\xA0-\\uFFFF]+/,\n      lookbehind: true\n    },\n    'dom': {\n      // this contains only a few commonly used DOM variables\n      pattern: /\\b(?:document|(?:local|session)Storage|location|navigator|performance|window)\\b/,\n      alias: 'variable'\n    },\n    'console': {\n      pattern: /\\bconsole(?=\\s*\\.)/,\n      alias: 'class-name'\n    }\n  }); // add 'maybe-class-name' to tokens which might be a class name\n\n  var maybeClassNameTokens = ['function', 'function-variable', 'method', 'method-variable', 'property-access'];\n  for (var i = 0; i < maybeClassNameTokens.length; i++) {\n    var token = maybeClassNameTokens[i];\n    var value = Prism.languages.javascript[token]; // convert regex to object\n\n    if (Prism.util.type(value) === 'RegExp') {\n      value = Prism.languages.javascript[token] = {\n        pattern: value\n      };\n    } // keep in mind that we don't support arrays\n\n    var inside = value.inside || {};\n    value.inside = inside;\n    inside['maybe-class-name'] = /^[A-Z][\\s\\S]*/;\n  }\n})(prism);\n/* \"prismjs/components/prism-jsx\" */\n\n(function (Prism) {\n  var javascript = Prism.util.clone(Prism.languages.javascript);\n  var space = /(?:\\s|\\/\\/.*(?!.)|\\/\\*(?:[^*]|\\*(?!\\/))\\*\\/)/.source;\n  var braces = /(?:\\{(?:\\{(?:\\{[^{}]*\\}|[^{}])*\\}|[^{}])*\\})/.source;\n  var spread = /(?:\\{<S>*\\.{3}(?:[^{}]|<BRACES>)*\\})/.source;\n  /**\n   * @param {string} source\n   * @param {string} [flags]\n   */\n\n  function re(source, flags) {\n    source = source.replace(/<S>/g, function () {\n      return space;\n    }).replace(/<BRACES>/g, function () {\n      return braces;\n    }).replace(/<SPREAD>/g, function () {\n      return spread;\n    });\n    return RegExp(source, flags);\n  }\n  spread = re(spread).source;\n  Prism.languages.jsx = Prism.languages.extend('markup', javascript);\n  Prism.languages.jsx.tag.pattern = re(/<\\/?(?:[\\w.:-]+(?:<S>+(?:[\\w.:$-]+(?:=(?:\"(?:\\\\[\\s\\S]|[^\\\\\"])*\"|'(?:\\\\[\\s\\S]|[^\\\\'])*'|[^\\s{'\"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\\/?)?>/.source);\n  Prism.languages.jsx.tag.inside['tag'].pattern = /^<\\/?[^\\s>\\/]*/;\n  Prism.languages.jsx.tag.inside['attr-value'].pattern = /=(?!\\{)(?:\"(?:\\\\[\\s\\S]|[^\\\\\"])*\"|'(?:\\\\[\\s\\S]|[^\\\\'])*'|[^\\s'\">]+)/;\n  Prism.languages.jsx.tag.inside['tag'].inside['class-name'] = /^[A-Z]\\w*(?:\\.[A-Z]\\w*)*$/;\n  Prism.languages.jsx.tag.inside['comment'] = javascript['comment'];\n  Prism.languages.insertBefore('inside', 'attr-name', {\n    'spread': {\n      pattern: re(/<SPREAD>/.source),\n      inside: Prism.languages.jsx\n    }\n  }, Prism.languages.jsx.tag);\n  Prism.languages.insertBefore('inside', 'special-attr', {\n    'script': {\n      // Allow for two levels of nesting\n      pattern: re(/=<BRACES>/.source),\n      alias: 'language-javascript',\n      inside: {\n        'script-punctuation': {\n          pattern: /^=(?=\\{)/,\n          alias: 'punctuation'\n        },\n        rest: Prism.languages.jsx\n      }\n    }\n  }, Prism.languages.jsx.tag); // The following will handle plain text inside tags\n\n  var stringifyToken = function stringifyToken(token) {\n    if (!token) {\n      return '';\n    }\n    if (typeof token === 'string') {\n      return token;\n    }\n    if (typeof token.content === 'string') {\n      return token.content;\n    }\n    return token.content.map(stringifyToken).join('');\n  };\n  var walkTokens = function walkTokens(tokens) {\n    var openedTags = [];\n    for (var i = 0; i < tokens.length; i++) {\n      var token = tokens[i];\n      var notTagNorBrace = false;\n      if (typeof token !== 'string') {\n        if (token.type === 'tag' && token.content[0] && token.content[0].type === 'tag') {\n          // We found a tag, now find its kind\n          if (token.content[0].content[0].content === '</') {\n            // Closing tag\n            if (openedTags.length > 0 && openedTags[openedTags.length - 1].tagName === stringifyToken(token.content[0].content[1])) {\n              // Pop matching opening tag\n              openedTags.pop();\n            }\n          } else {\n            if (token.content[token.content.length - 1].content === '/>') ;else {\n              // Opening tag\n              openedTags.push({\n                tagName: stringifyToken(token.content[0].content[1]),\n                openedBraces: 0\n              });\n            }\n          }\n        } else if (openedTags.length > 0 && token.type === 'punctuation' && token.content === '{') {\n          // Here we might have entered a JSX context inside a tag\n          openedTags[openedTags.length - 1].openedBraces++;\n        } else if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces > 0 && token.type === 'punctuation' && token.content === '}') {\n          // Here we might have left a JSX context inside a tag\n          openedTags[openedTags.length - 1].openedBraces--;\n        } else {\n          notTagNorBrace = true;\n        }\n      }\n      if (notTagNorBrace || typeof token === 'string') {\n        if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces === 0) {\n          // Here we are inside a tag, and not inside a JSX context.\n          // That's plain text: drop any tokens matched.\n          var plainText = stringifyToken(token); // And merge text with adjacent text\n\n          if (i < tokens.length - 1 && (typeof tokens[i + 1] === 'string' || tokens[i + 1].type === 'plain-text')) {\n            plainText += stringifyToken(tokens[i + 1]);\n            tokens.splice(i + 1, 1);\n          }\n          if (i > 0 && (typeof tokens[i - 1] === 'string' || tokens[i - 1].type === 'plain-text')) {\n            plainText = stringifyToken(tokens[i - 1]) + plainText;\n            tokens.splice(i - 1, 1);\n            i--;\n          }\n          tokens[i] = new Prism.Token('plain-text', plainText, null, plainText);\n        }\n      }\n      if (token.content && typeof token.content !== 'string') {\n        walkTokens(token.content);\n      }\n    }\n  };\n  Prism.hooks.add('after-tokenize', function (env) {\n    if (env.language !== 'jsx' && env.language !== 'tsx') {\n      return;\n    }\n    walkTokens(env.tokens);\n  });\n})(prism);\n/* \"prismjs/components/prism-diff\" */\n\n(function (Prism) {\n  Prism.languages.diff = {\n    'coord': [\n    // Match all kinds of coord lines (prefixed by \"+++\", \"---\" or \"***\").\n    /^(?:\\*{3}|-{3}|\\+{3}).*$/m,\n    // Match \"@@ ... @@\" coord lines in unified diff.\n    /^@@.*@@$/m,\n    // Match coord lines in normal diff (starts with a number).\n    /^\\d.*$/m] // deleted, inserted, unchanged, diff\n  };\n  /**\n   * A map from the name of a block to its line prefix.\n   *\n   * @type {Object<string, string>}\n   */\n\n  var PREFIXES = {\n    'deleted-sign': '-',\n    'deleted-arrow': '<',\n    'inserted-sign': '+',\n    'inserted-arrow': '>',\n    'unchanged': ' ',\n    'diff': '!'\n  }; // add a token for each prefix\n\n  Object.keys(PREFIXES).forEach(function (name) {\n    var prefix = PREFIXES[name];\n    var alias = [];\n    if (!/^\\w+$/.test(name)) {\n      // \"deleted-sign\" -> \"deleted\"\n      alias.push(/\\w+/.exec(name)[0]);\n    }\n    if (name === 'diff') {\n      alias.push('bold');\n    }\n    Prism.languages.diff[name] = {\n      pattern: RegExp('^(?:[' + prefix + '].*(?:\\r\\n?|\\n|(?![\\\\s\\\\S])))+', 'm'),\n      alias: alias,\n      inside: {\n        'line': {\n          pattern: /(.)(?=[\\s\\S]).*(?:\\r\\n?|\\n)?/,\n          lookbehind: true\n        },\n        'prefix': {\n          pattern: /[\\s\\S]/,\n          alias: /\\w+/.exec(name)[0]\n        }\n      }\n    };\n  }); // make prefixes available to Diff plugin\n\n  Object.defineProperty(Prism.languages.diff, 'PREFIXES', {\n    value: PREFIXES\n  });\n})(prism);\n/* \"prismjs/components/prism-git\" */\n\nprism.languages.git = {\n  /*\n   * A simple one line comment like in a git status command\n   * For instance:\n   * $ git status\n   * # On branch infinite-scroll\n   * # Your branch and 'origin/sharedBranches/frontendTeam/infinite-scroll' have diverged,\n   * # and have 1 and 2 different commits each, respectively.\n   * nothing to commit (working directory clean)\n   */\n  'comment': /^#.*/m,\n  /*\n   * Regexp to match the changed lines in a git diff output. Check the example below.\n   */\n  'deleted': /^[-–].*/m,\n  'inserted': /^\\+.*/m,\n  /*\n   * a string (double and simple quote)\n   */\n  'string': /(\"|')(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n  /*\n   * a git command. It starts with a random prompt finishing by a $, then \"git\" then some other parameters\n   * For instance:\n   * $ git add file.txt\n   */\n  'command': {\n    pattern: /^.*\\$ git .*$/m,\n    inside: {\n      /*\n       * A git command can contain a parameter starting by a single or a double dash followed by a string\n       * For instance:\n       * $ git diff --cached\n       * $ git log -p\n       */\n      'parameter': /\\s--?\\w+/\n    }\n  },\n  /*\n   * Coordinates displayed in a git diff command\n   * For instance:\n   * $ git diff\n   * diff --git file.txt file.txt\n   * index 6214953..1d54a52 100644\n   * --- file.txt\n   * +++ file.txt\n   * @@ -1 +1,2 @@\n   * -Here's my tetx file\n   * +Here's my text file\n   * +And this is the second line\n   */\n  'coord': /^@@.*@@$/m,\n  /*\n   * Match a \"commit [SHA1]\" line in a git log output.\n   * For instance:\n   * $ git log\n   * commit a11a14ef7e26f2ca62d4b35eac455ce636d0dc09\n   * Author: lgiraudel\n   * Date:   Mon Feb 17 11:18:34 2014 +0100\n   *\n   *     Add of a new line\n   */\n  'commit-sha1': /^commit \\w{40}$/m\n};\n/* \"prismjs/components/prism-go\" */\n\nprism.languages.go = prism.languages.extend('clike', {\n  'string': {\n    pattern: /(^|[^\\\\])\"(?:\\\\.|[^\"\\\\\\r\\n])*\"|`[^`]*`/,\n    lookbehind: true,\n    greedy: true\n  },\n  'keyword': /\\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(?:to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\\b/,\n  'boolean': /\\b(?:_|false|iota|nil|true)\\b/,\n  'number': [\n  // binary and octal integers\n  /\\b0(?:b[01_]+|o[0-7_]+)i?\\b/i,\n  // hexadecimal integers and floats\n  /\\b0x(?:[a-f\\d_]+(?:\\.[a-f\\d_]*)?|\\.[a-f\\d_]+)(?:p[+-]?\\d+(?:_\\d+)*)?i?(?!\\w)/i,\n  // decimal integers and floats\n  /(?:\\b\\d[\\d_]*(?:\\.[\\d_]*)?|\\B\\.\\d[\\d_]*)(?:e[+-]?[\\d_]+)?i?(?!\\w)/i],\n  'operator': /[*\\/%^!=]=?|\\+[=+]?|-[=-]?|\\|[=|]?|&(?:=|&|\\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\\.\\.\\./,\n  'builtin': /\\b(?:append|bool|byte|cap|close|complex|complex(?:64|128)|copy|delete|error|float(?:32|64)|u?int(?:8|16|32|64)?|imag|len|make|new|panic|print(?:ln)?|real|recover|rune|string|uintptr)\\b/\n});\nprism.languages.insertBefore('go', 'string', {\n  'char': {\n    pattern: /'(?:\\\\.|[^'\\\\\\r\\n]){0,10}'/,\n    greedy: true\n  }\n});\ndelete prism.languages.go['class-name'];\n/* \"prismjs/components/prism-markup-templating\" */\n\n(function (Prism) {\n  /**\n   * Returns the placeholder for the given language id and index.\n   *\n   * @param {string} language\n   * @param {string|number} index\n   * @returns {string}\n   */\n  function getPlaceholder(language, index) {\n    return '___' + language.toUpperCase() + index + '___';\n  }\n  Object.defineProperties(Prism.languages['markup-templating'] = {}, {\n    buildPlaceholders: {\n      /**\n       * Tokenize all inline templating expressions matching `placeholderPattern`.\n       *\n       * If `replaceFilter` is provided, only matches of `placeholderPattern` for which `replaceFilter` returns\n       * `true` will be replaced.\n       *\n       * @param {object} env The environment of the `before-tokenize` hook.\n       * @param {string} language The language id.\n       * @param {RegExp} placeholderPattern The matches of this pattern will be replaced by placeholders.\n       * @param {(match: string) => boolean} [replaceFilter]\n       */\n      value: function value(env, language, placeholderPattern, replaceFilter) {\n        if (env.language !== language) {\n          return;\n        }\n        var tokenStack = env.tokenStack = [];\n        env.code = env.code.replace(placeholderPattern, function (match) {\n          if (typeof replaceFilter === 'function' && !replaceFilter(match)) {\n            return match;\n          }\n          var i = tokenStack.length;\n          var placeholder; // Check for existing strings\n\n          while (env.code.indexOf(placeholder = getPlaceholder(language, i)) !== -1) {\n            ++i;\n          } // Create a sparse array\n\n          tokenStack[i] = match;\n          return placeholder;\n        }); // Switch the grammar to markup\n\n        env.grammar = Prism.languages.markup;\n      }\n    },\n    tokenizePlaceholders: {\n      /**\n       * Replace placeholders with proper tokens after tokenizing.\n       *\n       * @param {object} env The environment of the `after-tokenize` hook.\n       * @param {string} language The language id.\n       */\n      value: function value(env, language) {\n        if (env.language !== language || !env.tokenStack) {\n          return;\n        } // Switch the grammar back\n\n        env.grammar = Prism.languages[language];\n        var j = 0;\n        var keys = Object.keys(env.tokenStack);\n        function walkTokens(tokens) {\n          for (var i = 0; i < tokens.length; i++) {\n            // all placeholders are replaced already\n            if (j >= keys.length) {\n              break;\n            }\n            var token = tokens[i];\n            if (typeof token === 'string' || token.content && typeof token.content === 'string') {\n              var k = keys[j];\n              var t = env.tokenStack[k];\n              var s = typeof token === 'string' ? token : token.content;\n              var placeholder = getPlaceholder(language, k);\n              var index = s.indexOf(placeholder);\n              if (index > -1) {\n                ++j;\n                var before = s.substring(0, index);\n                var middle = new Prism.Token(language, Prism.tokenize(t, env.grammar), 'language-' + language, t);\n                var after = s.substring(index + placeholder.length);\n                var replacement = [];\n                if (before) {\n                  replacement.push.apply(replacement, walkTokens([before]));\n                }\n                replacement.push(middle);\n                if (after) {\n                  replacement.push.apply(replacement, walkTokens([after]));\n                }\n                if (typeof token === 'string') {\n                  tokens.splice.apply(tokens, [i, 1].concat(replacement));\n                } else {\n                  token.content = replacement;\n                }\n              }\n            } else if (token.content\n            /* && typeof token.content !== 'string' */) {\n              walkTokens(token.content);\n            }\n          }\n          return tokens;\n        }\n        walkTokens(env.tokens);\n      }\n    }\n  });\n})(prism);\n/* \"prismjs/components/prism-handlebars\" */\n\n(function (Prism) {\n  Prism.languages.handlebars = {\n    'comment': /\\{\\{![\\s\\S]*?\\}\\}/,\n    'delimiter': {\n      pattern: /^\\{\\{\\{?|\\}\\}\\}?$/,\n      alias: 'punctuation'\n    },\n    'string': /([\"'])(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n    'number': /\\b0x[\\dA-Fa-f]+\\b|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:[Ee][+-]?\\d+)?/,\n    'boolean': /\\b(?:false|true)\\b/,\n    'block': {\n      pattern: /^(\\s*(?:~\\s*)?)[#\\/]\\S+?(?=\\s*(?:~\\s*)?$|\\s)/,\n      lookbehind: true,\n      alias: 'keyword'\n    },\n    'brackets': {\n      pattern: /\\[[^\\]]+\\]/,\n      inside: {\n        punctuation: /\\[|\\]/,\n        variable: /[\\s\\S]+/\n      }\n    },\n    'punctuation': /[!\"#%&':()*+,.\\/;<=>@\\[\\\\\\]^`{|}~]/,\n    'variable': /[^!\"#%&'()*+,\\/;<=>@\\[\\\\\\]^`{|}~\\s]+/\n  };\n  Prism.hooks.add('before-tokenize', function (env) {\n    var handlebarsPattern = /\\{\\{\\{[\\s\\S]+?\\}\\}\\}|\\{\\{[\\s\\S]+?\\}\\}/g;\n    Prism.languages['markup-templating'].buildPlaceholders(env, 'handlebars', handlebarsPattern);\n  });\n  Prism.hooks.add('after-tokenize', function (env) {\n    Prism.languages['markup-templating'].tokenizePlaceholders(env, 'handlebars');\n  });\n  Prism.languages.hbs = Prism.languages.handlebars;\n})(prism);\n/* \"prismjs/components/prism-json\" */\n// https://www.json.org/json-en.html\n\nprism.languages.json = {\n  'property': {\n    pattern: /(^|[^\\\\])\"(?:\\\\.|[^\\\\\"\\r\\n])*\"(?=\\s*:)/,\n    lookbehind: true,\n    greedy: true\n  },\n  'string': {\n    pattern: /(^|[^\\\\])\"(?:\\\\.|[^\\\\\"\\r\\n])*\"(?!\\s*:)/,\n    lookbehind: true,\n    greedy: true\n  },\n  'comment': {\n    pattern: /\\/\\/.*|\\/\\*[\\s\\S]*?(?:\\*\\/|$)/,\n    greedy: true\n  },\n  'number': /-?\\b\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?\\b/i,\n  'punctuation': /[{}[\\],]/,\n  'operator': /:/,\n  'boolean': /\\b(?:false|true)\\b/,\n  'null': {\n    pattern: /\\bnull\\b/,\n    alias: 'keyword'\n  }\n};\nprism.languages.webmanifest = prism.languages.json;\n/* \"prismjs/components/prism-less\" */\n\n/* FIXME :\n :extend() is not handled specifically : its highlighting is buggy.\n Mixin usage must be inside a ruleset to be highlighted.\n At-rules (e.g. import) containing interpolations are buggy.\n Detached rulesets are highlighted as at-rules.\n A comment before a mixin usage prevents the latter to be properly highlighted.\n */\n\nprism.languages.less = prism.languages.extend('css', {\n  'comment': [/\\/\\*[\\s\\S]*?\\*\\//, {\n    pattern: /(^|[^\\\\])\\/\\/.*/,\n    lookbehind: true\n  }],\n  'atrule': {\n    pattern: /@[\\w-](?:\\((?:[^(){}]|\\([^(){}]*\\))*\\)|[^(){};\\s]|\\s+(?!\\s))*?(?=\\s*\\{)/,\n    inside: {\n      'punctuation': /[:()]/\n    }\n  },\n  // selectors and mixins are considered the same\n  'selector': {\n    pattern: /(?:@\\{[\\w-]+\\}|[^{};\\s@])(?:@\\{[\\w-]+\\}|\\((?:[^(){}]|\\([^(){}]*\\))*\\)|[^(){};@\\s]|\\s+(?!\\s))*?(?=\\s*\\{)/,\n    inside: {\n      // mixin parameters\n      'variable': /@+[\\w-]+/\n    }\n  },\n  'property': /(?:@\\{[\\w-]+\\}|[\\w-])+(?:\\+_?)?(?=\\s*:)/,\n  'operator': /[+\\-*\\/]/\n});\nprism.languages.insertBefore('less', 'property', {\n  'variable': [\n  // Variable declaration (the colon must be consumed!)\n  {\n    pattern: /@[\\w-]+\\s*:/,\n    inside: {\n      'punctuation': /:/\n    }\n  },\n  // Variable usage\n  /@@?[\\w-]+/],\n  'mixin-usage': {\n    pattern: /([{;]\\s*)[.#](?!\\d)[\\w-].*?(?=[(;])/,\n    lookbehind: true,\n    alias: 'function'\n  }\n});\n/* \"prismjs/components/prism-makefile\" */\n\nprism.languages.makefile = {\n  'comment': {\n    pattern: /(^|[^\\\\])#(?:\\\\(?:\\r\\n|[\\s\\S])|[^\\\\\\r\\n])*/,\n    lookbehind: true\n  },\n  'string': {\n    pattern: /([\"'])(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/,\n    greedy: true\n  },\n  'builtin-target': {\n    pattern: /\\.[A-Z][^:#=\\s]+(?=\\s*:(?!=))/,\n    alias: 'builtin'\n  },\n  'target': {\n    pattern: /^(?:[^:=\\s]|[ \\t]+(?![\\s:]))+(?=\\s*:(?!=))/m,\n    alias: 'symbol',\n    inside: {\n      'variable': /\\$+(?:(?!\\$)[^(){}:#=\\s]+|(?=[({]))/\n    }\n  },\n  'variable': /\\$+(?:(?!\\$)[^(){}:#=\\s]+|\\([@*%<^+?][DF]\\)|(?=[({]))/,\n  // Directives\n  'keyword': /-include\\b|\\b(?:define|else|endef|endif|export|ifn?def|ifn?eq|include|override|private|sinclude|undefine|unexport|vpath)\\b/,\n  'function': {\n    pattern: /(\\()(?:abspath|addsuffix|and|basename|call|dir|error|eval|file|filter(?:-out)?|findstring|firstword|flavor|foreach|guile|if|info|join|lastword|load|notdir|or|origin|patsubst|realpath|shell|sort|strip|subst|suffix|value|warning|wildcard|word(?:list|s)?)(?=[ \\t])/,\n    lookbehind: true\n  },\n  'operator': /(?:::|[?:+!])?=|[|@]/,\n  'punctuation': /[:;(){}]/\n};\n/* \"prismjs/components/prism-objectivec\" */\n\nprism.languages.objectivec = prism.languages.extend('c', {\n  'string': {\n    pattern: /@?\"(?:\\\\(?:\\r\\n|[\\s\\S])|[^\"\\\\\\r\\n])*\"/,\n    greedy: true\n  },\n  'keyword': /\\b(?:asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|in|inline|int|long|register|return|self|short|signed|sizeof|static|struct|super|switch|typedef|typeof|union|unsigned|void|volatile|while)\\b|(?:@interface|@end|@implementation|@protocol|@class|@public|@protected|@private|@property|@try|@catch|@finally|@throw|@synthesize|@dynamic|@selector)\\b/,\n  'operator': /-[->]?|\\+\\+?|!=?|<<?=?|>>?=?|==?|&&?|\\|\\|?|[~^%?*\\/@]/\n});\ndelete prism.languages.objectivec['class-name'];\nprism.languages.objc = prism.languages.objectivec;\n/* \"prismjs/components/prism-ocaml\" */\n// https://ocaml.org/manual/lex.html\n\nprism.languages.ocaml = {\n  'comment': {\n    pattern: /\\(\\*[\\s\\S]*?\\*\\)/,\n    greedy: true\n  },\n  'char': {\n    pattern: /'(?:[^\\\\\\r\\n']|\\\\(?:.|[ox]?[0-9a-f]{1,3}))'/i,\n    greedy: true\n  },\n  'string': [{\n    pattern: /\"(?:\\\\(?:[\\s\\S]|\\r\\n)|[^\\\\\\r\\n\"])*\"/,\n    greedy: true\n  }, {\n    pattern: /\\{([a-z_]*)\\|[\\s\\S]*?\\|\\1\\}/,\n    greedy: true\n  }],\n  'number': [\n  // binary and octal\n  /\\b(?:0b[01][01_]*|0o[0-7][0-7_]*)\\b/i,\n  // hexadecimal\n  /\\b0x[a-f0-9][a-f0-9_]*(?:\\.[a-f0-9_]*)?(?:p[+-]?\\d[\\d_]*)?(?!\\w)/i,\n  // decimal\n  /\\b\\d[\\d_]*(?:\\.[\\d_]*)?(?:e[+-]?\\d[\\d_]*)?(?!\\w)/i],\n  'directive': {\n    pattern: /\\B#\\w+/,\n    alias: 'property'\n  },\n  'label': {\n    pattern: /\\B~\\w+/,\n    alias: 'property'\n  },\n  'type-variable': {\n    pattern: /\\B'\\w+/,\n    alias: 'function'\n  },\n  'variant': {\n    pattern: /`\\w+/,\n    alias: 'symbol'\n  },\n  // For the list of keywords and operators,\n  // see: http://caml.inria.fr/pub/docs/manual-ocaml/lex.html#sec84\n  'keyword': /\\b(?:as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|match|method|module|mutable|new|nonrec|object|of|open|private|rec|sig|struct|then|to|try|type|val|value|virtual|when|where|while|with)\\b/,\n  'boolean': /\\b(?:false|true)\\b/,\n  'operator-like-punctuation': {\n    pattern: /\\[[<>|]|[>|]\\]|\\{<|>\\}/,\n    alias: 'punctuation'\n  },\n  // Custom operators are allowed\n  'operator': /\\.[.~]|:[=>]|[=<>@^|&+\\-*\\/$%!?~][!$%&*+\\-.\\/:<=>?@^|~]*|\\b(?:and|asr|land|lor|lsl|lsr|lxor|mod|or)\\b/,\n  'punctuation': /;;|::|[(){}\\[\\].,:;#]|\\b_\\b/\n};\n/* \"prismjs/components/prism-python\" */\n\nprism.languages.python = {\n  'comment': {\n    pattern: /(^|[^\\\\])#.*/,\n    lookbehind: true,\n    greedy: true\n  },\n  'string-interpolation': {\n    pattern: /(?:f|fr|rf)(?:(\"\"\"|''')[\\s\\S]*?\\1|(\"|')(?:\\\\.|(?!\\2)[^\\\\\\r\\n])*\\2)/i,\n    greedy: true,\n    inside: {\n      'interpolation': {\n        // \"{\" <expression> <optional \"!s\", \"!r\", or \"!a\"> <optional \":\" format specifier> \"}\"\n        pattern: /((?:^|[^{])(?:\\{\\{)*)\\{(?!\\{)(?:[^{}]|\\{(?!\\{)(?:[^{}]|\\{(?!\\{)(?:[^{}])+\\})+\\})+\\}/,\n        lookbehind: true,\n        inside: {\n          'format-spec': {\n            pattern: /(:)[^:(){}]+(?=\\}$)/,\n            lookbehind: true\n          },\n          'conversion-option': {\n            pattern: /![sra](?=[:}]$)/,\n            alias: 'punctuation'\n          },\n          rest: null\n        }\n      },\n      'string': /[\\s\\S]+/\n    }\n  },\n  'triple-quoted-string': {\n    pattern: /(?:[rub]|br|rb)?(\"\"\"|''')[\\s\\S]*?\\1/i,\n    greedy: true,\n    alias: 'string'\n  },\n  'string': {\n    pattern: /(?:[rub]|br|rb)?(\"|')(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/i,\n    greedy: true\n  },\n  'function': {\n    pattern: /((?:^|\\s)def[ \\t]+)[a-zA-Z_]\\w*(?=\\s*\\()/g,\n    lookbehind: true\n  },\n  'class-name': {\n    pattern: /(\\bclass\\s+)\\w+/i,\n    lookbehind: true\n  },\n  'decorator': {\n    pattern: /(^[\\t ]*)@\\w+(?:\\.\\w+)*/m,\n    lookbehind: true,\n    alias: ['annotation', 'punctuation'],\n    inside: {\n      'punctuation': /\\./\n    }\n  },\n  'keyword': /\\b(?:_(?=\\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\\b/,\n  'builtin': /\\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\\b/,\n  'boolean': /\\b(?:False|None|True)\\b/,\n  'number': /\\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\\b|(?:\\b\\d+(?:_\\d+)*(?:\\.(?:\\d+(?:_\\d+)*)?)?|\\B\\.\\d+(?:_\\d+)*)(?:e[+-]?\\d+(?:_\\d+)*)?j?(?!\\w)/i,\n  'operator': /[-+%=]=?|!=|:=|\\*\\*?=?|\\/\\/?=?|<[<=>]?|>[=>]?|[&|^~]/,\n  'punctuation': /[{}[\\];(),.:]/\n};\nprism.languages.python['string-interpolation'].inside['interpolation'].inside.rest = prism.languages.python;\nprism.languages.py = prism.languages.python;\n/* \"prismjs/components/prism-reason\" */\n\nprism.languages.reason = prism.languages.extend('clike', {\n  'string': {\n    pattern: /\"(?:\\\\(?:\\r\\n|[\\s\\S])|[^\\\\\\r\\n\"])*\"/,\n    greedy: true\n  },\n  // 'class-name' must be matched *after* 'constructor' defined below\n  'class-name': /\\b[A-Z]\\w*/,\n  'keyword': /\\b(?:and|as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|method|module|mutable|new|nonrec|object|of|open|or|private|rec|sig|struct|switch|then|to|try|type|val|virtual|when|while|with)\\b/,\n  'operator': /\\.{3}|:[:=]|\\|>|->|=(?:==?|>)?|<=?|>=?|[|^?'#!~`]|[+\\-*\\/]\\.?|\\b(?:asr|land|lor|lsl|lsr|lxor|mod)\\b/\n});\nprism.languages.insertBefore('reason', 'class-name', {\n  'char': {\n    pattern: /'(?:\\\\x[\\da-f]{2}|\\\\o[0-3][0-7][0-7]|\\\\\\d{3}|\\\\.|[^'\\\\\\r\\n])'/,\n    greedy: true\n  },\n  // Negative look-ahead prevents from matching things like String.capitalize\n  'constructor': /\\b[A-Z]\\w*\\b(?!\\s*\\.)/,\n  'label': {\n    pattern: /\\b[a-z]\\w*(?=::)/,\n    alias: 'symbol'\n  }\n}); // We can't match functions property, so let's not even try.\n\ndelete prism.languages.reason.function;\n/* \"prismjs/components/prism-sass\" */\n\n(function (Prism) {\n  Prism.languages.sass = Prism.languages.extend('css', {\n    // Sass comments don't need to be closed, only indented\n    'comment': {\n      pattern: /^([ \\t]*)\\/[\\/*].*(?:(?:\\r?\\n|\\r)\\1[ \\t].+)*/m,\n      lookbehind: true,\n      greedy: true\n    }\n  });\n  Prism.languages.insertBefore('sass', 'atrule', {\n    // We want to consume the whole line\n    'atrule-line': {\n      // Includes support for = and + shortcuts\n      pattern: /^(?:[ \\t]*)[@+=].+/m,\n      greedy: true,\n      inside: {\n        'atrule': /(?:@[\\w-]+|[+=])/\n      }\n    }\n  });\n  delete Prism.languages.sass.atrule;\n  var variable = /\\$[-\\w]+|#\\{\\$[-\\w]+\\}/;\n  var operator = [/[+*\\/%]|[=!]=|<=?|>=?|\\b(?:and|not|or)\\b/, {\n    pattern: /(\\s)-(?=\\s)/,\n    lookbehind: true\n  }];\n  Prism.languages.insertBefore('sass', 'property', {\n    // We want to consume the whole line\n    'variable-line': {\n      pattern: /^[ \\t]*\\$.+/m,\n      greedy: true,\n      inside: {\n        'punctuation': /:/,\n        'variable': variable,\n        'operator': operator\n      }\n    },\n    // We want to consume the whole line\n    'property-line': {\n      pattern: /^[ \\t]*(?:[^:\\s]+ *:.*|:[^:\\s].*)/m,\n      greedy: true,\n      inside: {\n        'property': [/[^:\\s]+(?=\\s*:)/, {\n          pattern: /(:)[^:\\s]+/,\n          lookbehind: true\n        }],\n        'punctuation': /:/,\n        'variable': variable,\n        'operator': operator,\n        'important': Prism.languages.sass.important\n      }\n    }\n  });\n  delete Prism.languages.sass.property;\n  delete Prism.languages.sass.important; // Now that whole lines for other patterns are consumed,\n  // what's left should be selectors\n\n  Prism.languages.insertBefore('sass', 'punctuation', {\n    'selector': {\n      pattern: /^([ \\t]*)\\S(?:,[^,\\r\\n]+|[^,\\r\\n]*)(?:,[^,\\r\\n]+)*(?:,(?:\\r?\\n|\\r)\\1[ \\t]+\\S(?:,[^,\\r\\n]+|[^,\\r\\n]*)(?:,[^,\\r\\n]+)*)*/m,\n      lookbehind: true,\n      greedy: true\n    }\n  });\n})(prism);\n/* \"prismjs/components/prism-scss\" */\n\nprism.languages.scss = prism.languages.extend('css', {\n  'comment': {\n    pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|\\/\\/.*)/,\n    lookbehind: true\n  },\n  'atrule': {\n    pattern: /@[\\w-](?:\\([^()]+\\)|[^()\\s]|\\s+(?!\\s))*?(?=\\s+[{;])/,\n    inside: {\n      'rule': /@[\\w-]+/ // See rest below\n    }\n  },\n\n  // url, compassified\n  'url': /(?:[-a-z]+-)?url(?=\\()/i,\n  // CSS selector regex is not appropriate for Sass\n  // since there can be lot more things (var, @ directive, nesting..)\n  // a selector must start at the end of a property or after a brace (end of other rules or nesting)\n  // it can contain some characters that aren't used for defining rules or end of selector, & (parent selector), or interpolated variable\n  // the end of a selector is found when there is no rules in it ( {} or {\\s}) or if there is a property (because an interpolated var\n  // can \"pass\" as a selector- e.g: proper#{$erty})\n  // this one was hard to do, so please be careful if you edit this one :)\n  'selector': {\n    // Initial look-ahead is used to prevent matching of blank selectors\n    pattern: /(?=\\S)[^@;{}()]?(?:[^@;{}()\\s]|\\s+(?!\\s)|#\\{\\$[-\\w]+\\})+(?=\\s*\\{(?:\\}|\\s|[^}][^:{}]*[:{][^}]))/,\n    inside: {\n      'parent': {\n        pattern: /&/,\n        alias: 'important'\n      },\n      'placeholder': /%[-\\w]+/,\n      'variable': /\\$[-\\w]+|#\\{\\$[-\\w]+\\}/\n    }\n  },\n  'property': {\n    pattern: /(?:[-\\w]|\\$[-\\w]|#\\{\\$[-\\w]+\\})+(?=\\s*:)/,\n    inside: {\n      'variable': /\\$[-\\w]+|#\\{\\$[-\\w]+\\}/\n    }\n  }\n});\nprism.languages.insertBefore('scss', 'atrule', {\n  'keyword': [/@(?:content|debug|each|else(?: if)?|extend|for|forward|function|if|import|include|mixin|return|use|warn|while)\\b/i, {\n    pattern: /( )(?:from|through)(?= )/,\n    lookbehind: true\n  }]\n});\nprism.languages.insertBefore('scss', 'important', {\n  // var and interpolated vars\n  'variable': /\\$[-\\w]+|#\\{\\$[-\\w]+\\}/\n});\nprism.languages.insertBefore('scss', 'function', {\n  'module-modifier': {\n    pattern: /\\b(?:as|hide|show|with)\\b/i,\n    alias: 'keyword'\n  },\n  'placeholder': {\n    pattern: /%[-\\w]+/,\n    alias: 'selector'\n  },\n  'statement': {\n    pattern: /\\B!(?:default|optional)\\b/i,\n    alias: 'keyword'\n  },\n  'boolean': /\\b(?:false|true)\\b/,\n  'null': {\n    pattern: /\\bnull\\b/,\n    alias: 'keyword'\n  },\n  'operator': {\n    pattern: /(\\s)(?:[-+*\\/%]|[=!]=|<=?|>=?|and|not|or)(?=\\s)/,\n    lookbehind: true\n  }\n});\nprism.languages.scss['atrule'].inside.rest = prism.languages.scss;\n/* \"prismjs/components/prism-stylus\" */\n\n(function (Prism) {\n  var unit = {\n    pattern: /(\\b\\d+)(?:%|[a-z]+)/,\n    lookbehind: true\n  }; // 123 -123 .123 -.123 12.3 -12.3\n\n  var number = {\n    pattern: /(^|[^\\w.-])-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)/,\n    lookbehind: true\n  };\n  var inside = {\n    'comment': {\n      pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|\\/\\/.*)/,\n      lookbehind: true\n    },\n    'url': {\n      pattern: /\\burl\\(([\"']?).*?\\1\\)/i,\n      greedy: true\n    },\n    'string': {\n      pattern: /(\"|')(?:(?!\\1)[^\\\\\\r\\n]|\\\\(?:\\r\\n|[\\s\\S]))*\\1/,\n      greedy: true\n    },\n    'interpolation': null,\n    // See below\n    'func': null,\n    // See below\n    'important': /\\B!(?:important|optional)\\b/i,\n    'keyword': {\n      pattern: /(^|\\s+)(?:(?:else|for|if|return|unless)(?=\\s|$)|@[\\w-]+)/,\n      lookbehind: true\n    },\n    'hexcode': /#[\\da-f]{3,6}/i,\n    'color': [/\\b(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Transparent|Turquoise|Violet|Wheat|White|WhiteSmoke|Yellow|YellowGreen)\\b/i, {\n      pattern: /\\b(?:hsl|rgb)\\(\\s*\\d{1,3}\\s*,\\s*\\d{1,3}%?\\s*,\\s*\\d{1,3}%?\\s*\\)\\B|\\b(?:hsl|rgb)a\\(\\s*\\d{1,3}\\s*,\\s*\\d{1,3}%?\\s*,\\s*\\d{1,3}%?\\s*,\\s*(?:0|0?\\.\\d+|1)\\s*\\)\\B/i,\n      inside: {\n        'unit': unit,\n        'number': number,\n        'function': /[\\w-]+(?=\\()/,\n        'punctuation': /[(),]/\n      }\n    }],\n    'entity': /\\\\[\\da-f]{1,8}/i,\n    'unit': unit,\n    'boolean': /\\b(?:false|true)\\b/,\n    'operator': [\n    // We want non-word chars around \"-\" because it is\n    // accepted in property names.\n    /~|[+!\\/%<>?=]=?|[-:]=|\\*[*=]?|\\.{2,3}|&&|\\|\\||\\B-\\B|\\b(?:and|in|is(?: a| defined| not|nt)?|not|or)\\b/],\n    'number': number,\n    'punctuation': /[{}()\\[\\];:,]/\n  };\n  inside['interpolation'] = {\n    pattern: /\\{[^\\r\\n}:]+\\}/,\n    alias: 'variable',\n    inside: {\n      'delimiter': {\n        pattern: /^\\{|\\}$/,\n        alias: 'punctuation'\n      },\n      rest: inside\n    }\n  };\n  inside['func'] = {\n    pattern: /[\\w-]+\\([^)]*\\).*/,\n    inside: {\n      'function': /^[^(]+/,\n      rest: inside\n    }\n  };\n  Prism.languages.stylus = {\n    'atrule-declaration': {\n      pattern: /(^[ \\t]*)@.+/m,\n      lookbehind: true,\n      inside: {\n        'atrule': /^@[\\w-]+/,\n        rest: inside\n      }\n    },\n    'variable-declaration': {\n      pattern: /(^[ \\t]*)[\\w$-]+\\s*.?=[ \\t]*(?:\\{[^{}]*\\}|\\S.*|$)/m,\n      lookbehind: true,\n      inside: {\n        'variable': /^\\S+/,\n        rest: inside\n      }\n    },\n    'statement': {\n      pattern: /(^[ \\t]*)(?:else|for|if|return|unless)[ \\t].+/m,\n      lookbehind: true,\n      inside: {\n        'keyword': /^\\S+/,\n        rest: inside\n      }\n    },\n    // A property/value pair cannot end with a comma or a brace\n    // It cannot have indented content unless it ended with a semicolon\n    'property-declaration': {\n      pattern: /((?:^|\\{)([ \\t]*))(?:[\\w-]|\\{[^}\\r\\n]+\\})+(?:\\s*:\\s*|[ \\t]+)(?!\\s)[^{\\r\\n]*(?:;|[^{\\r\\n,]$(?!(?:\\r?\\n|\\r)(?:\\{|\\2[ \\t])))/m,\n      lookbehind: true,\n      inside: {\n        'property': {\n          pattern: /^[^\\s:]+/,\n          inside: {\n            'interpolation': inside.interpolation\n          }\n        },\n        rest: inside\n      }\n    },\n    // A selector can contain parentheses only as part of a pseudo-element\n    // It can span multiple lines.\n    // It must end with a comma or an accolade or have indented content.\n    'selector': {\n      pattern: /(^[ \\t]*)(?:(?=\\S)(?:[^{}\\r\\n:()]|::?[\\w-]+(?:\\([^)\\r\\n]*\\)|(?![\\w-]))|\\{[^}\\r\\n]+\\})+)(?:(?:\\r?\\n|\\r)(?:\\1(?:(?=\\S)(?:[^{}\\r\\n:()]|::?[\\w-]+(?:\\([^)\\r\\n]*\\)|(?![\\w-]))|\\{[^}\\r\\n]+\\})+)))*(?:,$|\\{|(?=(?:\\r?\\n|\\r)(?:\\{|\\1[ \\t])))/m,\n      lookbehind: true,\n      inside: {\n        'interpolation': inside.interpolation,\n        'comment': inside.comment,\n        'punctuation': /[{},]/\n      }\n    },\n    'func': inside.func,\n    'string': inside.string,\n    'comment': {\n      pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|\\/\\/.*)/,\n      lookbehind: true,\n      greedy: true\n    },\n    'interpolation': inside.interpolation,\n    'punctuation': /[{}()\\[\\];:.]/\n  };\n})(prism);\n/* \"prismjs/components/prism-tsx\" */\n\n(function (Prism) {\n  var typescript = Prism.util.clone(Prism.languages.typescript);\n  Prism.languages.tsx = Prism.languages.extend('jsx', typescript); // doesn't work with TS because TS is too complex\n\n  delete Prism.languages.tsx['parameter'];\n  delete Prism.languages.tsx['literal-property']; // This will prevent collisions between TSX tags and TS generic types.\n  // Idea by https://github.com/karlhorky\n  // Discussion: https://github.com/PrismJS/prism/issues/2594#issuecomment-710666928\n\n  var tag = Prism.languages.tsx.tag;\n  tag.pattern = RegExp(/(^|[^\\w$]|(?=<\\/))/.source + '(?:' + tag.pattern.source + ')', tag.pattern.flags);\n  tag.lookbehind = true;\n})(prism);\n/* \"prismjs/components/prism-wasm\" */\n\nprism.languages.wasm = {\n  'comment': [/\\(;[\\s\\S]*?;\\)/, {\n    pattern: /;;.*/,\n    greedy: true\n  }],\n  'string': {\n    pattern: /\"(?:\\\\[\\s\\S]|[^\"\\\\])*\"/,\n    greedy: true\n  },\n  'keyword': [{\n    pattern: /\\b(?:align|offset)=/,\n    inside: {\n      'operator': /=/\n    }\n  }, {\n    pattern: /\\b(?:(?:f32|f64|i32|i64)(?:\\.(?:abs|add|and|ceil|clz|const|convert_[su]\\/i(?:32|64)|copysign|ctz|demote\\/f64|div(?:_[su])?|eqz?|extend_[su]\\/i32|floor|ge(?:_[su])?|gt(?:_[su])?|le(?:_[su])?|load(?:(?:8|16|32)_[su])?|lt(?:_[su])?|max|min|mul|neg?|nearest|or|popcnt|promote\\/f32|reinterpret\\/[fi](?:32|64)|rem_[su]|rot[lr]|shl|shr_[su]|sqrt|store(?:8|16|32)?|sub|trunc(?:_[su]\\/f(?:32|64))?|wrap\\/i64|xor))?|memory\\.(?:grow|size))\\b/,\n    inside: {\n      'punctuation': /\\./\n    }\n  }, /\\b(?:anyfunc|block|br(?:_if|_table)?|call(?:_indirect)?|data|drop|elem|else|end|export|func|get_(?:global|local)|global|if|import|local|loop|memory|module|mut|nop|offset|param|result|return|select|set_(?:global|local)|start|table|tee_local|then|type|unreachable)\\b/],\n  'variable': /\\$[\\w!#$%&'*+\\-./:<=>?@\\\\^`|~]+/,\n  'number': /[+-]?\\b(?:\\d(?:_?\\d)*(?:\\.\\d(?:_?\\d)*)?(?:[eE][+-]?\\d(?:_?\\d)*)?|0x[\\da-fA-F](?:_?[\\da-fA-F])*(?:\\.[\\da-fA-F](?:_?[\\da-fA-D])*)?(?:[pP][+-]?\\d(?:_?\\d)*)?)\\b|\\binf\\b|\\bnan(?::0x[\\da-fA-F](?:_?[\\da-fA-D])*)?\\b/,\n  'punctuation': /[()]/\n};\nexport default prism;","import \"core-js/modules/es.array.reduce.js\";\nimport prism from '../prism/index.js';\nexport { default as Prism } from '../prism/index.js';\nimport theme from '../themes/duotoneDark';\nimport { Component } from 'react';\nvar defaultProps = {\n  // $FlowFixMe\n  Prism: prism,\n  theme: theme\n};\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\nvar newlineRe = /\\r\\n|\\r|\\n/; // Empty lines need to contain a single empty token, denoted with { empty: true }\n\nvar normalizeEmptyLines = function normalizeEmptyLines(line) {\n  if (line.length === 0) {\n    line.push({\n      types: [\"plain\"],\n      content: \"\\n\",\n      empty: true\n    });\n  } else if (line.length === 1 && line[0].content === \"\") {\n    line[0].content = \"\\n\";\n    line[0].empty = true;\n  }\n};\nvar appendTypes = function appendTypes(types, add) {\n  var typesSize = types.length;\n  if (typesSize > 0 && types[typesSize - 1] === add) {\n    return types;\n  }\n  return types.concat(add);\n}; // Takes an array of Prism's tokens and groups them by line, turning plain\n// strings into tokens as well. Tokens can become recursive in some cases,\n// which means that their types are concatenated. Plain-string tokens however\n// are always of type \"plain\".\n// This is not recursive to avoid exceeding the call-stack limit, since it's unclear\n// how nested Prism's tokens can become\n\nvar normalizeTokens = function normalizeTokens(tokens) {\n  var typeArrStack = [[]];\n  var tokenArrStack = [tokens];\n  var tokenArrIndexStack = [0];\n  var tokenArrSizeStack = [tokens.length];\n  var i = 0;\n  var stackIndex = 0;\n  var currentLine = [];\n  var acc = [currentLine];\n  while (stackIndex > -1) {\n    while ((i = tokenArrIndexStack[stackIndex]++) < tokenArrSizeStack[stackIndex]) {\n      var content = void 0;\n      var types = typeArrStack[stackIndex];\n      var tokenArr = tokenArrStack[stackIndex];\n      var token = tokenArr[i]; // Determine content and append type to types if necessary\n\n      if (typeof token === \"string\") {\n        types = stackIndex > 0 ? types : [\"plain\"];\n        content = token;\n      } else {\n        types = appendTypes(types, token.type);\n        if (token.alias) {\n          types = appendTypes(types, token.alias);\n        }\n        content = token.content;\n      } // If token.content is an array, increase the stack depth and repeat this while-loop\n\n      if (typeof content !== \"string\") {\n        stackIndex++;\n        typeArrStack.push(types);\n        tokenArrStack.push(content);\n        tokenArrIndexStack.push(0);\n        tokenArrSizeStack.push(content.length);\n        continue;\n      } // Split by newlines\n\n      var splitByNewlines = content.split(newlineRe);\n      var newlineCount = splitByNewlines.length;\n      currentLine.push({\n        types: types,\n        content: splitByNewlines[0]\n      }); // Create a new line for each string on a new line\n\n      for (var i$1 = 1; i$1 < newlineCount; i$1++) {\n        normalizeEmptyLines(currentLine);\n        acc.push(currentLine = []);\n        currentLine.push({\n          types: types,\n          content: splitByNewlines[i$1]\n        });\n      }\n    } // Decreate the stack depth\n\n    stackIndex--;\n    typeArrStack.pop();\n    tokenArrStack.pop();\n    tokenArrIndexStack.pop();\n    tokenArrSizeStack.pop();\n  }\n  normalizeEmptyLines(currentLine);\n  return acc;\n};\nvar themeToDict = function themeToDict(theme, language) {\n  var plain = theme.plain; // $FlowFixMe\n\n  var base = Object.create(null);\n  var themeDict = theme.styles.reduce(function (acc, themeEntry) {\n    var languages = themeEntry.languages;\n    var style = themeEntry.style;\n    if (languages && !languages.includes(language)) {\n      return acc;\n    }\n    themeEntry.types.forEach(function (type) {\n      // $FlowFixMe\n      var accStyle = _extends({}, acc[type], style);\n      acc[type] = accStyle;\n    });\n    return acc;\n  }, base); // $FlowFixMe\n\n  themeDict.root = plain; // $FlowFixMe\n\n  themeDict.plain = _extends({}, plain, {\n    backgroundColor: null\n  });\n  return themeDict;\n};\nfunction objectWithoutProperties(obj, exclude) {\n  var target = {};\n  for (var k in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, k) && exclude.indexOf(k) === -1) target[k] = obj[k];\n  }\n  return target;\n}\nvar Highlight = /*@__PURE__*/function (Component) {\n  function Highlight() {\n    var this$1 = this;\n    var args = [],\n      len = arguments.length;\n    while (len--) {\n      args[len] = arguments[len];\n    }\n    Component.apply(this, args);\n    _defineProperty(this, \"getThemeDict\", function (props) {\n      if (this$1.themeDict !== undefined && props.theme === this$1.prevTheme && props.language === this$1.prevLanguage) {\n        return this$1.themeDict;\n      }\n      this$1.prevTheme = props.theme;\n      this$1.prevLanguage = props.language;\n      var themeDict = props.theme ? themeToDict(props.theme, props.language) : undefined;\n      return this$1.themeDict = themeDict;\n    });\n    _defineProperty(this, \"getLineProps\", function (ref) {\n      var key = ref.key;\n      var className = ref.className;\n      var style = ref.style;\n      var rest$1 = objectWithoutProperties(ref, [\"key\", \"className\", \"style\", \"line\"]);\n      var rest = rest$1;\n      var output = _extends({}, rest, {\n        className: \"token-line\",\n        style: undefined,\n        key: undefined\n      });\n      var themeDict = this$1.getThemeDict(this$1.props);\n      if (themeDict !== undefined) {\n        output.style = themeDict.plain;\n      }\n      if (style !== undefined) {\n        output.style = output.style !== undefined ? _extends({}, output.style, style) : style;\n      }\n      if (key !== undefined) {\n        output.key = key;\n      }\n      if (className) {\n        output.className += \" \" + className;\n      }\n      return output;\n    });\n    _defineProperty(this, \"getStyleForToken\", function (ref) {\n      var types = ref.types;\n      var empty = ref.empty;\n      var typesSize = types.length;\n      var themeDict = this$1.getThemeDict(this$1.props);\n      if (themeDict === undefined) {\n        return undefined;\n      } else if (typesSize === 1 && types[0] === \"plain\") {\n        return empty ? {\n          display: \"inline-block\"\n        } : undefined;\n      } else if (typesSize === 1 && !empty) {\n        return themeDict[types[0]];\n      }\n      var baseStyle = empty ? {\n        display: \"inline-block\"\n      } : {}; // $FlowFixMe\n\n      var typeStyles = types.map(function (type) {\n        return themeDict[type];\n      });\n      return Object.assign.apply(Object, [baseStyle].concat(typeStyles));\n    });\n    _defineProperty(this, \"getTokenProps\", function (ref) {\n      var key = ref.key;\n      var className = ref.className;\n      var style = ref.style;\n      var token = ref.token;\n      var rest$1 = objectWithoutProperties(ref, [\"key\", \"className\", \"style\", \"token\"]);\n      var rest = rest$1;\n      var output = _extends({}, rest, {\n        className: \"token \" + token.types.join(\" \"),\n        children: token.content,\n        style: this$1.getStyleForToken(token),\n        key: undefined\n      });\n      if (style !== undefined) {\n        output.style = output.style !== undefined ? _extends({}, output.style, style) : style;\n      }\n      if (key !== undefined) {\n        output.key = key;\n      }\n      if (className) {\n        output.className += \" \" + className;\n      }\n      return output;\n    });\n    _defineProperty(this, \"tokenize\", function (Prism, code, grammar, language) {\n      var env = {\n        code: code,\n        grammar: grammar,\n        language: language,\n        tokens: []\n      };\n      Prism.hooks.run(\"before-tokenize\", env);\n      var tokens = env.tokens = Prism.tokenize(env.code, env.grammar, env.language);\n      Prism.hooks.run(\"after-tokenize\", env);\n      return tokens;\n    });\n  }\n  if (Component) Highlight.__proto__ = Component;\n  Highlight.prototype = Object.create(Component && Component.prototype);\n  Highlight.prototype.constructor = Highlight;\n  Highlight.prototype.render = function render() {\n    var ref = this.props;\n    var Prism = ref.Prism;\n    var language = ref.language;\n    var code = ref.code;\n    var children = ref.children;\n    var themeDict = this.getThemeDict(this.props);\n    var grammar = Prism.languages[language];\n    var mixedTokens = grammar !== undefined ? this.tokenize(Prism, code, grammar, language) : [code];\n    var tokens = normalizeTokens(mixedTokens);\n    return children({\n      tokens: tokens,\n      className: \"prism-code language-\" + language,\n      style: themeDict !== undefined ? themeDict.root : {},\n      getLineProps: this.getLineProps,\n      getTokenProps: this.getTokenProps\n    });\n  };\n  return Highlight;\n}(Component);\nexport default Highlight;\nexport { defaultProps };","// Duotone Dark\n// Author: Simurai, adapted from DuoTone themes for Atom (http://simurai.com/projects/2016/01/01/duotone-themes)\n// Conversion: Bram de Haan (http://atelierbram.github.io/Base2Tone-prism/output/prism/prism-base2tone-evening-dark.css)\n// Generated with Base16 Builder (https://github.com/base16-builder/base16-builder)\nvar theme = {\n  plain: {\n    backgroundColor: \"#2a2734\",\n    color: \"#9a86fd\"\n  },\n  styles: [{\n    types: [\"comment\", \"prolog\", \"doctype\", \"cdata\", \"punctuation\"],\n    style: {\n      color: \"#6c6783\"\n    }\n  }, {\n    types: [\"namespace\"],\n    style: {\n      opacity: 0.7\n    }\n  }, {\n    types: [\"tag\", \"operator\", \"number\"],\n    style: {\n      color: \"#e09142\"\n    }\n  }, {\n    types: [\"property\", \"function\"],\n    style: {\n      color: \"#9a86fd\"\n    }\n  }, {\n    types: [\"tag-id\", \"selector\", \"atrule-id\"],\n    style: {\n      color: \"#eeebff\"\n    }\n  }, {\n    types: [\"attr-name\"],\n    style: {\n      color: \"#c4b9fe\"\n    }\n  }, {\n    types: [\"boolean\", \"string\", \"entity\", \"url\", \"attr-value\", \"keyword\", \"control\", \"directive\", \"unit\", \"statement\", \"regex\", \"atrule\", \"placeholder\", \"variable\"],\n    style: {\n      color: \"#ffcc99\"\n    }\n  }, {\n    types: [\"deleted\"],\n    style: {\n      textDecorationLine: \"line-through\"\n    }\n  }, {\n    types: [\"inserted\"],\n    style: {\n      textDecorationLine: \"underline\"\n    }\n  }, {\n    types: [\"italic\"],\n    style: {\n      fontStyle: \"italic\"\n    }\n  }, {\n    types: [\"important\", \"bold\"],\n    style: {\n      fontWeight: \"bold\"\n    }\n  }, {\n    types: [\"important\"],\n    style: {\n      color: \"#c4b9fe\"\n    }\n  }]\n};\nexport default theme;","// Original: https://github.com/sdras/night-owl-vscode-theme\n// Converted automatically using ./tools/themeFromVsCode\nvar theme = {\n  plain: {\n    color: \"#d6deeb\",\n    backgroundColor: \"#011627\"\n  },\n  styles: [{\n    types: [\"changed\"],\n    style: {\n      color: \"rgb(162, 191, 252)\",\n      fontStyle: \"italic\"\n    }\n  }, {\n    types: [\"deleted\"],\n    style: {\n      color: \"rgba(239, 83, 80, 0.56)\",\n      fontStyle: \"italic\"\n    }\n  }, {\n    types: [\"inserted\", \"attr-name\"],\n    style: {\n      color: \"rgb(173, 219, 103)\",\n      fontStyle: \"italic\"\n    }\n  }, {\n    types: [\"comment\"],\n    style: {\n      color: \"rgb(99, 119, 119)\",\n      fontStyle: \"italic\"\n    }\n  }, {\n    types: [\"string\", \"url\"],\n    style: {\n      color: \"rgb(173, 219, 103)\"\n    }\n  }, {\n    types: [\"variable\"],\n    style: {\n      color: \"rgb(214, 222, 235)\"\n    }\n  }, {\n    types: [\"number\"],\n    style: {\n      color: \"rgb(247, 140, 108)\"\n    }\n  }, {\n    types: [\"builtin\", \"char\", \"constant\", \"function\"],\n    style: {\n      color: \"rgb(130, 170, 255)\"\n    }\n  }, {\n    // This was manually added after the auto-generation\n    // so that punctuations are not italicised\n    types: [\"punctuation\"],\n    style: {\n      color: \"rgb(199, 146, 234)\"\n    }\n  }, {\n    types: [\"selector\", \"doctype\"],\n    style: {\n      color: \"rgb(199, 146, 234)\",\n      fontStyle: \"italic\"\n    }\n  }, {\n    types: [\"class-name\"],\n    style: {\n      color: \"rgb(255, 203, 139)\"\n    }\n  }, {\n    types: [\"tag\", \"operator\", \"keyword\"],\n    style: {\n      color: \"rgb(127, 219, 202)\"\n    }\n  }, {\n    types: [\"boolean\"],\n    style: {\n      color: \"rgb(255, 88, 116)\"\n    }\n  }, {\n    types: [\"property\"],\n    style: {\n      color: \"rgb(128, 203, 196)\"\n    }\n  }, {\n    types: [\"namespace\"],\n    style: {\n      color: \"rgb(178, 204, 214)\"\n    }\n  }]\n};\nexport default theme;","import React, { useState } from 'react';\n\nimport Highlight, { defaultProps } from 'prism-react-renderer';\nimport Prism from 'prism-react-renderer/prism';\nimport theme from 'prism-react-renderer/themes/nightOwl';\nimport CopyToClipboard from 'react-copy-to-clipboard';\n\nimport csharpLang from 'refractor/lang/csharp';\nimport rubyLang from 'refractor/lang/ruby';\nimport swiftLang from 'refractor/lang/swift';\n\ncsharpLang(Prism);\nrubyLang(Prism);\nswiftLang(Prism);\n\nimport './styles.scss'\n\ninterface CodeHighlightProps {\n  language?: any;\n  code: string;\n}\n\nconst CodeHighlight: React.FC<CodeHighlightProps> = ({language, code}) => {\n  const [codeCopied, setCodeCopied] = useState(false);\n\n  const copyCode = () => {\n    setCodeCopied(true)\n    setTimeout(()=> setCodeCopied(false), 5000)\n  }\n\n  return (\n    <div className=\"code-wrapper\">\n      <CopyToClipboard\n        text={code}\n        onCopy={() => copyCode() }\n      >\n        <button className={`copy-btn ${codeCopied && 'copy-btn--copied'}`}>{codeCopied ? 'Copiado!' : 'Copiar'}</button>\n      </CopyToClipboard>\n      <Highlight\n        {...defaultProps}\n        code={code}\n        language={language ? language : ''}\n        Prism={Prism}\n        theme={theme}\n      >\n        {({ className, style, tokens, getLineProps, getTokenProps }) => (\n          <pre className={className} style={style}>\n            {tokens.slice(0, -1).map((line, i) => (\n              <div {...getLineProps({ line, key: i })} key={i}>\n                {line.map((token, key) => (\n                  <span {...getTokenProps({ token, key })} key={key} />\n                ))}\n              </div>\n            ))}\n          </pre>\n        )}\n      </Highlight>\n    </div>\n  )\n}\n\nexport default CodeHighlight\n","const langDict: any = {\n  'actionscript': 'ActionScript',\n  'bash': 'Bash',\n  'c': 'C',\n  'clike': 'C',\n  'coffeescript': 'CoffeeScript',\n  'cpp': 'C++',\n  'csharp': 'C#',\n  'css': 'CSS',\n  'css-extr': 'CSS',\n  'diff': 'Diff',\n  'dotnet': '.NET',\n  'git': 'Git',\n  'go': 'Go',\n  'graphql': 'GraphQL',\n  'handlebars': 'Handlebars',\n  'java': 'Java',\n  'javascript': 'Javascript',\n  'json': 'JSON',\n  'jsx': 'JSX',\n  'less': 'Less',\n  'makefile': 'Makefile',\n  'markdown': 'Markdown',\n  'markup': 'Markup',\n  'objectivec': 'Objective-C',\n  'ocaml': 'OCaml',\n  'php': 'PHP',\n  'python': 'Python',\n  'reason': 'Reason',\n  'ruby': 'Ruby',\n  'sass': 'Sass',\n  'scss': 'Scss',\n  'sql': 'SQL',\n  'stylus': 'Stylus',\n  'swift': 'Swift',\n  'tsx': 'TSX',\n  'typescript': 'Typescript',\n  'wasm': 'WebAssembly',\n  'yaml': 'YAML',\n}\n\nexport default langDict\n","import React, { useContext, useEffect, useState } from 'react'\nimport TabsContext from '../../context/TabsContext'\nimport CodeHighlight from '../CodeHighlight/CodeHighlight'\nimport langDict from './langDict'\nimport './styles.scss'\n\ninterface CodeTab {\n  code: string;\n  lang: string;\n  tabName: string;\n\n}\n\ninterface Animation {\n  direction: string | null;\n  index: number | null\n}\n\ninterface CodeTabsProps {\n  children: React.ReactNode[],\n  group?: string;\n}\n\nconst animationsInitialState = {\n  fadeIn: {\n    direction: null,\n    index: null,\n  },\n  fadeOut: {\n    direction: null,\n    index: null,\n  }\n}\n\nconst CodeTabs: React.FC<CodeTabsProps> = ({children, group}) => {\n  const tabs: CodeTab[] = [];\n\n  if(Array.isArray(children)) {\n    children.map((child: any) => {\n      const childrenProps = child.props.children.props;\n      const className = childrenProps.className || ''\n      const matches = className.match(/language-(?<lang>.*)/)\n\n      const lang = matches.groups.lang;\n\n      tabs.push({\n        code: childrenProps.children,\n        lang,\n        tabName: langDict[lang],\n      })\n    });\n  } else {\n    const childrenProps = children.props.children.props;\n    const className = childrenProps.className || ''\n    const matches = className.match(/language-(?<lang>.*)/)\n\n    const lang = matches.groups.lang;\n\n    tabs.push({\n      code: childrenProps.children,\n      lang,\n      tabName: langDict[lang],\n    })\n  }\n\n\n\n  const tabsContext = useContext(TabsContext);\n  const [selectedTabIndex, setSelectedTabIndex] = useState(0)\n\n  useEffect(() => {\n    if(group && tabsContext.preferredTabs[group]) {\n      tabs.forEach((tab, index) => {\n        if(tab.lang === tabsContext.preferredTabs[group]) {\n          setSelectedTabIndex(index)\n        }\n      })\n    }\n  });\n\n  let animations: {[key: string]: Animation} = animationsInitialState\n\n  const selectTab = (tab: CodeTab, newIndex: number) : void => {\n    if(newIndex !== selectedTabIndex) {\n      animations.fadeIn.direction =  selectedTabIndex > newIndex ? 'left' : 'right';\n      animations.fadeOut.direction =  selectedTabIndex > newIndex ? 'right' : 'left';\n\n      animations.fadeIn.index = newIndex\n      animations.fadeOut.index = selectedTabIndex\n\n      setSelectedTabIndex(newIndex)\n      tabsContext.setPreferredTab(tab.lang, group)\n\n      setTimeout(()=> resetAnimation(), 400)\n    }\n  }\n\n  const resetAnimation = () => {animations = {...animationsInitialState}}\n\n  return (\n    <div className=\"code-tabs\">\n      <ul className=\"code-tabs__wrapper\">\n        {\n          tabs.map((tab, i) =>\n            <li\n              className={`code-tab ${selectedTabIndex === i && 'code-tab--selected'}`}\n              key={`${tab.tabName}-${tab.lang}`}\n              onClick={() => {\n                selectTab(tab, i)\n              }}\n            >\n              {tab.tabName}\n            </li>\n          )\n        }\n      </ul>\n\n      <div className=\"code-tabs__content-wrapper\">\n        {\n          tabs.map((tab, i) =>\n            <div\n              className={`\n                code-tabs__content\n                ${selectedTabIndex === i && 'code-tabs__content--selected'}\n                ${animations.fadeIn.index === i && 'code-tabs__content--fadeIn'}\n                ${animations.fadeOut.index === i && 'code-tabs__content--fadeOut'}\n                ${animations.fadeIn.index === i && animations.fadeIn.direction}\n                ${animations.fadeOut.index === i && animations.fadeOut.direction}\n              `}\n              key={tab.lang}\n            >\n              <CodeHighlight\n                code={tab.code}\n                language={tab.lang}\n              />\n            </div>\n          )\n        }\n      </div>\n\n    </div>\n  )\n}\n\nexport default CodeTabs\n","import React from 'react'\nimport CountryContext from '../../context/CountryContext'\ninterface CountryContentProps {\n  children?: React.ReactNode\n  only?: string[]\n  except?: string[]\n}\n\nconst CountryContent: React.FC<CountryContentProps> = ({\n  children,\n  only,\n  except\n}) => (\n  <CountryContext.Consumer>\n    {country => {\n      let display = false\n\n      if(only && only.includes(country)) {\n        display = true\n      }\n\n      if(except && !except.includes(country)) {\n        display = true\n      }\n\n      return display ? children : <></>\n    }}\n  </CountryContext.Consumer>\n)\n\nexport default CountryContent\n","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArrayLimit from \"./iterableToArrayLimit.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\nexport default function _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}","export default function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}","export default function _iterableToArrayLimit(arr, i) {\n  var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"];\n  if (_i == null) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _s, _e;\n  try {\n    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n  return _arr;\n}","export default function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","import _objectWithoutProperties from \"/codebuild/output/src3819837428/src/kushki-docs/node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js\";\nimport _defineProperty from \"/codebuild/output/src3819837428/src/kushki-docs/node_modules/@babel/runtime/helpers/esm/defineProperty.js\";\nimport _createClass from \"/codebuild/output/src3819837428/src/kushki-docs/node_modules/@babel/runtime/helpers/esm/createClass.js\";\nimport _classCallCheck from \"/codebuild/output/src3819837428/src/kushki-docs/node_modules/@babel/runtime/helpers/esm/classCallCheck.js\";\nimport _toConsumableArray from \"/codebuild/output/src3819837428/src/kushki-docs/node_modules/@babel/runtime/helpers/esm/toConsumableArray.js\";\nimport _slicedToArray from \"/codebuild/output/src3819837428/src/kushki-docs/node_modules/@babel/runtime/helpers/esm/slicedToArray.js\";\nvar _excluded = [\"children\", \"renderLayer\", \"placement\", \"onStyle\", \"isOpen\", \"closeOnOutsideClick\", \"onOutsideClick\", \"onDisappear\", \"closeOnDisappear\", \"fixed\", \"container\", \"environment\"],\n  _excluded2 = [\"onStyle\", \"closeOnOutsideClick\", \"closeOnDisappear\", \"fixed\", \"container\", \"placement\", \"environment\"],\n  _excluded3 = [\"delayEnter\", \"delayLeave\", \"hideOnScroll\"];\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\nimport \"core-js/modules/es.array.reduce.js\";\nimport \"core-js/modules/es.array.sort.js\";\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\nimport React, { useEffect, useMemo, useLayoutEffect, useRef, useState, useCallback, createElement, Fragment } from 'react';\nimport { createPortal } from 'react-dom';\nfunction useEvent(element, event, callback) {\n  var enabled = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;\n  var capture = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n  return useEffect(function () {\n    if (!enabled || !element) {\n      return;\n    }\n    var cb = callback;\n    var el = Array.isArray(element) ? element : [element];\n    var ev = Array.isArray(event) ? event : [event];\n    el.forEach(function (e) {\n      ev.forEach(function (event) {\n        e.addEventListener(event, cb, capture);\n      });\n    });\n    return function () {\n      el.forEach(function (e) {\n        ev.forEach(function (event) {\n          e.removeEventListener(event, cb, capture);\n        });\n      });\n    };\n  }, [callback, element, enabled, event, capture]);\n}\nvar OutsideClickContext = /*#__PURE__*/React.createContext({});\nfunction isChildOf(parent, target) {\n  if (parent === target) {\n    return true;\n  }\n  var hasChildren = parent.children && parent.children.length > 0;\n  if (hasChildren) {\n    // tslint:disable-next-line\n    for (var i = 0; i < parent.children.length; i++) {\n      var child = parent.children[i];\n      if (child && isChildOf(child, target)) {\n        return true;\n      }\n    }\n  }\n  return false;\n}\nfunction OutsideClickGroupProvider(_ref) {\n  var refs = _ref.refs,\n    children = _ref.children;\n  var isPartOfGroup = typeof React.useContext(OutsideClickContext) === \"function\";\n  if (isPartOfGroup) {\n    return children;\n  }\n  return /*#__PURE__*/React.createElement(OutsideClickContext.Provider, {\n    value: React.useCallback(function (layerRef) {\n      refs.current.add(layerRef);\n    }, [])\n  }, children);\n}\nfunction useRegisterGroup(refs) {\n  var registerRefToGroup = React.useContext(OutsideClickContext);\n  React.useEffect(function () {\n    var _refs$current$values = refs.current.values(),\n      _refs$current$values2 = _slicedToArray(_refs$current$values, 1),\n      layerRef = _refs$current$values2[0];\n    if (typeof registerRefToGroup === \"function\" && layerRef) {\n      registerRefToGroup(layerRef);\n    }\n  }, [registerRefToGroup, refs]);\n}\nfunction useOutsideClick(refs, callback) {\n  var _React$useState = React.useState([\"click\"]),\n    _React$useState2 = _slicedToArray(_React$useState, 1),\n    events = _React$useState2[0];\n  useRegisterGroup(refs);\n  useEvent(typeof document !== \"undefined\" ? document : null, events, React.useCallback(function (evt) {\n    var _iterator = _createForOfIteratorHelper(refs.current),\n      _step;\n    try {\n      for (_iterator.s(); !(_step = _iterator.n()).done;) {\n        var ref = _step.value;\n        if (!ref.current) {\n          continue;\n        }\n        if (isChildOf(ref.current, evt.target)) {\n          return;\n        }\n      }\n    } catch (err) {\n      _iterator.e(err);\n    } finally {\n      _iterator.f();\n    }\n    callback();\n  }, [callback]), true, true);\n}\nfunction useOnScroll(elements, onScroll, environment) {\n  var trackScroll = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;\n  var memoElements = useMemo(function () {\n    return typeof environment !== \"undefined\" ? [environment].concat(_toConsumableArray(elements)) : [];\n  }, [elements]);\n  useEvent(memoElements, \"scroll\", onScroll, trackScroll);\n}\nfunction useOnWindowResize(onResize, environment) {\n  var trackResize = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n  useEvent(typeof environment !== \"undefined\" ? environment : null, \"resize\", onResize, trackResize);\n}\nvar useIsomorphicLayoutEffect = typeof window !== \"undefined\" ? useLayoutEffect : useEffect;\nfunction useTrackElementResize(injectedResizeObserver, layerRef, triggerElement, isOpen, callback, environment) {\n  var callbackRef = useRef(callback);\n  callbackRef.current = callback;\n  var ResizeObserver = injectedResizeObserver || (typeof environment === \"undefined\" ? /*#__PURE__*/_createClass(function ResizeObserver() {\n    _classCallCheck(this, ResizeObserver);\n  }) : environment.ResizeObserver);\n  if (!ResizeObserver) {\n    throw new Error(\"This browser does not support `ResizeObserver` out of the box. Please provide a polyfill as a prop.\");\n  }\n  var resizeObserver = useRef(new ResizeObserver(function () {\n    if (layerRef.current) {\n      callbackRef.current();\n    }\n  }));\n  useIsomorphicLayoutEffect(function () {\n    if (isOpen) {\n      if (triggerElement) {\n        resizeObserver.current.observe(triggerElement);\n      }\n    } else {\n      if (triggerElement) {\n        resizeObserver.current.unobserve(triggerElement);\n      }\n      if (layerRef.current) {\n        resizeObserver.current.unobserve(layerRef.current);\n      }\n    }\n  }, [isOpen, triggerElement]);\n  useEffect(function () {\n    return function () {\n      resizeObserver.current.disconnect();\n    };\n  }, []);\n  return resizeObserver.current;\n}\nvar EMPTY_STYLE = {};\nfunction isSet(value) {\n  return value !== undefined && value !== null;\n}\nfunction areStylesTheSame(a, b) {\n  var aKeys = Object.keys(a);\n  var bKeys = Object.keys(b);\n  if (aKeys.length !== bKeys.length) {\n    return false;\n  }\n  for (var i = 0; i < Math.max(aKeys.length, bKeys.length); i++) {\n    var key = aKeys[i] || bKeys[i];\n    if (a[key] !== b[key]) {\n      return false;\n    }\n  }\n  return true;\n}\nfunction shouldUpdateStyles(prev, next) {\n  if (areStylesTheSame(prev.layer, next.layer) && areStylesTheSame(prev.arrow, next.arrow)) {\n    return false;\n  }\n  return true;\n} // creates a ClientRect-like object from the viewport's dimensions\n\nfunction getWindowClientRect(environment) {\n  return {\n    top: 0,\n    left: 0,\n    right: environment ? environment.innerWidth : 0,\n    bottom: environment ? environment.innerHeight : 0,\n    height: environment ? environment.innerHeight : 0,\n    width: environment ? environment.innerWidth : 0\n  };\n}\nvar convertFloat = function convertFloat(value) {\n  return parseFloat(value.replace(\"px\", \"\"));\n}; // get the outer width / height of an element\n// We effectively want the same width / height that `getBoundingClientRect()`\n// gives, minus optional `scale` transforms\n\nfunction getContentBox(element, environment) {\n  if (!environment) {\n    return {\n      width: 0,\n      height: 0\n    };\n  }\n  var _environment$getCompu = environment.getComputedStyle(element),\n    width = _environment$getCompu.width,\n    height = _environment$getCompu.height,\n    boxSizing = _environment$getCompu.boxSizing,\n    borderLeft = _environment$getCompu.borderLeft,\n    borderRight = _environment$getCompu.borderRight,\n    borderTop = _environment$getCompu.borderTop,\n    borderBottom = _environment$getCompu.borderBottom,\n    paddingLeft = _environment$getCompu.paddingLeft,\n    paddingRight = _environment$getCompu.paddingRight,\n    paddingTop = _environment$getCompu.paddingTop,\n    paddingBottom = _environment$getCompu.paddingBottom;\n  return {\n    width: boxSizing === \"border-box\" ? convertFloat(width) : [width, borderLeft, borderRight, paddingLeft, paddingRight].reduce(function (total, value) {\n      return total + (value ? convertFloat(value) : 0);\n    }, 0),\n    height: boxSizing === \"border-box\" ? convertFloat(height) : [height, borderTop, borderBottom, paddingTop, paddingBottom].reduce(function (total, value) {\n      return total + (value ? convertFloat(value) : 0);\n    }, 0)\n  };\n} // converts a ClientRect (or DOMRect) to a plain js-object\n// usefull for destructuring for instance\n\nfunction clientRectToObject(clientRect) {\n  return {\n    top: clientRect.top,\n    left: clientRect.left,\n    right: clientRect.right,\n    bottom: clientRect.bottom,\n    width: clientRect.width,\n    height: clientRect.height\n  };\n}\nfunction getElementFromAnchorNode(anchorNode) {\n  var currentElement = anchorNode;\n  while (!currentElement.getBoundingClientRect) {\n    if (!currentElement.parentElement) {\n      return null;\n    }\n    currentElement = currentElement.parentElement;\n  }\n  return currentElement;\n}\nfunction minMax(value, _ref2) {\n  var min = _ref2.min,\n    max = _ref2.max;\n  return value < min ? min : value > max ? max : value;\n}\nfunction useStyleState(anchor) {\n  var _useState = useState({\n      layer: EMPTY_STYLE,\n      arrow: EMPTY_STYLE,\n      layerSide: anchor.split(\"_\")[0].toLowerCase()\n    }),\n    _useState2 = _slicedToArray(_useState, 1),\n    INITIAL_STYLES = _useState2[0];\n  var _useState3 = useState(INITIAL_STYLES),\n    _useState4 = _slicedToArray(_useState3, 2),\n    styles = _useState4[0],\n    setStyles = _useState4[1];\n  var lastStyles = useRef(styles);\n  return {\n    styles: styles,\n    lastStyles: lastStyles,\n    setStyles: setStyles,\n    resetLastStyles: function resetLastStyles() {\n      lastStyles.current = INITIAL_STYLES;\n    }\n  };\n}\nvar Anchor = {\n  BOTTOM_LEFT: \"BOTTOM_LEFT\",\n  BOTTOM_RIGHT: \"BOTTOM_RIGHT\",\n  BOTTOM_CENTER: \"BOTTOM_CENTER\",\n  TOP_LEFT: \"TOP_LEFT\",\n  TOP_CENTER: \"TOP_CENTER\",\n  TOP_RIGHT: \"TOP_RIGHT\",\n  LEFT_BOTTOM: \"LEFT_BOTTOM\",\n  LEFT_CENTER: \"LEFT_CENTER\",\n  LEFT_TOP: \"LEFT_TOP\",\n  RIGHT_BOTTOM: \"RIGHT_BOTTOM\",\n  RIGHT_CENTER: \"RIGHT_CENTER\",\n  RIGHT_TOP: \"RIGHT_TOP\"\n};\nvar POSSIBLE_ANCHORS = Object.keys(Anchor);\nfunction getPrimaryDirection(anchor) {\n  return anchor.startsWith(\"TOP_\") || anchor.startsWith(\"BOTTOM_\") ? \"Y\" : \"X\";\n}\nfunction primaryIsY(primary) {\n  return primary === \"TOP\" || primary === \"BOTTOM\";\n}\nfunction getPrimaryByIndex(index, preferedPrimary, preferedX, preferedY) {\n  var prefferedIsY = primaryIsY(preferedPrimary);\n  if (index < 3) {\n    return preferedPrimary;\n  }\n  if (index < 6) {\n    return prefferedIsY ? preferedX : preferedY;\n  }\n  if (index < 9) {\n    if (prefferedIsY) {\n      return [\"LEFT\", \"RIGHT\"].filter(function (x) {\n        return x !== preferedX;\n      })[0];\n    } else {\n      return [\"TOP\", \"BOTTOM\"].filter(function (x) {\n        return x !== preferedY;\n      })[0];\n    }\n  }\n  if (prefferedIsY) {\n    return [\"TOP\", \"BOTTOM\"].filter(function (x) {\n      return x !== preferedPrimary;\n    })[0];\n  } else {\n    return [\"LEFT\", \"RIGHT\"].filter(function (x) {\n      return x !== preferedPrimary;\n    })[0];\n  }\n}\nfunction getSecondaryByIndex(index, preferedPrimary, preferedSecondary, rects) {\n  var prefferedIsY = primaryIsY(preferedPrimary);\n  var triggerHasBiggerHeight = rects.trigger.height > rects.layer.height;\n  var triggerHasBiggerWidth = rects.trigger.width > rects.layer.width;\n  switch (index) {\n    case 9:\n    case 0:\n      return preferedSecondary;\n    case 1:\n    case 10:\n      {\n        if (preferedSecondary === \"CENTER\") {\n          return prefferedIsY ? \"RIGHT\" : \"BOTTOM\";\n        }\n        return \"CENTER\";\n      }\n    case 4:\n    case 7:\n      return \"CENTER\";\n    case 2:\n    case 11:\n      {\n        if (prefferedIsY) {\n          return [\"LEFT\", \"RIGHT\"].filter(function (x) {\n            return x !== preferedSecondary;\n          })[0];\n        } else {\n          return [\"TOP\", \"BOTTOM\"].filter(function (x) {\n            return x !== preferedSecondary;\n          })[0];\n        }\n      }\n    case 3:\n    case 6:\n      {\n        if (prefferedIsY) {\n          return preferedPrimary === \"BOTTOM\" ? triggerHasBiggerHeight ? \"BOTTOM\" : \"TOP\" : triggerHasBiggerHeight ? \"TOP\" : \"BOTTOM\";\n        }\n        return preferedPrimary === \"LEFT\" ? triggerHasBiggerWidth ? \"LEFT\" : \"RIGHT\" : triggerHasBiggerWidth ? \"RIGHT\" : \"LEFT\";\n      }\n    case 5:\n    case 8:\n      {\n        if (prefferedIsY) {\n          return preferedPrimary === \"BOTTOM\" ? triggerHasBiggerHeight ? \"TOP\" : \"BOTTOM\" : triggerHasBiggerHeight ? \"BOTTOM\" : \"TOP\";\n        }\n        return preferedPrimary === \"LEFT\" ? triggerHasBiggerWidth ? \"RIGHT\" : \"LEFT\" : triggerHasBiggerWidth ? \"LEFT\" : \"RIGHT\";\n      }\n  }\n  /* istanbul ignore next */\n\n  return \"LEFT\";\n}\nfunction getSecondaryAnchorOptionsByPrimary(primary, anchorOptions) {\n  return anchorOptions.filter(function (anchor) {\n    return anchor.startsWith(primary);\n  });\n}\nfunction splitAnchor(anchor) {\n  var _anchor$split = anchor.split(\"_\"),\n    _anchor$split2 = _slicedToArray(_anchor$split, 2),\n    primary = _anchor$split2[0],\n    secondary = _anchor$split2[1];\n  return {\n    primary: primary,\n    secondary: secondary\n  };\n}\nfunction getLayerSideByAnchor(anchor) {\n  if (anchor === \"CENTER\") {\n    return \"center\";\n  }\n  return splitAnchor(anchor).primary.toLowerCase();\n}\nfunction getAnchorPriority(preferedAnchor, possibleAnchors, preferedX, preferedY, rects) {\n  var _ref3 = preferedAnchor !== \"CENTER\" ? splitAnchor(preferedAnchor) : {\n      primary: preferedY,\n      secondary: \"CENTER\"\n    },\n    primary = _ref3.primary,\n    secondary = _ref3.secondary;\n  var anchors = POSSIBLE_ANCHORS.map(function (_, index) {\n    return getPrimaryByIndex(index, primary, preferedX, preferedY) + \"_\" + getSecondaryByIndex(index, primary, secondary, rects);\n  }).filter(function (anchor) {\n    return possibleAnchors.indexOf(anchor) > -1;\n  }); // include prefered anchor if not included in possibleAnchors\n\n  if (anchors.indexOf(preferedAnchor) === -1) {\n    /* istanbul ignore next */\n    anchors = [preferedAnchor].concat(_toConsumableArray(anchors));\n  }\n  return anchors;\n}\nfunction getPrimaryStyle(primary, rects, scroll, triggerOffset) {\n  var prop = primary === \"TOP\" || primary === \"BOTTOM\" ? \"top\" : \"left\";\n  var size = primary === \"TOP\" || primary === \"BOTTOM\" ? \"height\" : \"width\";\n  if (primary === \"TOP\" || primary === \"LEFT\") {\n    return _defineProperty({}, prop, rects.trigger[prop] - rects.layer[size] - (rects.relativeParent[prop] - scroll[prop]) - triggerOffset);\n  }\n  return _defineProperty({}, prop, rects.trigger[prop] + rects.trigger[size] - (rects.relativeParent[prop] - scroll[prop]) + triggerOffset);\n}\nfunction getCenter(rects, scroll, offsetSecondary, prop, size) {\n  return minMax(rects.trigger[prop] - rects.relativeParent[prop] + scroll[prop] + rects.trigger[size] / 2 - rects.layer[size] / 2 - offsetSecondary, getLimits(rects, scroll)[prop]);\n}\nfunction getLimits(rects, scroll) {\n  var topBase = rects.trigger.top - rects.relativeParent.top + scroll.top;\n  var leftBase = rects.trigger.left - rects.relativeParent.left + scroll.left;\n  return {\n    top: {\n      min: topBase - (rects.layer.height - rects.arrow.height),\n      max: topBase + (rects.trigger.height - rects.arrow.height)\n    },\n    left: {\n      min: leftBase - (rects.layer.width - rects.arrow.width),\n      max: leftBase + (rects.trigger.width - rects.arrow.width)\n    }\n  };\n}\nfunction getSecondaryStyle(secondary, rects, scroll, offsetSecondary, primaryDirection) {\n  if (secondary === \"CENTER\") {\n    var _prop = primaryDirection === \"X\" ? \"top\" : \"left\";\n    var _size = primaryDirection === \"X\" ? \"height\" : \"width\";\n    return _defineProperty({}, _prop, getCenter(rects, scroll, offsetSecondary, _prop, _size));\n  }\n  var prop = secondary === \"TOP\" || secondary === \"BOTTOM\" ? \"top\" : \"left\";\n  var size = secondary === \"TOP\" || secondary === \"BOTTOM\" ? \"height\" : \"width\";\n  if (secondary === \"TOP\" || secondary === \"LEFT\") {\n    return _defineProperty({}, prop, minMax(rects.trigger[prop] - rects.relativeParent[prop] + scroll[prop] + offsetSecondary, getLimits(rects, scroll)[prop]));\n  }\n  return _defineProperty({}, prop, minMax(rects.trigger[prop] + rects.trigger[size] - rects.layer[size] - (rects.relativeParent[prop] - scroll[prop]) - offsetSecondary, getLimits(rects, scroll)[prop]));\n}\nfunction getAbsolutePositions(_ref9) {\n  var anchor = _ref9.anchor,\n    rects = _ref9.rects,\n    triggerOffset = _ref9.triggerOffset,\n    offsetSecondary = _ref9.offsetSecondary,\n    scrollLeft = _ref9.scrollLeft,\n    scrollTop = _ref9.scrollTop;\n  var scroll = {\n    left: scrollLeft,\n    top: scrollTop\n  };\n  if (anchor === \"CENTER\") {\n    return {\n      top: getCenter(rects, scroll, 0, \"top\", \"height\"),\n      left: getCenter(rects, scroll, 0, \"left\", \"width\")\n    };\n  }\n  var _splitAnchor = splitAnchor(anchor),\n    primary = _splitAnchor.primary,\n    secondary = _splitAnchor.secondary;\n  var primaryDirection = getPrimaryDirection(anchor);\n  return _objectSpread(_objectSpread({}, getPrimaryStyle(primary, rects, scroll, triggerOffset)), getSecondaryStyle(secondary, rects, scroll, offsetSecondary, primaryDirection));\n}\n\n// anticipate the width / height based on the current anchor\n\nfunction fixLayerDimensions(originalLayer, anchor, layerDimensions) {\n  var dimensions = typeof layerDimensions === \"function\" ? layerDimensions(getLayerSideByAnchor(anchor)) : layerDimensions;\n  return _objectSpread(_objectSpread({}, clientRectToObject(originalLayer)), dimensions);\n}\nvar propMap = {\n  TOP: {\n    side1: \"bottom\",\n    side2: \"top\",\n    size: \"height\",\n    factor: -1\n  },\n  BOTTOM: {\n    side1: \"top\",\n    side2: \"bottom\",\n    size: \"height\",\n    factor: 1\n  },\n  LEFT: {\n    side1: \"right\",\n    side2: \"left\",\n    size: \"width\",\n    factor: -1\n  },\n  RIGHT: {\n    side1: \"left\",\n    side2: \"right\",\n    size: \"width\",\n    factor: 1\n  }\n};\nfunction getPrimaryRect(primary, trigger, layer, triggerOffset) {\n  var _ref10;\n  var _propMap$primary = propMap[primary],\n    side1 = _propMap$primary.side1,\n    side2 = _propMap$primary.side2,\n    size = _propMap$primary.size,\n    factor = _propMap$primary.factor;\n  var value = trigger[side2] + triggerOffset * factor;\n  return _ref10 = {}, _defineProperty(_ref10, side1, value), _defineProperty(_ref10, side2, value + layer[size] * factor), _ref10;\n}\nfunction getCenter$1(trigger, layer, offsetSecondary, prop, size) {\n  var _ref11;\n  var value = trigger[prop] + trigger[size] / 2 - layer[size] / 2 - offsetSecondary;\n  return _ref11 = {}, _defineProperty(_ref11, prop, value), _defineProperty(_ref11, prop === \"left\" ? \"right\" : \"bottom\", value + layer[size]), _ref11;\n}\nfunction getSecondaryRect(secondary, trigger, layer, offsetSecondary, primaryDirection) {\n  var _ref12;\n  if (secondary === \"CENTER\") {\n    var prop = primaryDirection === \"X\" ? \"top\" : \"left\";\n    var _size2 = primaryDirection === \"X\" ? \"height\" : \"width\";\n    return getCenter$1(trigger, layer, offsetSecondary, prop, _size2);\n  }\n  var _propMap$secondary = propMap[secondary],\n    side1 = _propMap$secondary.side1,\n    side2 = _propMap$secondary.side2,\n    size = _propMap$secondary.size,\n    factor = _propMap$secondary.factor;\n  var value = trigger[side2] - offsetSecondary * factor;\n  return _ref12 = {}, _defineProperty(_ref12, side2, value), _defineProperty(_ref12, side1, value - layer[size] * factor), _ref12;\n}\nfunction getLayerRectByAnchor(_ref13) {\n  var trigger = _ref13.trigger,\n    layer = _ref13.layer,\n    anchor = _ref13.anchor,\n    triggerOffset = _ref13.triggerOffset,\n    _ref13$scrollOffset = _ref13.scrollOffset,\n    scrollOffset = _ref13$scrollOffset === void 0 ? 0 : _ref13$scrollOffset,\n    _ref13$offsetSecondar = _ref13.offsetSecondary,\n    offsetSecondary = _ref13$offsetSecondar === void 0 ? 0 : _ref13$offsetSecondar,\n    layerDimensions = _ref13.layerDimensions;\n  var primaryRect;\n  var secondaryRect; // get the correct anticipated ClientRect based on the provided Anchor\n\n  var layerRect = layerDimensions ? fixLayerDimensions(layer, anchor, layerDimensions) : layer;\n  if (anchor === \"CENTER\") {\n    primaryRect = getCenter$1(trigger, layerRect, 0, \"top\", \"height\");\n    secondaryRect = getCenter$1(trigger, layerRect, 0, \"left\", \"width\");\n  } else {\n    var _splitAnchor2 = splitAnchor(anchor),\n      primary = _splitAnchor2.primary,\n      secondary = _splitAnchor2.secondary;\n    var primaryDirection = getPrimaryDirection(anchor);\n    primaryRect = getPrimaryRect(primary, trigger, layerRect, triggerOffset);\n    secondaryRect = getSecondaryRect(secondary, trigger, layerRect, offsetSecondary, primaryDirection);\n  }\n  var result = _objectSpread(_objectSpread(_objectSpread({}, layerRect), primaryRect), secondaryRect); // correct scrollOffsets\n\n  result.top = result.top - scrollOffset;\n  result.right = result.right + scrollOffset;\n  result.left = result.left - scrollOffset;\n  result.bottom = result.bottom + scrollOffset;\n  return result;\n}\nvar ALL_OFFSET_SIDES = [\"bottom\", \"top\", \"left\", \"right\"];\nfunction getLayerOffsetsToParent(layer, parent) {\n  return {\n    top: layer.top - parent.top,\n    bottom: parent.bottom - layer.bottom,\n    left: layer.left - parent.left,\n    right: parent.right - layer.right\n  };\n}\nfunction getLayerOffsetsToParents(layer, parents) {\n  return parents.map(function (parent) {\n    return getLayerOffsetsToParent(layer, parent);\n  });\n}\nfunction isLayerCompletelyInvisible(layer, parents) {\n  return parents.some(function (parent) {\n    return layer.bottom <= parent.top || layer.right <= parent.left || layer.top >= parent.bottom || layer.left >= parent.right;\n  });\n}\nfunction doesEntireLayerFitWithinScrollParents(layer, parents) {\n  var parentOffsets = getLayerOffsetsToParents(layer, parents);\n  return parentOffsets.every(function (offsets) {\n    return ALL_OFFSET_SIDES.every(function (side) {\n      return offsets[side] >= 0;\n    });\n  });\n}\nfunction reduceOffsets(parentOffsets) {\n  var parentOffsetsCombined = parentOffsets.reduce(function (result, offsets) {\n    ALL_OFFSET_SIDES.forEach(function (side) {\n      result[side] = [].concat(_toConsumableArray(result[side]), [offsets[side]]);\n    });\n    return result;\n  }, {\n    top: [],\n    bottom: [],\n    left: [],\n    right: []\n  });\n  return ALL_OFFSET_SIDES.reduce(function (result, side) {\n    result[side] = parentOffsetsCombined[side].sort(function (a, b) {\n      return a - b;\n    })[0];\n    return result;\n  }, {});\n}\nfunction getNegativeOffsetSides(parentOffsets) {\n  var offsets = reduceOffsets(parentOffsets);\n  return ALL_OFFSET_SIDES.filter(function (side) {\n    return offsets[side] < 0;\n  });\n}\nfunction getVisibleLayerSurface(layer, parent) {\n  var offsets = getLayerOffsetsToParent(layer, parent);\n  var _ALL_OFFSET_SIDES$fil = ALL_OFFSET_SIDES.filter(function (side) {\n      return offsets[side] < 0;\n    }).reduce(function (rect, side) {\n      var affectedProperty = side === \"top\" || side === \"bottom\" ? \"height\" : \"width\";\n      return _objectSpread(_objectSpread({}, rect), {}, _defineProperty({}, affectedProperty, rect[affectedProperty] + offsets[side]));\n    }, layer),\n    width = _ALL_OFFSET_SIDES$fil.width,\n    height = _ALL_OFFSET_SIDES$fil.height;\n  var result = width * height;\n  return width < 0 && height < 0 ? -result : result;\n}\nfunction getVisibleLayerSurfaceWithinScrollParent(layer, parents) {\n  var surfaces = parents.map(function (parent) {\n    return getVisibleLayerSurface(layer, parent);\n  }); // pick smallest\n\n  return surfaces.sort(function (a, b) {\n    return a - b;\n  })[0];\n}\nfunction doesAnchorFitWithinScrollParents(anchor, rects, triggerOffset, scrollOffset, layerDimensions) {\n  var layerRect = getLayerRectByAnchor({\n    anchor: anchor,\n    trigger: rects.trigger,\n    layer: rects.layer,\n    triggerOffset: triggerOffset,\n    scrollOffset: scrollOffset,\n    layerDimensions: layerDimensions\n  });\n  return doesEntireLayerFitWithinScrollParents(layerRect, rects.scrollParents);\n}\nfunction getLayerOffsetsToScrollParentsByAnchor(anchor, rects, triggerOffset, scrollOffset) {\n  return getLayerOffsetsToParents(getLayerRectByAnchor({\n    anchor: anchor,\n    trigger: rects.trigger,\n    layer: rects.layer,\n    triggerOffset: triggerOffset,\n    scrollOffset: scrollOffset,\n    layerDimensions: null\n  }), rects.scrollParents);\n}\nfunction triggerIsBiggerThanLayer(layerSide, layer, trigger) {\n  return (layerSide === \"top\" || layerSide === \"bottom\") && trigger.width > layer.width || (layerSide === \"left\" || layerSide === \"right\") && trigger.height > layer.height;\n}\nfunction getOffsetSurface(anchor, layer, triggerOffset, scrollOffset) {\n  var primaryDirection = getPrimaryDirection(anchor);\n  var primarySize = layer[primaryDirection === \"X\" ? \"width\" : \"height\"] - triggerOffset - scrollOffset * 2;\n  var secondarySize = layer[primaryDirection === \"X\" ? \"height\" : \"width\"] - triggerOffset - scrollOffset * 2;\n  return primarySize * secondarySize;\n}\nfunction findAnchorByLayerSurface(rects, anchorOptions, triggerOffset, scrollOffset, layerDimensions) {\n  var result = anchorOptions.map(function (anchor) {\n    // get layerRect based on all offsets\n    var layerRect = getLayerRectByAnchor({\n      anchor: anchor,\n      layer: rects.layer,\n      trigger: rects.trigger,\n      scrollOffset: scrollOffset,\n      triggerOffset: triggerOffset,\n      layerDimensions: layerDimensions\n    }); // get smallest visible layer surface for current anchor\n\n    var surface = getVisibleLayerSurfaceWithinScrollParent(layerRect, rects.scrollParents); // get surface of the offsets\n    // offsets are important for collision detection, but\n    // eventually we are interested in the 'meat' of the layer\n\n    var offsetSurface = getOffsetSurface(anchor, layerRect, triggerOffset, scrollOffset);\n    return {\n      anchor: anchor,\n      square: surface - offsetSurface\n    };\n  }) // sort -> biggest surface first\n  .sort(function (a, b) {\n    return b.square - a.square;\n  });\n  return result[0].anchor;\n}\nfunction findBestSuitableAnchor(rects, anchorOptions, triggerOffset, scrollOffset, layerDimensions) {\n  // STRATEGY A\n  // find first that fits parent\n  var anchor = anchorOptions.find(function (anchor) {\n    return doesAnchorFitWithinScrollParents(anchor, rects, triggerOffset, scrollOffset, layerDimensions);\n  });\n  if (anchor) {\n    return anchor;\n  } // STRATEGY B\n  // find first with biggest surface\n\n  return findAnchorByLayerSurface(rects, anchorOptions, triggerOffset, scrollOffset, layerDimensions);\n}\nfunction getSecondaryOffsetSide(currentAnchor, firstAnchorThatDoesNotFit, rects, triggerOffset, scrollOffset) {\n  var primaryDirection = getPrimaryDirection(currentAnchor);\n  var offsets = getLayerOffsetsToScrollParentsByAnchor(firstAnchorThatDoesNotFit, rects, triggerOffset, scrollOffset);\n  var sides = getNegativeOffsetSides(offsets);\n  return sides.find(function (side) {\n    if (primaryDirection === \"X\") {\n      return side === \"top\" || side === \"bottom\";\n    }\n    return side === \"left\" || side === \"right\";\n  });\n}\nfunction findSecondaryOffset(anchor, anchorOptions, rects, triggerOffset, scrollOffset) {\n  var _splitAnchor3 = splitAnchor(anchor),\n    primary = _splitAnchor3.primary;\n  /**\n   * A.\n   * Check which other anchors available\n   */\n\n  var secondaryAnchorOptions = getSecondaryAnchorOptionsByPrimary(primary, anchorOptions);\n  /**\n   * B.\n   * Check whether current anchor is the preffered anchor and whether\n   * it fits\n   * If so, skip secondary offset\n   */\n\n  var currentAnchorHasHighestPriority = secondaryAnchorOptions.indexOf(anchor) === 0;\n  var currentAnchorFits = doesAnchorFitWithinScrollParents(anchor, rects, triggerOffset, scrollOffset, null);\n  if (currentAnchorHasHighestPriority && currentAnchorFits) {\n    return 0;\n  }\n  /**\n   * C.\n   * Retrieve the first anchor on same primary side (by priority) that\n   * does not fit.\n   * Check if there's a relevant side that has a negative offset.\n   * If not, skip secondary offset\n   */\n\n  var firstAnchorThatDoesNotFit = secondaryAnchorOptions.find(function (anchor) {\n    return !doesAnchorFitWithinScrollParents(anchor, rects, triggerOffset, scrollOffset, null);\n  });\n  var affectedSide = getSecondaryOffsetSide(anchor, firstAnchorThatDoesNotFit, rects, triggerOffset, scrollOffset);\n  if (!affectedSide) {\n    return 0;\n  }\n  /**\n   * Determine the final secondary offset\n   */\n\n  var currentOffsets = reduceOffsets(getLayerOffsetsToScrollParentsByAnchor(anchor, rects, triggerOffset, scrollOffset));\n  var secondaryOffset = -currentOffsets[affectedSide];\n  var triggerIsBigger = triggerIsBiggerThanLayer(getLayerSideByAnchor(anchor), rects.layer, rects.trigger);\n  var isCenter = anchor.includes(\"_CENTER\");\n  var isLeft = anchor.includes(\"_LEFT\");\n  var isTop = anchor.includes(\"_TOP\"); // when trigger is bigger, make `secondaryOffset` positive\n  // conditionally\n\n  if (triggerIsBigger && (isLeft && affectedSide === \"right\" || affectedSide === \"left\" || isTop && affectedSide === \"bottom\" || affectedSide === \"top\")) {\n    secondaryOffset = -secondaryOffset;\n  } else if (\n  // when current anchor is center, make `secondaryOffset` positive\n  // when affectedSide is top or right\n  !triggerIsBigger && isCenter && (affectedSide === \"top\" || affectedSide === \"left\")) {\n    secondaryOffset = -secondaryOffset;\n  }\n  return secondaryOffset;\n}\nfunction getOffsets(layer, trigger, arrow) {\n  var left = layer.left + layer.width / 2 - trigger.left - arrow.width / 2;\n  var right = layer.right - layer.width / 2 - trigger.right + arrow.width / 2;\n  var top = layer.top + layer.height / 2 - trigger.top - arrow.height / 2;\n  var bottom = layer.bottom - layer.height / 2 - trigger.bottom + arrow.height / 2;\n  return {\n    left: left < 0 ? -left : 0,\n    right: right > 0 ? -right : 0,\n    top: top < 0 ? -top : 0,\n    bottom: bottom > 0 ? -bottom : 0\n  };\n}\nfunction getArrowStyle(layer, trigger, layerSide, arrow) {\n  var triggerIsBigger = triggerIsBiggerThanLayer(layerSide, layer, trigger);\n  var limitsDefault = {\n    left: {\n      min: arrow.width / 2,\n      max: layer.width - arrow.width / 2\n    },\n    top: {\n      min: arrow.height / 2,\n      max: layer.height - arrow.height / 2\n    }\n  };\n  var offsets = getOffsets(layer, trigger, arrow);\n  if (layerSide === \"bottom\") {\n    return {\n      bottom: \"100%\",\n      top: null,\n      left: minMax(triggerIsBigger ? layer.width / 2 + (offsets.left + offsets.right) : trigger.left + trigger.width / 2 - layer.left, limitsDefault.left),\n      right: null\n    };\n  }\n  if (layerSide === \"right\") {\n    return {\n      right: \"100%\",\n      left: null,\n      top: minMax(triggerIsBigger ? layer.height / 2 + (offsets.top + offsets.bottom) : trigger.top + trigger.height / 2 - layer.top, limitsDefault.top),\n      bottom: null\n    };\n  }\n  if (layerSide === \"top\") {\n    return {\n      top: \"100%\",\n      bottom: null,\n      left: minMax(triggerIsBigger ? layer.width / 2 + (offsets.left + offsets.right) : trigger.left + trigger.width / 2 - layer.left, limitsDefault.left),\n      right: null\n    };\n  }\n  return {\n    left: \"100%\",\n    right: null,\n    top: minMax(triggerIsBigger ? layer.height / 2 + (offsets.top + offsets.bottom) : trigger.top + trigger.height / 2 - layer.top, limitsDefault.top),\n    bottom: null\n  };\n}\nfunction getAbsoluteStyle(_ref14) {\n  var rects = _ref14.rects,\n    scrollTop = _ref14.scrollTop,\n    scrollLeft = _ref14.scrollLeft,\n    triggerOffset = _ref14.triggerOffset,\n    scrollOffset = _ref14.scrollOffset,\n    possibleAnchors = _ref14.possibleAnchors,\n    preferedAnchor = _ref14.preferedAnchor,\n    preferedX = _ref14.preferedX,\n    preferedY = _ref14.preferedY,\n    autoAdjust = _ref14.autoAdjust,\n    snapToAnchor = _ref14.snapToAnchor,\n    layerDimensions = _ref14.layerDimensions;\n  // get a list of possible anchors bases on user set props\n  var possibleAnchorsByPriority = getAnchorPriority(preferedAnchor, possibleAnchors, preferedX, preferedY, rects); // on `autoAdjust` find best suitable anchor based on\n  // window's / scrollParent's position\n\n  var anchor = autoAdjust ? findBestSuitableAnchor(rects, possibleAnchorsByPriority, triggerOffset, scrollOffset, layerDimensions) : preferedAnchor; // calculate a secondary offset when `autoAdjust` is set\n  // and `snapToAnchor` is not.\n  // Basically it creates a visual effect where it seems that\n  // the layer has glued to it's parents sides\n  // Note: `offsetSecondary` is disabled when anchor is CENTER\n\n  var offsetSecondary = autoAdjust && !snapToAnchor && anchor !== \"CENTER\" ? findSecondaryOffset(anchor, possibleAnchorsByPriority, rects, triggerOffset, scrollOffset) : 0;\n  var layerStyle = getAbsolutePositions({\n    anchor: anchor,\n    rects: rects,\n    triggerOffset: triggerOffset,\n    offsetSecondary: offsetSecondary,\n    scrollLeft: scrollLeft,\n    scrollTop: scrollTop\n  });\n  var layerRect = getLayerRectByAnchor({\n    anchor: anchor,\n    trigger: rects.trigger,\n    layer: rects.layer,\n    triggerOffset: triggerOffset,\n    offsetSecondary: offsetSecondary,\n    layerDimensions: layerDimensions\n  });\n  if (layerDimensions) {\n    layerStyle.width = layerRect.width;\n    layerStyle.height = layerRect.height;\n  }\n  return {\n    layerStyle: layerStyle,\n    layerRect: layerRect,\n    anchor: anchor\n  };\n}\nfunction compensateScrollbars(rect, clientWidth, clientHeight) {\n  var scrollbarWidth = rect.width - clientWidth;\n  var scrollbarHeight = rect.height - clientHeight;\n  return {\n    left: rect.left,\n    top: rect.top,\n    width: rect.width - scrollbarWidth,\n    right: rect.right - scrollbarWidth,\n    height: rect.height - scrollbarHeight,\n    bottom: rect.bottom - scrollbarHeight\n  };\n}\nfunction getArrowRect(layerElement, arrowOffset) {\n  var arrowElement = layerElement.querySelector(\"[data-arrow]\");\n  if (!arrowElement) {\n    return {\n      top: 0,\n      bottom: 0,\n      left: 0,\n      right: 0,\n      width: 0,\n      height: 0\n    };\n  }\n  var rect = arrowElement.getBoundingClientRect();\n  return _objectSpread(_objectSpread({}, clientRectToObject(rect)), {}, {\n    width: rect.width + arrowOffset * 2,\n    height: rect.height + arrowOffset * 2\n  });\n}\nvar defaultPlacement = {\n  autoAdjust: false,\n  snapToAnchor: false,\n  anchor: \"TOP_CENTER\",\n  layerDimensions: null,\n  possibleAnchors: POSSIBLE_ANCHORS,\n  preferX: \"RIGHT\",\n  preferY: \"BOTTOM\",\n  scrollOffset: 10,\n  triggerOffset: 0,\n  arrowOffset: 0\n};\nfunction getPositioning(_ref15) {\n  var triggerRect = _ref15.triggerRect,\n    layerElement = _ref15.layerElement,\n    relativeParentElement = _ref15.relativeParentElement,\n    scrollParents = _ref15.scrollParents,\n    _ref15$placement = _ref15.placement,\n    placement = _ref15$placement === void 0 ? {} : _ref15$placement,\n    environment = _ref15.environment,\n    fixed = _ref15.fixed;\n  /**\n   * A.\n   * Calculate new layer positions\n   */\n  // sometimes ResizeObserver calls this function when all values in the\n  // trigger ClientRect are 0. Return early in that case\n  if (triggerRect.height === 0) {\n    return;\n  }\n  if (!layerElement) {\n    return;\n  } // gather all scroll parents (including the window ClientRect)\n  // in order to check for collisions\n\n  var scrollParentRects = fixed ? [getWindowClientRect(environment)] : [].concat(_toConsumableArray(scrollParents.map(function (parent) {\n    return compensateScrollbars(parent.getBoundingClientRect(), parent.clientWidth, parent.clientHeight);\n  })), [getWindowClientRect(environment)]);\n  var options = {\n    autoAdjust: placement.autoAdjust || defaultPlacement.autoAdjust,\n    snapToAnchor: placement.snapToAnchor || defaultPlacement.snapToAnchor,\n    triggerOffset: isSet(placement.triggerOffset) ? placement.triggerOffset : defaultPlacement.triggerOffset,\n    scrollOffset: isSet(placement.scrollOffset) ? placement.scrollOffset : defaultPlacement.scrollOffset,\n    possibleAnchors: placement.possibleAnchors || defaultPlacement.possibleAnchors,\n    preferedAnchor: placement.anchor || defaultPlacement.anchor,\n    preferedX: placement.preferX || defaultPlacement.preferX,\n    preferedY: placement.preferY || defaultPlacement.preferY,\n    scrollLeft: relativeParentElement === document.body ? 0 : relativeParentElement.scrollLeft,\n    scrollTop: relativeParentElement === document.body ? 0 : relativeParentElement.scrollTop,\n    relativeParentElement: relativeParentElement,\n    layerDimensions: placement.layerDimensions || defaultPlacement.layerDimensions\n  };\n  var layerBox = layerElement.getBoundingClientRect(); // construct layerRect\n\n  var layer = _objectSpread({\n    top: layerBox.top,\n    left: layerBox.left,\n    right: layerBox.right,\n    bottom: layerBox.bottom\n  }, getContentBox(layerElement, environment));\n  var rects = {\n    layer: layer,\n    relativeParent: relativeParentElement.getBoundingClientRect(),\n    scrollParents: scrollParentRects,\n    trigger: triggerRect,\n    arrow: getArrowRect(layerElement, placement.arrowOffset || defaultPlacement.arrowOffset)\n  };\n  var _getAbsoluteStyle = getAbsoluteStyle(_objectSpread({\n      rects: rects\n    }, options)),\n    layerRect = _getAbsoluteStyle.layerRect,\n    layerStyle = _getAbsoluteStyle.layerStyle,\n    anchor = _getAbsoluteStyle.anchor;\n  if (fixed) {\n    layerStyle.top = layerRect.top;\n    layerStyle.left = layerRect.left;\n  } // determine in which side to layer will be relative to\n  // the trigger\n\n  var layerSide = getLayerSideByAnchor(anchor); // get optional arrow positions\n  // anchor-style is pointless when rendered anchor is CENTER\n\n  var arrowStyle = anchor === \"CENTER\" ? EMPTY_STYLE : getArrowStyle(layerRect, triggerRect, layerSide, rects.arrow);\n  var styles = {\n    layer: layerStyle,\n    arrow: arrowStyle,\n    layerSide: layerSide\n  };\n  return {\n    styles: styles,\n    layerRect: layerRect\n  };\n}\n\n/**\n * Tracks an element and keeps it in state\n * (together with other relevant state that depends on the element)\n */\n\nfunction useElementRef(initialState, elementToState) {\n  var _useState5 = useState(initialState || null),\n    _useState6 = _slicedToArray(_useState5, 2),\n    state = _useState6[0],\n    setState = _useState6[1];\n  var lastElement = useRef(null);\n  var setRef = useCallback(function (node) {\n    if (node && node !== lastElement.current) {\n      lastElement.current = node;\n      if (elementToState) {\n        setState(elementToState(node));\n      } else {\n        setState(node);\n      }\n    }\n  }, []);\n  return [setRef, state, lastElement];\n}\nfunction findScrollContainers(element, environment) {\n  var result = [];\n  if (!element || !environment) {\n    return result;\n  }\n  if (element === document.body) {\n    return result;\n  }\n  var _environment$getCompu2 = environment.getComputedStyle(element),\n    overflow = _environment$getCompu2.overflow,\n    overflowX = _environment$getCompu2.overflowX,\n    overflowY = _environment$getCompu2.overflowY;\n  if ([overflow, overflowX, overflowY].some(function (prop) {\n    return prop === \"auto\" || prop === \"scroll\";\n  })) {\n    result.push(element);\n  }\n  return [].concat(result, _toConsumableArray(findScrollContainers(element.parentElement, environment)));\n}\nfunction useElementState(container, fixed, environment) {\n  return useElementRef({\n    triggerElement: null,\n    relativeParentElement: null,\n    scrollParents: []\n  }, useCallback(function (triggerElement) {\n    var scrollParents = findScrollContainers(triggerElement, environment);\n    var relativeParentElement = scrollParents[0] || document.body;\n    if (relativeParentElement === document.body) {\n      document.body.style.position = \"relative\";\n    } else if (process.env.NODE_ENV === \"development\" && environment) {\n      // Check if we should warn the user about 'position: relative; stuff...'\n      var containerElement = typeof container === \"function\" ? container() : container;\n      var position = environment.getComputedStyle(relativeParentElement).position;\n      var shouldWarnAboutPositionStyle = position !== \"relative\" && position !== \"absolute\" && position !== \"fixed\" && !fixed && !containerElement;\n      if (shouldWarnAboutPositionStyle) {\n        console.error(\"react-laag: Set the 'position' style of the nearest scroll-container to 'relative', 'absolute' or 'fixed', or set the 'fixed' prop to true. This is needed in order to position the layers properly. Currently the scroll-container is positioned: \\\"\" + position + \"\\\". Visit https://react-laag.com/docs/#position-relative for more info.\", relativeParentElement);\n      }\n    }\n    return {\n      triggerElement: triggerElement,\n      relativeParentElement: relativeParentElement,\n      scrollParents: scrollParents\n    };\n  }, []));\n}\nfunction useIsOpen(internal, external) {\n  var shouldOpenAfterMount = useRef(external);\n  var isOpen = shouldOpenAfterMount.current ? false : isSet(external) ? external : internal;\n  var rerenderAfterMount = useState(false)[1];\n  useEffect(function () {\n    if (shouldOpenAfterMount.current) {\n      shouldOpenAfterMount.current = false;\n      rerenderAfterMount(true);\n    }\n  }, []);\n  return isOpen;\n}\nvar ToggleLayer = function ToggleLayer(_ref16) {\n  var children = _ref16.children,\n    renderLayer = _ref16.renderLayer,\n    _ref16$placement = _ref16.placement,\n    placement = _ref16$placement === void 0 ? {} : _ref16$placement,\n    onStyle = _ref16.onStyle,\n    isOpenExternal = _ref16.isOpen,\n    closeOnOutsideClick = _ref16.closeOnOutsideClick,\n    onOutsideClick = _ref16.onOutsideClick,\n    onDisappear = _ref16.onDisappear,\n    closeOnDisappear = _ref16.closeOnDisappear,\n    fixed = _ref16.fixed,\n    container = _ref16.container,\n    _ref16$environment = _ref16.environment,\n    environment = _ref16$environment === void 0 ? typeof window !== \"undefined\" ? window : undefined : _ref16$environment,\n    props = _objectWithoutProperties(_ref16, _excluded);\n  /**\n   * Tracks trigger element and keeps it in state together with it's\n   * relative/absolute positioned parent\n   */\n  var _useElementState = useElementState(container, fixed, environment),\n    _useElementState2 = _slicedToArray(_useElementState, 3),\n    triggerRef = _useElementState2[0],\n    _useElementState2$ = _useElementState2[1],\n    relativeParentElement = _useElementState2$.relativeParentElement,\n    triggerElement = _useElementState2$.triggerElement,\n    scrollParents = _useElementState2$.scrollParents,\n    normalTriggerRef = _useElementState2[2];\n  var _useStyleState = useStyleState(placement.anchor || defaultPlacement.anchor),\n    styles = _useStyleState.styles,\n    setStyles = _useStyleState.setStyles,\n    lastStyles = _useStyleState.lastStyles,\n    resetLastStyles = _useStyleState.resetLastStyles;\n  var layerRef = useRef(null);\n  var _useState7 = useState(false),\n    _useState8 = _slicedToArray(_useState7, 2),\n    isOpenInternal = _useState8[0],\n    setOpenInternal = _useState8[1];\n  var isOpen = useIsOpen(isOpenInternal, isOpenExternal);\n  var handlePositioning = useCallback(function () {\n    if (!triggerElement) {\n      throw new Error(\"Could not find a valid reference of the trigger element. See https://www.react-laag.com/docs/togglelayer/#children for more info.\");\n    }\n    var triggerRect = triggerElement.getBoundingClientRect();\n    var result = getPositioning({\n      triggerRect: triggerRect,\n      layerElement: layerRef.current,\n      placement: placement,\n      relativeParentElement: relativeParentElement,\n      scrollParents: scrollParents,\n      fixed: fixed,\n      environment: environment\n    });\n    if (!result) {\n      return;\n    }\n    var layerRect = result.layerRect,\n      styles = result.styles; // only update styles when necessary\n\n    if (shouldUpdateStyles(lastStyles.current, styles)) {\n      // is parent in control of styles? (onStyle)\n      if (isSet(onStyle)) {\n        lastStyles.current = styles;\n        onStyle(styles.layer, styles.arrow, styles.layerSide);\n      } // ... otherwise set styles internally\n      else {\n        setStyles(styles);\n      }\n    }\n    /**\n     * B.\n     * Manage disappearance\n     */\n\n    var hasOnDisappear = isSet(onDisappear);\n    var shouldCloseOnDisappear = closeOnDisappear && !isSet(isOpenExternal); // Should we respond to the layer's partial or full disappearance?\n    // (trigger's disappearance when `fixed` props is set)\n\n    if (hasOnDisappear || shouldCloseOnDisappear) {\n      var allScrollParents = [].concat(_toConsumableArray(scrollParents.map(function (parent) {\n        return parent.getBoundingClientRect();\n      })), [getWindowClientRect(environment)]);\n      var partial = !doesEntireLayerFitWithinScrollParents(fixed ? triggerRect : layerRect, allScrollParents);\n      var full = isLayerCompletelyInvisible(fixed ? triggerRect : layerRect, allScrollParents); // if parent is interested in diseappearance...\n\n      if (hasOnDisappear) {\n        if (partial || full) {\n          onDisappear(full ? \"full\" : \"partial\");\n        }\n      } // ... else close accordingly\n      else {\n        if (closeOnDisappear === \"partial\" && partial) {\n          setOpenInternal(false);\n        }\n        if (closeOnDisappear === \"full\" && full) {\n          setOpenInternal(false);\n        }\n      }\n    }\n  }, [relativeParentElement, isOpen, triggerElement, scrollParents, fixed, placement]); // call `handlePositioning` when the layer's / trigger's\n  // height and / or width changes\n\n  var resizeObserver = useTrackElementResize(props.ResizeObserver, layerRef, triggerElement, isOpen, handlePositioning, environment); // On every render, check a few things...\n\n  useIsomorphicLayoutEffect(function () {\n    /**\n     * A.\n     * Ignore when render is caused by internal style change\n     */\n    var styleIsSetInterally = !isSet(onStyle);\n    var effectBecauseOfInternalStyleChange = styles !== lastStyles.current;\n    if (effectBecauseOfInternalStyleChange && styleIsSetInterally) {\n      lastStyles.current = styles;\n      return;\n    } // reset lastStyles-ref when closed\n\n    if (!isOpen) {\n      resetLastStyles();\n      return;\n    }\n    /**\n     * B.\n     * Prepare to calculate new layer style\n     */\n    // if (!triggerElement) {\n    //   throw new Error(\"Please provide a valid ref to the trigger element\");\n    // } else if (!layerRef.current) {\n    //   throw new Error(\"Please provide a valid ref to the layer element\");\n    // }\n\n    handlePositioning();\n  }); // calculate new layer style when window size changes\n\n  useOnWindowResize(handlePositioning, environment, isOpen); // calculate new layer style when user scrolls\n\n  useOnScroll(scrollParents, handlePositioning, environment, isOpen);\n  var outsideClickRefs = useRef(new Set([layerRef, normalTriggerRef])); // handle clicks that are not originated from the trigger / layer\n  // element\n\n  useOutsideClick(outsideClickRefs, useCallback(function () {\n    if (!isOpen) {\n      return;\n    }\n    if (onOutsideClick) {\n      onOutsideClick();\n    }\n    if (closeOnOutsideClick && !isSet(isOpenExternal)) {\n      setOpenInternal(false);\n    }\n  }, [isOpen, setOpenInternal, isOpenExternal, onOutsideClick]));\n  var containerElement = typeof container === \"function\" ? container() : container;\n  return /*#__PURE__*/createElement(Fragment, null, children({\n    isOpen: isOpen,\n    close: function close() {\n      /* istanbul ignore next */\n      if (isSet(isOpenExternal)) {\n        throw new Error(\"You cannot call `close()` while using the `isOpen` prop\");\n      }\n      /* istanbul ignore next */\n\n      setOpenInternal(false);\n    },\n    open: function open() {\n      /* istanbul ignore next */\n      if (isSet(isOpenExternal)) {\n        throw new Error(\"You cannot call `open()` while using the `isOpen` prop\");\n      }\n      /* istanbul ignore next */\n\n      setOpenInternal(true);\n    },\n    toggle: function toggle() {\n      /* istanbul ignore next */\n      if (isSet(isOpenExternal)) {\n        throw new Error(\"You cannot call `toggle()` while using the `isOpen` prop\");\n      }\n      setOpenInternal(!isOpenInternal);\n    },\n    triggerRef: triggerRef,\n    layerSide: isOpen ? styles.layerSide : null\n  }), relativeParentElement && /*#__PURE__*/createElement(OutsideClickGroupProvider, {\n    refs: outsideClickRefs\n  }, /*#__PURE__*/createPortal(renderLayer({\n    layerProps: {\n      ref: function ref(element) {\n        if (element) {\n          // observe the layer for resizing\n          // it's ok to observe the same element multiple times\n          // since multiple observes of same element are ignored\n          resizeObserver.observe(element);\n        }\n        layerRef.current = element;\n      },\n      style: _objectSpread(_objectSpread({}, isSet(onStyle) ? EMPTY_STYLE : styles.layer), {}, {\n        position: fixed ? \"fixed\" : \"absolute\",\n        willChange: \"top, bottom, left, right, width, height\"\n      })\n    },\n    arrowStyle: _objectSpread(_objectSpread({}, isSet(onStyle) ? EMPTY_STYLE : styles.arrow), {}, {\n      position: \"absolute\",\n      willChange: \"top, bottom, left, right\"\n    }),\n    isOpen: isOpen,\n    layerSide: styles.layerSide,\n    triggerRect: triggerElement ? triggerElement.getBoundingClientRect() : null,\n    close: function close() {\n      /* istanbul ignore next */\n      if (isSet(isOpenExternal)) {\n        throw new Error(\"You cannot call `close()` while using the `isOpen` prop\");\n      }\n      /* istanbul ignore next */\n\n      setOpenInternal(false);\n    }\n  }), containerElement || relativeParentElement)));\n};\nfunction getWidthBasedOnAngle(angle, size) {\n  return Math.tan(angle * (Math.PI / 180)) * size;\n}\nfunction getViewBox(sizeA, sizeB, layerSide, borderWidth) {\n  switch (layerSide) {\n    case \"bottom\":\n      return \"0 \" + -borderWidth + \" \" + sizeB + \" \" + sizeA;\n    case \"top\":\n      return \"0 0 \" + sizeB + \" \" + (sizeA + borderWidth);\n    case \"right\":\n      return -borderWidth + \" 0 \" + sizeA + \" \" + sizeB;\n    case \"left\":\n      return \"0 0 \" + (sizeA + borderWidth) + \" \" + sizeB;\n  }\n  return \"\";\n}\nfunction getTrianglePath(_ref17) {\n  var sizeA = _ref17.sizeA,\n    sizeB = _ref17.sizeB,\n    layerSide = _ref17.layerSide,\n    roundness = _ref17.roundness,\n    angle = _ref17.angle;\n  var relativeRoundness = roundness / 10 * sizeA * 2;\n  var A = layerSide === \"bottom\" ? \"0 \" + sizeA : layerSide === \"top\" ? \"0 0\" : layerSide === \"right\" ? sizeA + \" \" + sizeB : \"0 \" + sizeB;\n  var B = (layerSide === \"bottom\" || layerSide === \"top\" ? \"H\" : \"V\") + \" \" + (layerSide === \"bottom\" || layerSide === \"top\" ? sizeB : 0);\n  var cPoint = sizeB / 2;\n  var c1A = sizeB / 2 + getWidthBasedOnAngle(angle, sizeA / 8);\n  var c1B = sizeA / 8;\n  var C = layerSide === \"bottom\" ? \"C \" + c1A + \" \" + c1B + \" \" + (cPoint + relativeRoundness) + \" 0 \" + cPoint + \" 0\" : layerSide === \"top\" ? \"C \" + c1A + \" \" + (sizeA - c1B) + \" \" + (cPoint + relativeRoundness) + \" \" + sizeA + \" \" + cPoint + \" \" + sizeA : layerSide === \"right\" ? \"C \" + c1B + \" \" + (sizeB - c1A) + \" 0 \" + (cPoint - relativeRoundness) + \" 0 \" + cPoint : \"C \" + (sizeA - c1B) + \" \" + (sizeB - c1A) + \" \" + sizeA + \" \" + (cPoint - relativeRoundness) + \" \" + sizeA + \" \" + cPoint;\n  var d1A = sizeB / 2 - getWidthBasedOnAngle(angle, sizeA / 8);\n  var d1B = sizeA / 8;\n  var D = layerSide === \"bottom\" ? \"C \" + (cPoint - relativeRoundness) + \" 0 \" + d1A + \" \" + d1B + \" \" + A : layerSide === \"top\" ? \"C \" + (cPoint - relativeRoundness) + \" \" + sizeA + \" \" + d1A + \" \" + (sizeA - d1B) + \" \" + A : layerSide === \"right\" ? \"C 0 \" + (cPoint + relativeRoundness) + \" \" + d1B + \" \" + (sizeB - d1A) + \" \" + A : \"C\" + sizeA + \" \" + (cPoint + relativeRoundness) + \" \" + (sizeA - d1B) + \" \" + (sizeB - d1A) + \" \" + A;\n  return \"M \" + A + \" \" + B + \" \" + C + \" \" + D;\n}\nfunction getBorderMaskPath(_ref18) {\n  var sizeA = _ref18.sizeA,\n    sizeB = _ref18.sizeB,\n    borderWidth = _ref18.borderWidth,\n    layerSide = _ref18.layerSide,\n    angle = _ref18.angle;\n  var borderOffset = getWidthBasedOnAngle(angle, borderWidth);\n  if (layerSide === \"bottom\" || layerSide === \"top\") {\n    return \"M \" + borderWidth + \" \" + (layerSide === \"bottom\" ? sizeA : 0) + \" H \" + (sizeB - borderWidth) + \" L \" + (sizeB - borderWidth - borderOffset) + \" \" + (layerSide === \"bottom\" ? sizeA - borderWidth : borderWidth) + \" H \" + (borderOffset + borderWidth) + \" Z\";\n  }\n  return \"M \" + (layerSide === \"right\" ? sizeA : 0) + \" \" + borderWidth + \" V \" + (sizeB - borderWidth) + \" L \" + (layerSide === \"right\" ? sizeA - borderWidth : borderWidth) + \" \" + (sizeB - borderWidth - borderOffset) + \" V \" + (borderOffset + borderWidth) + \" Z\";\n}\nvar Arrow = function Arrow(_ref19) {\n  var _ref19$size = _ref19.size,\n    size = _ref19$size === void 0 ? 8 : _ref19$size,\n    _ref19$angle = _ref19.angle,\n    angle = _ref19$angle === void 0 ? 45 : _ref19$angle,\n    _ref19$borderWidth = _ref19.borderWidth,\n    borderWidth = _ref19$borderWidth === void 0 ? 0 : _ref19$borderWidth,\n    _ref19$borderColor = _ref19.borderColor,\n    borderColor = _ref19$borderColor === void 0 ? \"black\" : _ref19$borderColor,\n    _ref19$roundness = _ref19.roundness,\n    roundness = _ref19$roundness === void 0 ? 0 : _ref19$roundness,\n    _ref19$backgroundColo = _ref19.backgroundColor,\n    backgroundColor = _ref19$backgroundColo === void 0 ? \"white\" : _ref19$backgroundColo,\n    _ref19$layerSide = _ref19.layerSide,\n    layerSide = _ref19$layerSide === void 0 ? \"top\" : _ref19$layerSide,\n    _ref19$style = _ref19.style,\n    style = _ref19$style === void 0 ? {} : _ref19$style;\n  if (layerSide === \"center\") {\n    return null;\n  }\n  var sizeA = size;\n  var sizeB = getWidthBasedOnAngle(angle, size) * 2;\n  return /*#__PURE__*/createElement(\"svg\", {\n    style: _objectSpread(_objectSpread({}, style), {}, {\n      transform: \"translate\" + (layerSide === \"left\" || layerSide === \"right\" ? \"Y\" : \"X\") + \"(-50%)\"\n    }),\n    \"data-arrow\": \"true\",\n    width: layerSide === \"left\" || layerSide === \"right\" ? sizeA : sizeB,\n    viewBox: getViewBox(sizeA, sizeB, layerSide, borderWidth)\n  }, /*#__PURE__*/createElement(\"path\", {\n    fill: backgroundColor,\n    strokeWidth: borderWidth,\n    stroke: borderColor,\n    d: getTrianglePath({\n      angle: angle,\n      layerSide: layerSide,\n      roundness: roundness,\n      sizeA: sizeA,\n      sizeB: sizeB\n    })\n  }), /*#__PURE__*/createElement(\"path\", {\n    fill: backgroundColor,\n    d: getBorderMaskPath({\n      sizeA: sizeA,\n      sizeB: sizeB,\n      angle: angle,\n      borderWidth: borderWidth,\n      layerSide: layerSide\n    })\n  }));\n};\nfunction useToggleLayer(renderLayer) {\n  var _ref20 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n    onStyle = _ref20.onStyle,\n    closeOnOutsideClick = _ref20.closeOnOutsideClick,\n    closeOnDisappear = _ref20.closeOnDisappear,\n    fixed = _ref20.fixed,\n    container = _ref20.container,\n    _ref20$placement = _ref20.placement,\n    placement = _ref20$placement === void 0 ? {} : _ref20$placement,\n    _ref20$environment = _ref20.environment,\n    environment = _ref20$environment === void 0 ? typeof window !== \"undefined\" ? window : undefined : _ref20$environment,\n    props = _objectWithoutProperties(_ref20, _excluded2);\n  /**\n   * Tracks trigger element and keeps it in state together with it's\n   * relative/absolute positioned parent\n   */\n  var _useElementState3 = useElementState(container, fixed, environment),\n    _useElementState4 = _slicedToArray(_useElementState3, 3),\n    setTargetRef = _useElementState4[0],\n    _useElementState4$ = _useElementState4[1],\n    relativeParentElement = _useElementState4$.relativeParentElement,\n    targetElement = _useElementState4$.triggerElement,\n    scrollParents = _useElementState4$.scrollParents,\n    normalTriggerRef = _useElementState4[2];\n  var _useStyleState2 = useStyleState(placement.anchor || defaultPlacement.anchor),\n    styles = _useStyleState2.styles,\n    setStyles = _useStyleState2.setStyles,\n    lastStyles = _useStyleState2.lastStyles,\n    resetLastStyles = _useStyleState2.resetLastStyles;\n  var layerRef = useRef(null);\n  var triggerRectRef = useRef(null);\n  function getTriggerRect() {\n    return typeof triggerRectRef.current === \"function\" ? triggerRectRef.current() : triggerRectRef.current;\n  }\n  var _useState9 = useState(false),\n    _useState10 = _slicedToArray(_useState9, 2),\n    isOpen = _useState10[0],\n    setOpen = _useState10[1];\n  function _close() {\n    triggerRectRef.current = null;\n    setOpen(false);\n  }\n  var handlePositioning = useCallback(function () {\n    var triggerRect = getTriggerRect();\n    if (!triggerRect) {\n      return;\n    }\n    var result = getPositioning({\n      triggerRect: triggerRect,\n      layerElement: layerRef.current,\n      placement: placement,\n      relativeParentElement: relativeParentElement,\n      scrollParents: scrollParents,\n      fixed: fixed,\n      environment: environment\n    });\n    if (!result) {\n      return;\n    }\n    var layerRect = result.layerRect,\n      styles = result.styles; // only update styles when necessary\n\n    if (shouldUpdateStyles(lastStyles.current, styles)) {\n      // is parent in control of styles? (onStyle)\n      if (isSet(onStyle)) {\n        lastStyles.current = styles;\n        onStyle(styles.layer, styles.arrow, styles.layerSide);\n      } // ... otherwise set styles internally\n      else {\n        setStyles(styles);\n      }\n    }\n    /**\n     * B.\n     * Manage disappearance\n     */\n    // Should we respond to the layer's partial or full disappearance?\n    // (trigger's disappearance when `fixed` props is set)\n\n    if (closeOnDisappear) {\n      var allScrollParents = [].concat(_toConsumableArray(scrollParents.map(function (parent) {\n        return parent.getBoundingClientRect();\n      })), [getWindowClientRect(environment)]);\n      var partial = !doesEntireLayerFitWithinScrollParents(fixed ? triggerRect : layerRect, allScrollParents);\n      var full = isLayerCompletelyInvisible(fixed ? triggerRect : layerRect, allScrollParents);\n      if (closeOnDisappear === \"partial\" && partial) {\n        _close();\n      }\n      if (closeOnDisappear === \"full\" && full) {\n        _close();\n      }\n    }\n  }, [relativeParentElement, isOpen, targetElement, scrollParents, fixed, placement]); // call `handlePositioning` when the layer's / targets's\n  // height and / or width changes\n\n  var resizeObserver = useTrackElementResize(props.ResizeObserver, layerRef, targetElement, isOpen, handlePositioning, environment); // On every render, check a few things...\n\n  useIsomorphicLayoutEffect(function () {\n    /**\n     * A.\n     * Ignore when render is caused by internal style change\n     */\n    var styleIsSetInterally = !isSet(onStyle);\n    var effectBecauseOfInternalStyleChange = styles !== lastStyles.current;\n    if (effectBecauseOfInternalStyleChange && styleIsSetInterally) {\n      lastStyles.current = styles;\n      return;\n    } // reset `lastStyles` when closed\n\n    if (!isOpen) {\n      resetLastStyles();\n      return;\n    }\n    /**\n     * B.\n     * Prepare to calculate new layer style\n     */\n\n    handlePositioning();\n  }); // calculate new layer style when window size changes\n\n  useOnWindowResize(handlePositioning, environment, isOpen); // calculate new layer style when user scrolls\n\n  useOnScroll(scrollParents, handlePositioning, environment, isOpen);\n  var outsideClickRefs = useRef(new Set([layerRef, normalTriggerRef])); // handle clicks that are not originated from the trigger / layer\n  // element\n\n  useOutsideClick(outsideClickRefs, useCallback(function () {\n    if (!isOpen) {\n      return;\n    }\n    if (closeOnOutsideClick) {\n      _close();\n    }\n  }, [isOpen, setOpen, closeOnOutsideClick]));\n  var containerElement = typeof container === \"function\" ? container() : container;\n  function open(_ref21) {\n    var clientRect = _ref21.clientRect,\n      target = _ref21.target;\n    triggerRectRef.current = clientRect;\n    if (isOpen && target === targetElement) {\n      handlePositioning();\n    } else {\n      setTargetRef(target);\n      setOpen(true);\n    }\n  }\n  var payload = {\n    isOpen: isOpen,\n    close: _close,\n    open: open,\n    openFromContextMenuEvent: function openFromContextMenuEvent(evt) {\n      evt.preventDefault();\n      var target = evt.target;\n      var clientRect = {\n        top: evt.clientY,\n        left: evt.clientX,\n        bottom: evt.clientY + 1,\n        right: evt.clientX + 1,\n        width: 1,\n        height: 1\n      };\n      open({\n        clientRect: clientRect,\n        target: target\n      });\n    },\n    openFromMouseEvent: function openFromMouseEvent(evt) {\n      var currentTarget = evt.currentTarget;\n      if (!currentTarget || !currentTarget.getBoundingClientRect) {\n        return;\n      }\n      var clientRect = function clientRect() {\n        return currentTarget.getBoundingClientRect();\n      };\n      open({\n        clientRect: clientRect,\n        target: currentTarget\n      });\n    },\n    openFromRef: function openFromRef(ref) {\n      if (!ref.current) {\n        console.error(\"Error inside useTooltip(): Expected a valid ref to a trigger element, but got \" + typeof ref.current);\n        return;\n      }\n      open({\n        target: ref.current,\n        clientRect: ref.current.getBoundingClientRect()\n      });\n    },\n    openFromSelection: function openFromSelection(selection) {\n      if (!selection.anchorNode || selection.isCollapsed) {\n        return;\n      }\n      var element = getElementFromAnchorNode(selection.anchorNode);\n      if (!element) {\n        return;\n      }\n      var range = selection.getRangeAt(0);\n      open({\n        clientRect: function clientRect() {\n          return range.getBoundingClientRect();\n        },\n        target: element\n      });\n    },\n    layerSide: isOpen ? styles.layerSide : null\n  };\n  var element = relativeParentElement && /*#__PURE__*/createPortal(renderLayer({\n    layerProps: {\n      ref: function ref(element) {\n        if (element) {\n          // observe the layer for resizing\n          // it's ok to observe the same element multiple times\n          // since multiple observes of same element are ignored\n          resizeObserver.observe(element);\n        }\n        layerRef.current = element;\n      },\n      style: _objectSpread(_objectSpread({}, isSet(onStyle) ? EMPTY_STYLE : styles.layer), {}, {\n        position: fixed ? \"fixed\" : \"absolute\",\n        willChange: \"top, bottom, left, right, width, height\"\n      })\n    },\n    arrowStyle: _objectSpread(_objectSpread({}, isSet(onStyle) ? EMPTY_STYLE : styles.arrow), {}, {\n      position: \"absolute\",\n      willChange: \"top, bottom, left, right\"\n    }),\n    isOpen: isOpen,\n    layerSide: styles.layerSide,\n    triggerRect: getTriggerRect(),\n    close: function close() {\n      _close();\n    }\n  }), containerElement || relativeParentElement);\n  return [/*#__PURE__*/createElement(OutsideClickGroupProvider, {\n    refs: outsideClickRefs\n  }, element), payload];\n}\nfunction useHover(config) {\n  var _ref22 = config || {},\n    _ref22$delayEnter = _ref22.delayEnter,\n    delayEnter = _ref22$delayEnter === void 0 ? 0 : _ref22$delayEnter,\n    _ref22$delayLeave = _ref22.delayLeave,\n    delayLeave = _ref22$delayLeave === void 0 ? 0 : _ref22$delayLeave,\n    _ref22$hideOnScroll = _ref22.hideOnScroll,\n    hideOnScroll = _ref22$hideOnScroll === void 0 ? true : _ref22$hideOnScroll,\n    onShow = _ref22.onShow,\n    onHide = _ref22.onHide;\n  var _useState11 = useState(false),\n    _useState12 = _slicedToArray(_useState11, 2),\n    show = _useState12[0],\n    setShow = _useState12[1];\n  var timeoutRef = useRef(null);\n  var timeoutState = useRef(null);\n  var hasTouchMoved = useRef(false);\n  function handleShowHide(show) {\n    if (show) {\n      if (onShow) {\n        onShow();\n      }\n      setShow(true);\n      return;\n    }\n    if (onHide) {\n      onHide();\n    }\n    setShow(false);\n  }\n  function onMouseEnter() {\n    // if was leaving, stop leaving\n    if (timeoutState.current === \"leaving\" && timeoutRef.current) {\n      clearTimeout(timeoutRef.current);\n      timeoutRef.current = null;\n      timeoutState.current = null;\n    }\n    if (show) {\n      return;\n    }\n    timeoutState.current = \"entering\";\n    timeoutRef.current = setTimeout(function () {\n      handleShowHide(true);\n      timeoutRef.current = null;\n      timeoutState.current = null;\n    }, delayEnter);\n  }\n  function onMouseLeave() {\n    // if was waiting for entering,\n    // clear timeout\n    if (timeoutState.current === \"entering\" && timeoutRef.current) {\n      clearTimeout(timeoutRef.current);\n      timeoutRef.current = null;\n    }\n    if (!show) {\n      return;\n    }\n    timeoutState.current = \"leaving\";\n    timeoutRef.current = setTimeout(function () {\n      handleShowHide(false);\n      timeoutRef.current = null;\n    }, delayLeave);\n  } // make sure to clear timeout on unmount\n\n  useEffect(function () {\n    var to = timeoutRef.current;\n    function clear() {\n      if (timeoutRef.current) {\n        clearTimeout(timeoutRef.current);\n        timeoutRef.current = null;\n      }\n    }\n    function onScroll() {\n      if (show && hideOnScroll) {\n        clear();\n        handleShowHide(false);\n      }\n    }\n    function onTouchEnd() {\n      if (show) {\n        clear();\n        handleShowHide(false);\n      }\n    }\n    window.addEventListener(\"scroll\", onScroll, true);\n    window.addEventListener(\"touchend\", onTouchEnd, true);\n    return function () {\n      window.removeEventListener(\"scroll\", onScroll, true);\n      window.removeEventListener(\"touchend\", onTouchEnd, true);\n      if (to) {\n        clearTimeout(to);\n      }\n    };\n  }, [show, hideOnScroll]);\n  var hoverProps = {\n    onMouseEnter: onMouseEnter,\n    onMouseLeave: onMouseLeave,\n    onTouchStart: function onTouchStart() {\n      hasTouchMoved.current = false;\n    },\n    onTouchMove: function onTouchMove() {\n      hasTouchMoved.current = true;\n    },\n    onTouchEnd: function onTouchEnd() {\n      if (!hasTouchMoved.current && !show) {\n        handleShowHide(true);\n      }\n      hasTouchMoved.current = false;\n    }\n  }; // @ts-ignore\n\n  if (onShow) {\n    return hoverProps;\n  }\n  return [show, hoverProps];\n}\nfunction useBreakpoint(maxPixels) {\n  var _useState13 = useState(typeof window !== \"undefined\" ? window.matchMedia(\"(max-width: \" + maxPixels + \"px)\").matches : false),\n    _useState14 = _slicedToArray(_useState13, 2),\n    match = _useState14[0],\n    setMatch = _useState14[1];\n  useEffect(function () {\n    var matcher = window.matchMedia(\"(max-width: \" + maxPixels + \"px)\");\n    function onMatch(evt) {\n      setMatch(evt.matches);\n    }\n    matcher.addListener(onMatch);\n    return function () {\n      matcher.removeListener(onMatch);\n    };\n  }, [maxPixels]);\n  return match;\n}\nfunction Transition(_ref23) {\n  var isOpenExternal = _ref23.isOpen,\n    children = _ref23.children;\n  var _useState15 = useState({\n      isOpenInternal: isOpenExternal,\n      isLeaving: false\n    }),\n    _useState16 = _slicedToArray(_useState15, 2),\n    state = _useState16[0],\n    setState = _useState16[1];\n  var didMount = useRef(false);\n  useEffect(function () {\n    if (isOpenExternal) {\n      setState({\n        isOpenInternal: true,\n        isLeaving: false\n      });\n    } else if (didMount.current) {\n      setState({\n        isOpenInternal: false,\n        isLeaving: true\n      });\n    }\n  }, [isOpenExternal, setState]);\n  useEffect(function () {\n    didMount.current = true;\n  }, []);\n  if (!isOpenExternal && !state.isOpenInternal && !state.isLeaving) {\n    return null;\n  }\n  return children(state.isOpenInternal, function () {\n    if (!state.isOpenInternal) {\n      setState(function (s) {\n        return _objectSpread(_objectSpread({}, s), {}, {\n          isLeaving: false\n        });\n      });\n    }\n  }, state.isLeaving);\n}\nfunction useTooltip(renderLayer) {\n  var _ref24 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n    delayEnter = _ref24.delayEnter,\n    delayLeave = _ref24.delayLeave,\n    hideOnScroll = _ref24.hideOnScroll,\n    rest = _objectWithoutProperties(_ref24, _excluded3);\n  var triggerRef = useRef();\n  var _useToggleLayer = useToggleLayer(renderLayer, rest),\n    _useToggleLayer2 = _slicedToArray(_useToggleLayer, 2),\n    element = _useToggleLayer2[0],\n    _useToggleLayer2$ = _useToggleLayer2[1],\n    openFromRef = _useToggleLayer2$.openFromRef,\n    close = _useToggleLayer2$.close;\n  var hoverProps = useHover({\n    delayEnter: delayEnter,\n    delayLeave: delayLeave,\n    hideOnScroll: hideOnScroll,\n    onShow: function onShow() {\n      return openFromRef(triggerRef);\n    },\n    onHide: close\n  });\n  var triggerProps = _objectSpread({\n    ref: triggerRef\n  }, hoverProps);\n  return [element, triggerProps];\n}\nexport { Arrow, ToggleLayer, Transition, Anchor as anchor, useBreakpoint, useHover, useToggleLayer, useTooltip };","import React from 'react'\nimport { useBreakpoint } from 'react-laag'\nimport { ParallaxHover } from 'react-parallax-hover'\nimport Link from '../Link/Link'\n\nimport './styles.scss'\n\nlet result\nlet external: false\n\ninterface GuideLinkProps {\n  link: string\n  title: string\n  subtitle: string\n  exampleImage: string\n  accentColor: string\n  external: false\n}\n\nconst GuideLink: React.FC<GuideLinkProps> = ({\n  link,\n  title,\n  subtitle,\n  exampleImage,\n  accentColor,\n  external\n}) => {\n  const isMobile = useBreakpoint(480)\n  const isTablet = useBreakpoint(768)\n\n  const linkWidth =\n    isMobile\n      ? 320\n      : isTablet\n        ? 350\n        : 294\n\n  if (external) {\n    return (\n      <a\n        className=\"guide-link\"\n        href={link}\n        target='_blank'\n        rel=\"noopener\"\n      >\n        <ParallaxHover\n          width={linkWidth}\n          height={270}\n          borderRadius={8}\n          shadow={0}\n          rotation={3}\n          shine={2}\n          scale={1}\n        >\n          <div className=\"guide-link__bg\" />\n          <div className=\"guide-link__accent-bg\" style={{ backgroundColor: accentColor }} />\n          <div className=\"guide-link__example-card\">\n            <img src={exampleImage} alt={title} />\n          </div>\n          <div className=\"guide-link__content\">\n            <h6>{title}</h6>\n            <p>{subtitle}</p>\n          </div>\n        </ParallaxHover>\n      </a>\n    )\n  } else {\n    return (\n      <Link to={link} className=\"guide-link\">\n        <ParallaxHover\n          width={linkWidth}\n          height={270}\n          borderRadius={8}\n          shadow={0}\n          rotation={3}\n          shine={2}\n          scale={1}\n        >\n          <div className=\"guide-link__bg\" />\n          <div className=\"guide-link__accent-bg\" style={{ backgroundColor: accentColor }} />\n          <div className=\"guide-link__example-card\">\n            <img src={exampleImage} alt={title} />\n          </div>\n          <div className=\"guide-link__content\">\n            <h6>{title}</h6>\n            <p>{subtitle}</p>\n          </div>\n        </ParallaxHover>\n      </Link>\n    )\n  }\n\n  return (\n    <Link to={link} className=\"guide-link\">\n      <ParallaxHover\n        width={linkWidth}\n        height={270}\n        borderRadius={8}\n        shadow={0}\n        rotation={3}\n        shine={2}\n        scale={1}\n      >\n        <div className=\"guide-link__bg\" />\n        <div className=\"guide-link__accent-bg\" style={{ backgroundColor: accentColor }} />\n        <div className=\"guide-link__example-card\">\n          <img src={exampleImage} alt={title} />\n        </div>\n        <div className=\"guide-link__content\">\n          <h6>{title}</h6>\n          <p>{subtitle}</p>\n        </div>\n      </ParallaxHover>\n    </Link>\n  )\n}\n\nexport default GuideLink\n","import React from 'react'\nimport Link from '../Link/Link'\n\nimport './styles.scss'\n\ninterface IntroLinkProps {\n  icon: string\n  title: string\n  description: string\n  link: string\n}\n\nconst IntroLink: React.FC<IntroLinkProps> = ({icon, title, description, link}) => {\n  return (\n    <Link className=\"intro-link\" to={link}>\n      <img src={icon} alt={title} className=\"intro-link__icon\" />\n      <div className=\"intro-link__content\">\n        <h5 className=\"mt-0 mb-0 text-primary\">{title}</h5>\n        <p className=\"mb-0 mt-2 text-dark-gray-2\">{description}</p>\n      </div>\n    </Link>\n  )\n}\n\nexport default IntroLink\n","import React from 'react'\nimport Link from '../Link/Link'\n\nimport './styles.scss'\n\ninterface NextStepProps {\n  title: string\n  children: React.ReactNode\n  side?: 'left' | 'right'\n  type?: 'default' | 'required' | 'recommended'\n  link: string\n}\n\nconst NextStep: React.FC<NextStepProps> = ({children, title, side, type, link}) => {\n  const displayType = type || 'default'\n\n  return (\n    <Link\n      className={`\n        next-step\n        ${side && `next-step--${side}`}\n        next-step--${displayType}\n      `}\n      to={link}\n    >\n      <h5>{title}</h5>\n      {children}\n    </Link>\n  )\n}\n\nexport default NextStep\n","import React from 'react'\nimport { FormattedMessage } from 'react-intl'\nimport Scrollspy from 'react-scrollspy'\nimport { flatDeep } from '../../utilities/utilities'\n\nimport streamIcon from './stream.svg'\n\ninterface ArticleHeader {\n  url: string\n  title: string\n  items?: ArticleHeader[],\n  level?: number\n}\n\ninterface ArticleTOCProps {\n  items: ArticleHeader[]\n}\n\nconst ArticleTOC: React.FC<ArticleTOCProps> = ({items}) => {\n\n  const flattenTOCHeaders = (articleHeaders: ArticleHeader[], level: number = 1): any[] => {\n    return flatDeep(articleHeaders.map(ah => {\n      if(ah.items) {\n        return [\n          {\n            level,\n            title: ah.title,\n            url: ah.url,\n          },\n          ...flattenTOCHeaders(ah.items, level+1)\n        ]\n      } else {\n        return {\n          level,\n          title: ah.title,\n          url: ah.url,\n        }\n      }\n    }), Infinity)\n  }\n\n  const listedItems = flattenTOCHeaders(items)\n\n  return (\n    <aside className=\"docs-toc\">\n      <div className=\"position-sticky\">\n        <h6 className=\"docs-toc__title\"><img src={streamIcon} alt=\"Stream icon\" /> <FormattedMessage id=\"articles.toc_title\"/></h6>\n        <Scrollspy\n          className=\"docs-toc__list\"\n          items={\n            listedItems\n            .map((item: ArticleHeader) => item.url ? item.url.substring(1) : '')\n          }\n          currentClassName=\"docs-toc__link--current\"\n        >\n          {\n            listedItems.map((item: ArticleHeader) =>\n              <li\n                key={item.url}\n                className={`docs-toc__link docs-toc__link--level-${item.level}`}\n              >\n                <a href={item.url}>{item.title}</a>\n              </li>\n            )\n          }\n        </Scrollspy>\n      </div>\n    </aside>\n  )\n}\n\nexport default ArticleTOC\n","\nimport { MDXProvider } from '@mdx-js/react'\nimport { navigate, useLocation } from '@reach/router';\nimport * as queryString from 'query-string';\n\nimport { MDXRenderer } from 'gatsby-plugin-mdx'\nimport React, { useContext, useEffect, useState } from 'react'\nimport TabsContext from '../../context/TabsContext'\nimport { stringToSlug } from '../../utilities/utilities'\nimport Aside from '../Aside/Aside'\nimport CodeHighlight from '../CodeHighlight/CodeHighlight'\nimport CodeTabs from '../CodeTabs/CodeTabs'\nimport CountryContent from '../CountryContent/CountryContent'\nimport GuideLink from '../GuideLink/GuideLink';\nimport IntroLink from '../IntroLink/IntroLink';\nimport Link from '../Link/Link'\nimport NextStep from '../NextStep/NextStep'\nimport ArticleTOC from './ArticleTOC'\n\nimport clockIcon from './clock.svg'\n\nimport './styles.scss'\n\nconst shortCodes = {\n  Aside,\n  CodeTabs,\n  CountryContent,\n  GuideLink,\n  IntroLink,\n  NextStep,\n  a: (props: any) => {\n    if(props.href.substring(0,1) === '/') {\n      const { href, ...newProps } = props\n      return <Link to={href} {...newProps} />\n    } else {\n      return <a {...props}/>\n    }\n  },\n  pre: (props: any) => {\n    const className = props.children.props.className || ''\n    const matches = className.match(/language-(?<lang>.*)/)\n\n    if(matches) {\n      const lang = matches.groups.lang\n\n      return <CodeHighlight code={props.children.props.children} language={lang} />\n    } else {\n      return <CodeHighlight code={props.children.props.children} language=\"\"/>\n    }\n  },\n}\n\ninterface ArticleProps {\n  title: string\n  subtitle: string\n  contents: any\n  country: string\n  fullWidth?: boolean\n  hero?: boolean\n  heroImg?: string\n  heroTextColor?: string\n}\n\nconst Article: React.FC<ArticleProps> = ({\n  title,\n  subtitle,\n  fullWidth,\n  contents,\n  hero,\n  heroImg,\n  heroTextColor,\n}) => {\n  const [selectedTab, setSelectedTab] = useState(0)\n  // const [animations, setAnimations] = useState<{[key: string]: Animation}>(animationsInitialState)\n  const tabsContext = useContext(TabsContext)\n\n  const location = useLocation()\n\n  useEffect(() => {\n    const qs = queryString.parse(location.search)\n    if(qs.tab) {\n      contents.forEach((content: any, index: number) => {\n        if(content.tabTitle === qs.tab) {\n          setSelectedTab(index)\n        }\n      })\n    } else if(tabsContext.preferredTabs.mainTabs) {\n      contents.forEach((content: any, index: number) => {\n        if(content.tabTitle === tabsContext.preferredTabs.mainTabs) {\n          setSelectedTab(index)\n          navigate(`?tab=${tabsContext.preferredTabs.mainTabs}`)\n        }\n      })\n    }\n    // Start of Survicate (www.survicate.com) code\n      if( undefined !== window ){\n        (function(w) {\n          var s = document.createElement(`script`);\n          s.src = `https://survey.survicate.com/workspaces/06bf5ed6cc8cad7ea547f976c79dbcb6/web_surveys.js`;\n          s.async = true;\n          var e = document.getElementsByTagName(`script`)[0];\n          e.parentNode.insertBefore(s, e);\n        })(window);\n      }\n    // End of Survicate code\n  }, []);\n\n  const selectTab = (newIndex: number) : void => {\n    if(newIndex !== selectedTab) {\n      setSelectedTab(newIndex)\n\n      navigate(`?tab=${contents[newIndex].tabTitle}`);\n\n      tabsContext.setPreferredTab(contents[newIndex].tabTitle, 'mainTabs')\n    }\n  }\n\n  return (\n    <MDXProvider components={shortCodes}>\n      {\n        hero &&\n        <div className=\"article-hero\"\n          style={{\n            backgroundImage: `url(${heroImg})`,\n            color: heroTextColor,\n          }}\n        >\n          <div className=\"article-container\">\n            <header>\n              <div className=\"article-hero-titles\">\n                <h1 id={stringToSlug(title)} className=\"mt-0\">{title}</h1>\n                <p className=\"lead\">{subtitle}</p>\n              </div>\n            </header>\n          </div>\n        </div>\n      }\n      <div className=\"article-container\">\n        <article className=\"article\">\n          {\n            !hero &&\n            <header>\n              <div className=\"article-titles\">\n                <div className=\"d-flex justify-content-between flex-column flex-lg-row\">\n                  <h1 id={stringToSlug(title)} className=\"mt-0 order-2 order-lg-1\">{title}</h1>\n                  <div className=\"article-date order-1 order-lg-2\">\n                    <img src={clockIcon} alt=\"clock\" height=\"14px\" width=\"auto\" className=\"mr-2\"/> {contents[selectedTab].updatedAt}\n                  </div>\n                </div>\n                <p className=\"lead\">{subtitle}</p>\n              </div>\n            </header>\n          }\n\n          {\n            contents.length > 1 &&\n            <div className=\"article-tabs\">\n              {\n                contents.map((content: any, index: number) =>\n                  <div\n                    className={`\n                      article-tab\n                      ${index === selectedTab && 'article-tab--selected'}\n                    `}\n                    key={content.tabTitle}\n                    onClick={() => selectTab(index)}\n                  >\n                    <span className=\"article-tab__title\">\n                      {content.tabTitle}\n                    </span>\n                  </div>\n                )\n              }\n            </div>\n          }\n          {\n            contents.length > 1\n            ?\n              <MDXRenderer>\n                {contents[selectedTab].body.childMdx.body}\n              </MDXRenderer>\n            : <MDXRenderer>\n                {contents[0].body.childMdx.body}\n              </MDXRenderer>\n          }\n        </article>\n        {\n          !fullWidth &&\n          contents[selectedTab].body.childMdx.tableOfContents.items &&\n          <ArticleTOC items={contents[selectedTab].body.childMdx.tableOfContents.items} />\n        }\n\n      </div>\n    </MDXProvider>\n  )\n}\n\nexport default Article\n"],"sourceRoot":""}