component---src-templates-doc-jsx-21a94bb36ef3df298f42.js.map

{"version":3,"sources":["webpack:///./node_modules/prismjs/components/prism-markup.min.js","webpack:///./node_modules/prismjs/components/prism-java.min.js","webpack:///./src/templates/doc.jsx","webpack:///./node_modules/prismjs/prism.js","webpack:///./node_modules/prismjs/components/prism-yaml.min.js"],"names":["Prism","languages","markup","comment","prolog","doctype","pattern","greedy","inside","lookbehind","string","punctuation","name","cdata","tag","namespace","alias","entity","hooks","add","a","type","attributes","title","content","replace","Object","defineProperty","value","e","s","n","t","RegExp","insertBefore","html","mathml","svg","xml","extend","ssml","atom","rss","java","keyword","function","clike","number","operator","annotation","generics","source","componentDidMount","window","highlightAll","Doc","data","asciidocCopy","document","subtitle","__html","langKey","pageContext","useEffect","className","description","lang","dangerouslySetInnerHTML","_self","uniqueId","_","manual","disableWorkerMessageHandler","util","encode","tokens","Token","Array","isArray","map","o","prototype","toString","call","slice","objId","obj","clone","deepClone","visited","id","key","hasOwnProperty","forEach","v","i","getLanguage","element","test","parentElement","match","toLowerCase","currentScript","Error","err","src","exec","stack","scripts","getElementsByTagName","isActive","defaultActivation","no","classList","contains","redef","before","insert","root","grammar","ret","token","newToken","old","DFS","this","callback","property","propertyType","plugins","async","highlightAllUnder","container","env","selector","run","elements","apply","querySelectorAll","highlightElement","language","parent","nodeName","code","textContent","insertHighlightedCode","highlightedCode","innerHTML","Worker","worker","filename","onmessage","evt","postMessage","JSON","stringify","immediateClose","highlight","text","tokenize","rest","tokenList","LinkedList","addAfter","head","matchGrammar","startNode","startPos","rematch","patterns","j","length","cause","patternObj","global","flags","currentNode","next","pos","tail","reach","str","removeCount","matchPattern","from","index","to","p","k","matchStr","after","removeFrom","prev","removeRange","wrapped","list","array","node","push","toArray","all","callbacks","matchedStr","lastIndex","lookbehindLength","newNode","count","classes","aliases","join","addEventListener","message","parse","close","script","highlightAutomaticallyCallback","hasAttribute","readyState","defer","requestAnimationFrame","setTimeout","WorkerGlobalScope","self","module","exports","tagName","includedCdataInside","def","css","addInlined","javascript","regex","js","Element","matches","msMatchesSelector","webkitMatchesSelector","EXTENSIONS","SELECTOR","pre","setAttribute","appendChild","createElement","getAttribute","extension","setLanguageClass","autoloader","loadLanguages","xhr","XMLHttpRequest","open","onreadystatechange","status","responseText","statusText","send","fileHighlight","logged","console","warn","arguments","trim","r","d","yaml","scalar","directive","datetime","boolean","null","important","yml"],"mappings":"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","file":"component---src-templates-doc-jsx-21a94bb36ef3df298f42.js","sourcesContent":["Prism.languages.markup = {\n  comment: /<!--[\\s\\S]*?-->/,\n  prolog: /<\\?[\\s\\S]+?\\?>/,\n  doctype: {\n    pattern: /<!DOCTYPE(?:[^>\"'[\\]]|\"[^\"]*\"|'[^']*')+(?:\\[(?:[^<\"'\\]]|\"[^\"]*\"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\\]\\s*)?>/i,\n    greedy: !0,\n    inside: {\n      \"internal-subset\": {\n        pattern: /(\\[)[\\s\\S]+(?=\\]>$)/,\n        lookbehind: !0,\n        greedy: !0,\n        inside: null\n      },\n      string: {\n        pattern: /\"[^\"]*\"|'[^']*'/,\n        greedy: !0\n      },\n      punctuation: /^<!|>$|[[\\]]/,\n      \"doctype-tag\": /^DOCTYPE/,\n      name: /[^\\s<>'\"]+/\n    }\n  },\n  cdata: /<!\\[CDATA\\[[\\s\\S]*?]]>/i,\n  tag: {\n    pattern: /<\\/?(?!\\d)[^\\s>\\/=$<%]+(?:\\s(?:\\s*[^\\s>\\/=]+(?:\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s'\">=]+(?=[\\s>]))|(?=[\\s/>])))+)?\\s*\\/?>/,\n    greedy: !0,\n    inside: {\n      tag: {\n        pattern: /^<\\/?[^\\s>\\/]+/,\n        inside: {\n          punctuation: /^<\\/?/,\n          namespace: /^[^\\s>\\/:]+:/\n        }\n      },\n      \"attr-value\": {\n        pattern: /=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s'\">=]+)/,\n        inside: {\n          punctuation: [{\n            pattern: /^=/,\n            alias: \"attr-equals\"\n          }, /\"|'/]\n        }\n      },\n      punctuation: /\\/?>/,\n      \"attr-name\": {\n        pattern: /[^\\s>\\/]+/,\n        inside: {\n          namespace: /^[^\\s>\\/:]+:/\n        }\n      }\n    }\n  },\n  entity: [{\n    pattern: /&[\\da-z]{1,8};/i,\n    alias: \"named-entity\"\n  }, /&#x?[\\da-f]{1,8};/i]\n}, Prism.languages.markup.tag.inside[\"attr-value\"].inside.entity = Prism.languages.markup.entity, Prism.languages.markup.doctype.inside[\"internal-subset\"].inside = Prism.languages.markup, Prism.hooks.add(\"wrap\", function (a) {\n  \"entity\" === a.type && (a.attributes.title = a.content.replace(/&amp;/, \"&\"));\n}), Object.defineProperty(Prism.languages.markup.tag, \"addInlined\", {\n  value: function value(a, e) {\n    var s = {};\n    s[\"language-\" + e] = {\n      pattern: /(^<!\\[CDATA\\[)[\\s\\S]+?(?=\\]\\]>$)/i,\n      lookbehind: !0,\n      inside: Prism.languages[e]\n    }, s.cdata = /^<!\\[CDATA\\[|\\]\\]>$/i;\n    var n = {\n      \"included-cdata\": {\n        pattern: /<!\\[CDATA\\[[\\s\\S]*?\\]\\]>/i,\n        inside: s\n      }\n    };\n    n[\"language-\" + e] = {\n      pattern: /[\\s\\S]+/,\n      inside: Prism.languages[e]\n    };\n    var t = {};\n    t[a] = {\n      pattern: RegExp(\"(<__[^>]*>)(?:<!\\\\[CDATA\\\\[(?:[^\\\\]]|\\\\](?!\\\\]>))*\\\\]\\\\]>|(?!<!\\\\[CDATA\\\\[)[^])*?(?=</__>)\".replace(/__/g, function () {\n        return a;\n      }), \"i\"),\n      lookbehind: !0,\n      greedy: !0,\n      inside: n\n    }, Prism.languages.insertBefore(\"markup\", \"cdata\", t);\n  }\n}), Prism.languages.html = Prism.languages.markup, Prism.languages.mathml = Prism.languages.markup, Prism.languages.svg = Prism.languages.markup, Prism.languages.xml = Prism.languages.extend(\"markup\", {}), Prism.languages.ssml = Prism.languages.xml, Prism.languages.atom = Prism.languages.xml, Prism.languages.rss = Prism.languages.xml;","!function (e) {\n  var t = /\\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\\b/,\n      n = \"(^|[^\\\\w.])(?:[a-z]\\\\w*\\\\s*\\\\.\\\\s*)*(?:[A-Z]\\\\w*\\\\s*\\\\.\\\\s*)*\",\n      a = {\n    pattern: RegExp(n + \"[A-Z](?:[\\\\d_A-Z]*[a-z]\\\\w*)?\\\\b\"),\n    lookbehind: !0,\n    inside: {\n      namespace: {\n        pattern: /^[a-z]\\w*(?:\\s*\\.\\s*[a-z]\\w*)*(?:\\s*\\.)?/,\n        inside: {\n          punctuation: /\\./\n        }\n      },\n      punctuation: /\\./\n    }\n  };\n  e.languages.java = e.languages.extend(\"clike\", {\n    \"class-name\": [a, {\n      pattern: RegExp(n + \"[A-Z]\\\\w*(?=\\\\s+\\\\w+\\\\s*[;,=())])\"),\n      lookbehind: !0,\n      inside: a.inside\n    }],\n    keyword: t,\n    function: [e.languages.clike.function, {\n      pattern: /(\\:\\:\\s*)[a-z_]\\w*/,\n      lookbehind: !0\n    }],\n    number: /\\b0b[01][01_]*L?\\b|\\b0x(?:\\.[\\da-f_p+-]+|[\\da-f_]+(?:\\.[\\da-f_p+-]+)?)\\b|(?:\\b\\d[\\d_]*(?:\\.[\\d_]*)?|\\B\\.\\d[\\d_]*)(?:e[+-]?\\d[\\d_]*)?[dfl]?/i,\n    operator: {\n      pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\\+\\+|&&|\\|\\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,\n      lookbehind: !0\n    }\n  }), e.languages.insertBefore(\"java\", \"string\", {\n    \"triple-quoted-string\": {\n      pattern: /\"\"\"[ \\t]*[\\r\\n](?:(?:\"|\"\")?(?:\\\\.|[^\"\\\\]))*\"\"\"/,\n      greedy: !0,\n      alias: \"string\"\n    }\n  }), e.languages.insertBefore(\"java\", \"class-name\", {\n    annotation: {\n      pattern: /(^|[^.])@\\w+(?:\\s*\\.\\s*\\w+)*/,\n      lookbehind: !0,\n      alias: \"punctuation\"\n    },\n    generics: {\n      pattern: /<(?:[\\w\\s,.&?]|<(?:[\\w\\s,.&?]|<(?:[\\w\\s,.&?]|<[\\w\\s,.&?]*>)*>)*>)*>/,\n      inside: {\n        \"class-name\": a,\n        keyword: t,\n        punctuation: /[<>(),.:]/,\n        operator: /[?&|]/\n      }\n    },\n    namespace: {\n      pattern: RegExp(\"(\\\\b(?:exports|import(?:\\\\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\\\\s+)(?!<keyword>)[a-z]\\\\w*(?:\\\\.[a-z]\\\\w*)*\\\\.?\".replace(/<keyword>/g, function () {\n        return t.source;\n      })),\n      lookbehind: !0,\n      inside: {\n        punctuation: /\\./\n      }\n    }\n  });\n}(Prism);","import React, {useEffect} from 'react';\nimport {graphql} from 'gatsby';\nimport Header from '../components/header';\nimport Seo from '../components/seo';\nimport 'prismjs/prism';\nimport 'prismjs/components/prism-java.min'\nimport 'prismjs/components/prism-markup.min'\nimport 'prismjs/components/prism-yaml.min'\nimport 'prismjs/themes/prism-solarizedlight.css'\nimport '../styles/main.scss';\n\nconst componentDidMount = () => {\n  window.Prism.highlightAll()\n};\n\nconst Doc = ({\n  data: {\n    asciidocCopy: {\n      document: {\n        title,\n        subtitle\n      },\n      html: __html\n    }\n  },\n  pageContext: {langKey}\n}) => {\n  useEffect(componentDidMount, []);\n  return (\n    <div className='eclipse-jkube'>\n      <Seo title={title} description={subtitle} lang={langKey}/>\n      <Header lang={langKey}/>\n      <div className='eclipse-jkube__documentation book toc2 toc-left'>\n        <div\n          className='eclipse-jkube__documentation-content'\n          dangerouslySetInnerHTML={{__html}}\n        />\n      </div>\n    </div>\n  );\n};\n\n\nexport const pageQuery = graphql`\n  query($id: String!) {\n    asciidocCopy(id: { eq: $id }) {\n      html\n      document {\n        title\n        subtitle\n      }\n    }\n  }\n`;\n\nexport default Doc;\n","/* **********************************************\n     Begin prism-core.js\n********************************************** */\n/// <reference lib=\"WebWorker\"/>\nvar _self = typeof window !== 'undefined' ? window // if in browser\n: typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope ? self // if in worker\n: {} // if in node js\n;\n/**\n * Prism: Lightweight, robust, elegant syntax highlighting\n *\n * @license MIT <https://opensource.org/licenses/MIT>\n * @author Lea Verou <https://lea.verou.me>\n * @namespace\n * @public\n */\n\n\nvar Prism = function (_self) {\n  // Private helper vars\n  var lang = /\\blang(?:uage)?-([\\w-]+)\\b/i;\n  var uniqueId = 0;\n  var _ = {\n    /**\n     * By default, Prism will attempt to highlight all code elements (by calling {@link Prism.highlightAll}) on the\n     * current page after the page finished loading. This might be a problem if e.g. you wanted to asynchronously load\n     * additional languages or plugins yourself.\n     *\n     * By setting this value to `true`, Prism will not automatically highlight all code elements on the page.\n     *\n     * You obviously have to change this value before the automatic highlighting started. To do this, you can add an\n     * empty Prism object into the global scope before loading the Prism script like this:\n     *\n     * ```js\n     * window.Prism = window.Prism || {};\n     * Prism.manual = true;\n     * // add a new <script> to load Prism's script\n     * ```\n     *\n     * @default false\n     * @type {boolean}\n     * @memberof Prism\n     * @public\n     */\n    manual: _self.Prism && _self.Prism.manual,\n    disableWorkerMessageHandler: _self.Prism && _self.Prism.disableWorkerMessageHandler,\n\n    /**\n     * A namespace for utility methods.\n     *\n     * All function in this namespace that are not explicitly marked as _public_ are for __internal use only__ and may\n     * change or disappear at any time.\n     *\n     * @namespace\n     * @memberof Prism\n     */\n    util: {\n      encode: function encode(tokens) {\n        if (tokens instanceof Token) {\n          return new Token(tokens.type, encode(tokens.content), tokens.alias);\n        } else if (Array.isArray(tokens)) {\n          return tokens.map(encode);\n        } else {\n          return tokens.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/\\u00a0/g, ' ');\n        }\n      },\n\n      /**\n       * Returns the name of the type of the given value.\n       *\n       * @param {any} o\n       * @returns {string}\n       * @example\n       * type(null)      === 'Null'\n       * type(undefined) === 'Undefined'\n       * type(123)       === 'Number'\n       * type('foo')     === 'String'\n       * type(true)      === 'Boolean'\n       * type([1, 2])    === 'Array'\n       * type({})        === 'Object'\n       * type(String)    === 'Function'\n       * type(/abc+/)    === 'RegExp'\n       */\n      type: function type(o) {\n        return Object.prototype.toString.call(o).slice(8, -1);\n      },\n\n      /**\n       * Returns a unique number for the given object. Later calls will still return the same number.\n       *\n       * @param {Object} obj\n       * @returns {number}\n       */\n      objId: function objId(obj) {\n        if (!obj['__id']) {\n          Object.defineProperty(obj, '__id', {\n            value: ++uniqueId\n          });\n        }\n\n        return obj['__id'];\n      },\n\n      /**\n       * Creates a deep clone of the given object.\n       *\n       * The main intended use of this function is to clone language definitions.\n       *\n       * @param {T} o\n       * @param {Record<number, any>} [visited]\n       * @returns {T}\n       * @template T\n       */\n      clone: function deepClone(o, visited) {\n        visited = visited || {};\n        var clone, id;\n\n        switch (_.util.type(o)) {\n          case 'Object':\n            id = _.util.objId(o);\n\n            if (visited[id]) {\n              return visited[id];\n            }\n\n            clone =\n            /** @type {Record<string, any>} */\n            {};\n            visited[id] = clone;\n\n            for (var key in o) {\n              if (o.hasOwnProperty(key)) {\n                clone[key] = deepClone(o[key], visited);\n              }\n            }\n\n            return (\n              /** @type {any} */\n              clone\n            );\n\n          case 'Array':\n            id = _.util.objId(o);\n\n            if (visited[id]) {\n              return visited[id];\n            }\n\n            clone = [];\n            visited[id] = clone;\n\n            /** @type {Array} */\n\n            /** @type {any} */\n            o.forEach(function (v, i) {\n              clone[i] = deepClone(v, visited);\n            });\n            return (\n              /** @type {any} */\n              clone\n            );\n\n          default:\n            return o;\n        }\n      },\n\n      /**\n       * Returns the Prism language of the given element set by a `language-xxxx` or `lang-xxxx` class.\n       *\n       * If no language is set for the element or the element is `null` or `undefined`, `none` will be returned.\n       *\n       * @param {Element} element\n       * @returns {string}\n       */\n      getLanguage: function getLanguage(element) {\n        while (element && !lang.test(element.className)) {\n          element = element.parentElement;\n        }\n\n        if (element) {\n          return (element.className.match(lang) || [, 'none'])[1].toLowerCase();\n        }\n\n        return 'none';\n      },\n\n      /**\n       * Returns the script element that is currently executing.\n       *\n       * This does __not__ work for line script element.\n       *\n       * @returns {HTMLScriptElement | null}\n       */\n      currentScript: function currentScript() {\n        if (typeof document === 'undefined') {\n          return null;\n        }\n\n        if ('currentScript' in document && 1 < 2\n        /* hack to trip TS' flow analysis */\n        ) {\n            return (\n              /** @type {any} */\n              document.currentScript\n            );\n          } // IE11 workaround\n        // we'll get the src of the current script by parsing IE11's error stack trace\n        // this will not work for inline scripts\n\n\n        try {\n          throw new Error();\n        } catch (err) {\n          // Get file src url from stack. Specifically works with the format of stack traces in IE.\n          // A stack will look like this:\n          //\n          // Error\n          //    at _.util.currentScript (http://localhost/components/prism-core.js:119:5)\n          //    at Global code (http://localhost/components/prism-core.js:606:1)\n          var src = (/at [^(\\r\\n]*\\((.*):.+:.+\\)$/i.exec(err.stack) || [])[1];\n\n          if (src) {\n            var scripts = document.getElementsByTagName('script');\n\n            for (var i in scripts) {\n              if (scripts[i].src == src) {\n                return scripts[i];\n              }\n            }\n          }\n\n          return null;\n        }\n      },\n\n      /**\n       * Returns whether a given class is active for `element`.\n       *\n       * The class can be activated if `element` or one of its ancestors has the given class and it can be deactivated\n       * if `element` or one of its ancestors has the negated version of the given class. The _negated version_ of the\n       * given class is just the given class with a `no-` prefix.\n       *\n       * Whether the class is active is determined by the closest ancestor of `element` (where `element` itself is\n       * closest ancestor) that has the given class or the negated version of it. If neither `element` nor any of its\n       * ancestors have the given class or the negated version of it, then the default activation will be returned.\n       *\n       * In the paradoxical situation where the closest ancestor contains __both__ the given class and the negated\n       * version of it, the class is considered active.\n       *\n       * @param {Element} element\n       * @param {string} className\n       * @param {boolean} [defaultActivation=false]\n       * @returns {boolean}\n       */\n      isActive: function isActive(element, className, defaultActivation) {\n        var no = 'no-' + className;\n\n        while (element) {\n          var classList = element.classList;\n\n          if (classList.contains(className)) {\n            return true;\n          }\n\n          if (classList.contains(no)) {\n            return false;\n          }\n\n          element = element.parentElement;\n        }\n\n        return !!defaultActivation;\n      }\n    },\n\n    /**\n     * This namespace contains all currently loaded languages and the some helper functions to create and modify languages.\n     *\n     * @namespace\n     * @memberof Prism\n     * @public\n     */\n    languages: {\n      /**\n       * Creates a deep copy of the language with the given id and appends the given tokens.\n       *\n       * If a token in `redef` also appears in the copied language, then the existing token in the copied language\n       * will be overwritten at its original position.\n       *\n       * ## Best practices\n       *\n       * Since the position of overwriting tokens (token in `redef` that overwrite tokens in the copied language)\n       * doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to\n       * understand the language definition because, normally, the order of tokens matters in Prism grammars.\n       *\n       * Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens.\n       * Furthermore, all non-overwriting tokens should be placed after the overwriting ones.\n       *\n       * @param {string} id The id of the language to extend. This has to be a key in `Prism.languages`.\n       * @param {Grammar} redef The new tokens to append.\n       * @returns {Grammar} The new language created.\n       * @public\n       * @example\n       * Prism.languages['css-with-colors'] = Prism.languages.extend('css', {\n       *     // Prism.languages.css already has a 'comment' token, so this token will overwrite CSS' 'comment' token\n       *     // at its original position\n       *     'comment': { ... },\n       *     // CSS doesn't have a 'color' token, so this token will be appended\n       *     'color': /\\b(?:red|green|blue)\\b/\n       * });\n       */\n      extend: function extend(id, redef) {\n        var lang = _.util.clone(_.languages[id]);\n\n        for (var key in redef) {\n          lang[key] = redef[key];\n        }\n\n        return lang;\n      },\n\n      /**\n       * Inserts tokens _before_ another token in a language definition or any other grammar.\n       *\n       * ## Usage\n       *\n       * This helper method makes it easy to modify existing languages. For example, the CSS language definition\n       * not only defines CSS highlighting for CSS documents, but also needs to define highlighting for CSS embedded\n       * in HTML through `<style>` elements. To do this, it needs to modify `Prism.languages.markup` and add the\n       * appropriate tokens. However, `Prism.languages.markup` is a regular JavaScript object literal, so if you do\n       * this:\n       *\n       * ```js\n       * Prism.languages.markup.style = {\n       *     // token\n       * };\n       * ```\n       *\n       * then the `style` token will be added (and processed) at the end. `insertBefore` allows you to insert tokens\n       * before existing tokens. For the CSS example above, you would use it like this:\n       *\n       * ```js\n       * Prism.languages.insertBefore('markup', 'cdata', {\n       *     'style': {\n       *         // token\n       *     }\n       * });\n       * ```\n       *\n       * ## Special cases\n       *\n       * If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar\n       * will be ignored.\n       *\n       * This behavior can be used to insert tokens after `before`:\n       *\n       * ```js\n       * Prism.languages.insertBefore('markup', 'comment', {\n       *     'comment': Prism.languages.markup.comment,\n       *     // tokens after 'comment'\n       * });\n       * ```\n       *\n       * ## Limitations\n       *\n       * The main problem `insertBefore` has to solve is iteration order. Since ES2015, the iteration order for object\n       * properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave\n       * differently when keys are deleted and re-inserted. So `insertBefore` can't be implemented by temporarily\n       * deleting properties which is necessary to insert at arbitrary positions.\n       *\n       * To solve this problem, `insertBefore` doesn't actually insert the given tokens into the target object.\n       * Instead, it will create a new object and replace all references to the target object with the new one. This\n       * can be done without temporarily deleting properties, so the iteration order is well-defined.\n       *\n       * However, only references that can be reached from `Prism.languages` or `insert` will be replaced. I.e. if\n       * you hold the target object in a variable, then the value of the variable will not change.\n       *\n       * ```js\n       * var oldMarkup = Prism.languages.markup;\n       * var newMarkup = Prism.languages.insertBefore('markup', 'comment', { ... });\n       *\n       * assert(oldMarkup !== Prism.languages.markup);\n       * assert(newMarkup === Prism.languages.markup);\n       * ```\n       *\n       * @param {string} inside The property of `root` (e.g. a language id in `Prism.languages`) that contains the\n       * object to be modified.\n       * @param {string} before The key to insert before.\n       * @param {Grammar} insert An object containing the key-value pairs to be inserted.\n       * @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the\n       * object to be modified.\n       *\n       * Defaults to `Prism.languages`.\n       * @returns {Grammar} The new grammar object.\n       * @public\n       */\n      insertBefore: function insertBefore(inside, before, insert, root) {\n        root = root ||\n        /** @type {any} */\n        _.languages;\n        var grammar = root[inside];\n        /** @type {Grammar} */\n\n        var ret = {};\n\n        for (var token in grammar) {\n          if (grammar.hasOwnProperty(token)) {\n            if (token == before) {\n              for (var newToken in insert) {\n                if (insert.hasOwnProperty(newToken)) {\n                  ret[newToken] = insert[newToken];\n                }\n              }\n            } // Do not insert token which also occur in insert. See #1525\n\n\n            if (!insert.hasOwnProperty(token)) {\n              ret[token] = grammar[token];\n            }\n          }\n        }\n\n        var old = root[inside];\n        root[inside] = ret; // Update references in other language definitions\n\n        _.languages.DFS(_.languages, function (key, value) {\n          if (value === old && key != inside) {\n            this[key] = ret;\n          }\n        });\n\n        return ret;\n      },\n      // Traverse a language definition with Depth First Search\n      DFS: function DFS(o, callback, type, visited) {\n        visited = visited || {};\n        var objId = _.util.objId;\n\n        for (var i in o) {\n          if (o.hasOwnProperty(i)) {\n            callback.call(o, i, o[i], type || i);\n\n            var property = o[i],\n                propertyType = _.util.type(property);\n\n            if (propertyType === 'Object' && !visited[objId(property)]) {\n              visited[objId(property)] = true;\n              DFS(property, callback, null, visited);\n            } else if (propertyType === 'Array' && !visited[objId(property)]) {\n              visited[objId(property)] = true;\n              DFS(property, callback, i, visited);\n            }\n          }\n        }\n      }\n    },\n    plugins: {},\n\n    /**\n     * This is the most high-level function in Prism’s API.\n     * It fetches all the elements that have a `.language-xxxx` class and then calls {@link Prism.highlightElement} on\n     * each one of them.\n     *\n     * This is equivalent to `Prism.highlightAllUnder(document, async, callback)`.\n     *\n     * @param {boolean} [async=false] Same as in {@link Prism.highlightAllUnder}.\n     * @param {HighlightCallback} [callback] Same as in {@link Prism.highlightAllUnder}.\n     * @memberof Prism\n     * @public\n     */\n    highlightAll: function highlightAll(async, callback) {\n      _.highlightAllUnder(document, async, callback);\n    },\n\n    /**\n     * Fetches all the descendants of `container` that have a `.language-xxxx` class and then calls\n     * {@link Prism.highlightElement} on each one of them.\n     *\n     * The following hooks will be run:\n     * 1. `before-highlightall`\n     * 2. `before-all-elements-highlight`\n     * 3. All hooks of {@link Prism.highlightElement} for each element.\n     *\n     * @param {ParentNode} container The root element, whose descendants that have a `.language-xxxx` class will be highlighted.\n     * @param {boolean} [async=false] Whether each element is to be highlighted asynchronously using Web Workers.\n     * @param {HighlightCallback} [callback] An optional callback to be invoked on each element after its highlighting is done.\n     * @memberof Prism\n     * @public\n     */\n    highlightAllUnder: function highlightAllUnder(container, async, callback) {\n      var env = {\n        callback: callback,\n        container: container,\n        selector: 'code[class*=\"language-\"], [class*=\"language-\"] code, code[class*=\"lang-\"], [class*=\"lang-\"] code'\n      };\n\n      _.hooks.run('before-highlightall', env);\n\n      env.elements = Array.prototype.slice.apply(env.container.querySelectorAll(env.selector));\n\n      _.hooks.run('before-all-elements-highlight', env);\n\n      for (var i = 0, element; element = env.elements[i++];) {\n        _.highlightElement(element, async === true, env.callback);\n      }\n    },\n\n    /**\n     * Highlights the code inside a single element.\n     *\n     * The following hooks will be run:\n     * 1. `before-sanity-check`\n     * 2. `before-highlight`\n     * 3. All hooks of {@link Prism.highlight}. These hooks will be run by an asynchronous worker if `async` is `true`.\n     * 4. `before-insert`\n     * 5. `after-highlight`\n     * 6. `complete`\n     *\n     * Some the above hooks will be skipped if the element doesn't contain any text or there is no grammar loaded for\n     * the element's language.\n     *\n     * @param {Element} element The element containing the code.\n     * It must have a class of `language-xxxx` to be processed, where `xxxx` is a valid language identifier.\n     * @param {boolean} [async=false] Whether the element is to be highlighted asynchronously using Web Workers\n     * to improve performance and avoid blocking the UI when highlighting very large chunks of code. This option is\n     * [disabled by default](https://prismjs.com/faq.html#why-is-asynchronous-highlighting-disabled-by-default).\n     *\n     * Note: All language definitions required to highlight the code must be included in the main `prism.js` file for\n     * asynchronous highlighting to work. You can build your own bundle on the\n     * [Download page](https://prismjs.com/download.html).\n     * @param {HighlightCallback} [callback] An optional callback to be invoked after the highlighting is done.\n     * Mostly useful when `async` is `true`, since in that case, the highlighting is done asynchronously.\n     * @memberof Prism\n     * @public\n     */\n    highlightElement: function highlightElement(element, async, callback) {\n      // Find language\n      var language = _.util.getLanguage(element);\n\n      var grammar = _.languages[language]; // Set language on the element, if not present\n\n      element.className = element.className.replace(lang, '').replace(/\\s+/g, ' ') + ' language-' + language; // Set language on the parent, for styling\n\n      var parent = element.parentElement;\n\n      if (parent && parent.nodeName.toLowerCase() === 'pre') {\n        parent.className = parent.className.replace(lang, '').replace(/\\s+/g, ' ') + ' language-' + language;\n      }\n\n      var code = element.textContent;\n      var env = {\n        element: element,\n        language: language,\n        grammar: grammar,\n        code: code\n      };\n\n      function insertHighlightedCode(highlightedCode) {\n        env.highlightedCode = highlightedCode;\n\n        _.hooks.run('before-insert', env);\n\n        env.element.innerHTML = env.highlightedCode;\n\n        _.hooks.run('after-highlight', env);\n\n        _.hooks.run('complete', env);\n\n        callback && callback.call(env.element);\n      }\n\n      _.hooks.run('before-sanity-check', env);\n\n      if (!env.code) {\n        _.hooks.run('complete', env);\n\n        callback && callback.call(env.element);\n        return;\n      }\n\n      _.hooks.run('before-highlight', env);\n\n      if (!env.grammar) {\n        insertHighlightedCode(_.util.encode(env.code));\n        return;\n      }\n\n      if (async && _self.Worker) {\n        var worker = new Worker(_.filename);\n\n        worker.onmessage = function (evt) {\n          insertHighlightedCode(evt.data);\n        };\n\n        worker.postMessage(JSON.stringify({\n          language: env.language,\n          code: env.code,\n          immediateClose: true\n        }));\n      } else {\n        insertHighlightedCode(_.highlight(env.code, env.grammar, env.language));\n      }\n    },\n\n    /**\n     * Low-level function, only use if you know what you’re doing. It accepts a string of text as input\n     * and the language definitions to use, and returns a string with the HTML produced.\n     *\n     * The following hooks will be run:\n     * 1. `before-tokenize`\n     * 2. `after-tokenize`\n     * 3. `wrap`: On each {@link Token}.\n     *\n     * @param {string} text A string with the code to be highlighted.\n     * @param {Grammar} grammar An object containing the tokens to use.\n     *\n     * Usually a language definition like `Prism.languages.markup`.\n     * @param {string} language The name of the language definition passed to `grammar`.\n     * @returns {string} The highlighted HTML.\n     * @memberof Prism\n     * @public\n     * @example\n     * Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');\n     */\n    highlight: function highlight(text, grammar, language) {\n      var env = {\n        code: text,\n        grammar: grammar,\n        language: language\n      };\n\n      _.hooks.run('before-tokenize', env);\n\n      env.tokens = _.tokenize(env.code, env.grammar);\n\n      _.hooks.run('after-tokenize', env);\n\n      return Token.stringify(_.util.encode(env.tokens), env.language);\n    },\n\n    /**\n     * This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input\n     * and the language definitions to use, and returns an array with the tokenized code.\n     *\n     * When the language definition includes nested tokens, the function is called recursively on each of these tokens.\n     *\n     * This method could be useful in other contexts as well, as a very crude parser.\n     *\n     * @param {string} text A string with the code to be highlighted.\n     * @param {Grammar} grammar An object containing the tokens to use.\n     *\n     * Usually a language definition like `Prism.languages.markup`.\n     * @returns {TokenStream} An array of strings and tokens, a token stream.\n     * @memberof Prism\n     * @public\n     * @example\n     * let code = `var foo = 0;`;\n     * let tokens = Prism.tokenize(code, Prism.languages.javascript);\n     * tokens.forEach(token => {\n     *     if (token instanceof Prism.Token && token.type === 'number') {\n     *         console.log(`Found numeric literal: ${token.content}`);\n     *     }\n     * });\n     */\n    tokenize: function tokenize(text, grammar) {\n      var rest = grammar.rest;\n\n      if (rest) {\n        for (var token in rest) {\n          grammar[token] = rest[token];\n        }\n\n        delete grammar.rest;\n      }\n\n      var tokenList = new LinkedList();\n      addAfter(tokenList, tokenList.head, text);\n      matchGrammar(text, tokenList, grammar, tokenList.head, 0);\n      return toArray(tokenList);\n    },\n\n    /**\n     * @namespace\n     * @memberof Prism\n     * @public\n     */\n    hooks: {\n      all: {},\n\n      /**\n       * Adds the given callback to the list of callbacks for the given hook.\n       *\n       * The callback will be invoked when the hook it is registered for is run.\n       * Hooks are usually directly run by a highlight function but you can also run hooks yourself.\n       *\n       * One callback function can be registered to multiple hooks and the same hook multiple times.\n       *\n       * @param {string} name The name of the hook.\n       * @param {HookCallback} callback The callback function which is given environment variables.\n       * @public\n       */\n      add: function add(name, callback) {\n        var hooks = _.hooks.all;\n        hooks[name] = hooks[name] || [];\n        hooks[name].push(callback);\n      },\n\n      /**\n       * Runs a hook invoking all registered callbacks with the given environment variables.\n       *\n       * Callbacks will be invoked synchronously and in the order in which they were registered.\n       *\n       * @param {string} name The name of the hook.\n       * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.\n       * @public\n       */\n      run: function run(name, env) {\n        var callbacks = _.hooks.all[name];\n\n        if (!callbacks || !callbacks.length) {\n          return;\n        }\n\n        for (var i = 0, callback; callback = callbacks[i++];) {\n          callback(env);\n        }\n      }\n    },\n    Token: Token\n  };\n  _self.Prism = _; // Typescript note:\n  // The following can be used to import the Token type in JSDoc:\n  //\n  //   @typedef {InstanceType<import(\"./prism-core\")[\"Token\"]>} Token\n\n  /**\n   * Creates a new token.\n   *\n   * @param {string} type See {@link Token#type type}\n   * @param {string | TokenStream} content See {@link Token#content content}\n   * @param {string|string[]} [alias] The alias(es) of the token.\n   * @param {string} [matchedStr=\"\"] A copy of the full string this token was created from.\n   * @class\n   * @global\n   * @public\n   */\n\n  function Token(type, content, alias, matchedStr) {\n    /**\n     * The type of the token.\n     *\n     * This is usually the key of a pattern in a {@link Grammar}.\n     *\n     * @type {string}\n     * @see GrammarToken\n     * @public\n     */\n    this.type = type;\n    /**\n     * The strings or tokens contained by this token.\n     *\n     * This will be a token stream if the pattern matched also defined an `inside` grammar.\n     *\n     * @type {string | TokenStream}\n     * @public\n     */\n\n    this.content = content;\n    /**\n     * The alias(es) of the token.\n     *\n     * @type {string|string[]}\n     * @see GrammarToken\n     * @public\n     */\n\n    this.alias = alias; // Copy of the full string this token was created from\n\n    this.length = (matchedStr || '').length | 0;\n  }\n  /**\n   * A token stream is an array of strings and {@link Token Token} objects.\n   *\n   * Token streams have to fulfill a few properties that are assumed by most functions (mostly internal ones) that process\n   * them.\n   *\n   * 1. No adjacent strings.\n   * 2. No empty strings.\n   *\n   *    The only exception here is the token stream that only contains the empty string and nothing else.\n   *\n   * @typedef {Array<string | Token>} TokenStream\n   * @global\n   * @public\n   */\n\n  /**\n   * Converts the given token or token stream to an HTML representation.\n   *\n   * The following hooks will be run:\n   * 1. `wrap`: On each {@link Token}.\n   *\n   * @param {string | Token | TokenStream} o The token or token stream to be converted.\n   * @param {string} language The name of current language.\n   * @returns {string} The HTML representation of the token or token stream.\n   * @memberof Token\n   * @static\n   */\n\n\n  Token.stringify = function stringify(o, language) {\n    if (typeof o == 'string') {\n      return o;\n    }\n\n    if (Array.isArray(o)) {\n      var s = '';\n      o.forEach(function (e) {\n        s += stringify(e, language);\n      });\n      return s;\n    }\n\n    var env = {\n      type: o.type,\n      content: stringify(o.content, language),\n      tag: 'span',\n      classes: ['token', o.type],\n      attributes: {},\n      language: language\n    };\n    var aliases = o.alias;\n\n    if (aliases) {\n      if (Array.isArray(aliases)) {\n        Array.prototype.push.apply(env.classes, aliases);\n      } else {\n        env.classes.push(aliases);\n      }\n    }\n\n    _.hooks.run('wrap', env);\n\n    var attributes = '';\n\n    for (var name in env.attributes) {\n      attributes += ' ' + name + '=\"' + (env.attributes[name] || '').replace(/\"/g, '&quot;') + '\"';\n    }\n\n    return '<' + env.tag + ' class=\"' + env.classes.join(' ') + '\"' + attributes + '>' + env.content + '</' + env.tag + '>';\n  };\n  /**\n   * @param {RegExp} pattern\n   * @param {number} pos\n   * @param {string} text\n   * @param {boolean} lookbehind\n   * @returns {RegExpExecArray | null}\n   */\n\n\n  function matchPattern(pattern, pos, text, lookbehind) {\n    pattern.lastIndex = pos;\n    var match = pattern.exec(text);\n\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\n    return match;\n  }\n  /**\n   * @param {string} text\n   * @param {LinkedList<string | Token>} tokenList\n   * @param {any} grammar\n   * @param {LinkedListNode<string | Token>} startNode\n   * @param {number} startPos\n   * @param {RematchOptions} [rematch]\n   * @returns {void}\n   * @private\n   *\n   * @typedef RematchOptions\n   * @property {string} cause\n   * @property {number} reach\n   */\n\n\n  function matchGrammar(text, tokenList, grammar, startNode, startPos, rematch) {\n    for (var token in grammar) {\n      if (!grammar.hasOwnProperty(token) || !grammar[token]) {\n        continue;\n      }\n\n      var patterns = grammar[token];\n      patterns = Array.isArray(patterns) ? patterns : [patterns];\n\n      for (var j = 0; j < patterns.length; ++j) {\n        if (rematch && rematch.cause == token + ',' + j) {\n          return;\n        }\n\n        var patternObj = patterns[j],\n            inside = patternObj.inside,\n            lookbehind = !!patternObj.lookbehind,\n            greedy = !!patternObj.greedy,\n            alias = patternObj.alias;\n\n        if (greedy && !patternObj.pattern.global) {\n          // Without the global flag, lastIndex won't work\n          var flags = patternObj.pattern.toString().match(/[imsuy]*$/)[0];\n          patternObj.pattern = RegExp(patternObj.pattern.source, flags + 'g');\n        }\n        /** @type {RegExp} */\n\n\n        var pattern = patternObj.pattern || patternObj;\n\n        for ( // iterate the token list and keep track of the current token/string position\n        var currentNode = startNode.next, pos = startPos; currentNode !== tokenList.tail; pos += currentNode.value.length, currentNode = currentNode.next) {\n          if (rematch && pos >= rematch.reach) {\n            break;\n          }\n\n          var str = currentNode.value;\n\n          if (tokenList.length > text.length) {\n            // Something went terribly wrong, ABORT, ABORT!\n            return;\n          }\n\n          if (str instanceof Token) {\n            continue;\n          }\n\n          var removeCount = 1; // this is the to parameter of removeBetween\n\n          var match;\n\n          if (greedy) {\n            match = matchPattern(pattern, pos, text, lookbehind);\n\n            if (!match) {\n              break;\n            }\n\n            var from = match.index;\n            var to = match.index + match[0].length;\n            var p = pos; // find the node that contains the match\n\n            p += currentNode.value.length;\n\n            while (from >= p) {\n              currentNode = currentNode.next;\n              p += currentNode.value.length;\n            } // adjust pos (and p)\n\n\n            p -= currentNode.value.length;\n            pos = p; // the current node is a Token, then the match starts inside another Token, which is invalid\n\n            if (currentNode.value instanceof Token) {\n              continue;\n            } // find the last node which is affected by this match\n\n\n            for (var k = currentNode; k !== tokenList.tail && (p < to || typeof k.value === 'string'); k = k.next) {\n              removeCount++;\n              p += k.value.length;\n            }\n\n            removeCount--; // replace with the new match\n\n            str = text.slice(pos, p);\n            match.index -= pos;\n          } else {\n            match = matchPattern(pattern, 0, str, lookbehind);\n\n            if (!match) {\n              continue;\n            }\n          }\n\n          var from = match.index,\n              matchStr = match[0],\n              before = str.slice(0, from),\n              after = str.slice(from + matchStr.length);\n          var reach = pos + str.length;\n\n          if (rematch && reach > rematch.reach) {\n            rematch.reach = reach;\n          }\n\n          var removeFrom = currentNode.prev;\n\n          if (before) {\n            removeFrom = addAfter(tokenList, removeFrom, before);\n            pos += before.length;\n          }\n\n          removeRange(tokenList, removeFrom, removeCount);\n          var wrapped = new Token(token, inside ? _.tokenize(matchStr, inside) : matchStr, alias, matchStr);\n          currentNode = addAfter(tokenList, removeFrom, wrapped);\n\n          if (after) {\n            addAfter(tokenList, currentNode, after);\n          }\n\n          if (removeCount > 1) {\n            // at least one Token object was removed, so we have to do some rematching\n            // this can only happen if the current pattern is greedy\n            matchGrammar(text, tokenList, grammar, currentNode.prev, pos, {\n              cause: token + ',' + j,\n              reach: reach\n            });\n          }\n        }\n      }\n    }\n  }\n  /**\n   * @typedef LinkedListNode\n   * @property {T} value\n   * @property {LinkedListNode<T> | null} prev The previous node.\n   * @property {LinkedListNode<T> | null} next The next node.\n   * @template T\n   * @private\n   */\n\n  /**\n   * @template T\n   * @private\n   */\n\n\n  function LinkedList() {\n    /** @type {LinkedListNode<T>} */\n    var head = {\n      value: null,\n      prev: null,\n      next: null\n    };\n    /** @type {LinkedListNode<T>} */\n\n    var tail = {\n      value: null,\n      prev: head,\n      next: null\n    };\n    head.next = tail;\n    /** @type {LinkedListNode<T>} */\n\n    this.head = head;\n    /** @type {LinkedListNode<T>} */\n\n    this.tail = tail;\n    this.length = 0;\n  }\n  /**\n   * Adds a new node with the given value to the list.\n   * @param {LinkedList<T>} list\n   * @param {LinkedListNode<T>} node\n   * @param {T} value\n   * @returns {LinkedListNode<T>} The added node.\n   * @template T\n   */\n\n\n  function addAfter(list, node, value) {\n    // assumes that node != list.tail && values.length >= 0\n    var next = node.next;\n    var newNode = {\n      value: value,\n      prev: node,\n      next: next\n    };\n    node.next = newNode;\n    next.prev = newNode;\n    list.length++;\n    return newNode;\n  }\n  /**\n   * Removes `count` nodes after the given node. The given node will not be removed.\n   * @param {LinkedList<T>} list\n   * @param {LinkedListNode<T>} node\n   * @param {number} count\n   * @template T\n   */\n\n\n  function removeRange(list, node, count) {\n    var next = node.next;\n\n    for (var i = 0; i < count && next !== list.tail; i++) {\n      next = next.next;\n    }\n\n    node.next = next;\n    next.prev = node;\n    list.length -= i;\n  }\n  /**\n   * @param {LinkedList<T>} list\n   * @returns {T[]}\n   * @template T\n   */\n\n\n  function toArray(list) {\n    var array = [];\n    var node = list.head.next;\n\n    while (node !== list.tail) {\n      array.push(node.value);\n      node = node.next;\n    }\n\n    return array;\n  }\n\n  if (!_self.document) {\n    if (!_self.addEventListener) {\n      // in Node.js\n      return _;\n    }\n\n    if (!_.disableWorkerMessageHandler) {\n      // In worker\n      _self.addEventListener('message', function (evt) {\n        var message = JSON.parse(evt.data),\n            lang = message.language,\n            code = message.code,\n            immediateClose = message.immediateClose;\n\n        _self.postMessage(_.highlight(code, _.languages[lang], lang));\n\n        if (immediateClose) {\n          _self.close();\n        }\n      }, false);\n    }\n\n    return _;\n  } // Get current script and highlight\n\n\n  var script = _.util.currentScript();\n\n  if (script) {\n    _.filename = script.src;\n\n    if (script.hasAttribute('data-manual')) {\n      _.manual = true;\n    }\n  }\n\n  function highlightAutomaticallyCallback() {\n    if (!_.manual) {\n      _.highlightAll();\n    }\n  }\n\n  if (!_.manual) {\n    // If the document state is \"loading\", then we'll use DOMContentLoaded.\n    // If the document state is \"interactive\" and the prism.js script is deferred, then we'll also use the\n    // DOMContentLoaded event because there might be some plugins or languages which have also been deferred and they\n    // might take longer one animation frame to execute which can create a race condition where only some plugins have\n    // been loaded when Prism.highlightAll() is executed, depending on how fast resources are loaded.\n    // See https://github.com/PrismJS/prism/issues/2102\n    var readyState = document.readyState;\n\n    if (readyState === 'loading' || readyState === 'interactive' && script && script.defer) {\n      document.addEventListener('DOMContentLoaded', highlightAutomaticallyCallback);\n    } else {\n      if (window.requestAnimationFrame) {\n        window.requestAnimationFrame(highlightAutomaticallyCallback);\n      } else {\n        window.setTimeout(highlightAutomaticallyCallback, 16);\n      }\n    }\n  }\n\n  return _;\n}(_self);\n\nif (typeof module !== 'undefined' && module.exports) {\n  module.exports = Prism;\n} // hack for components to work correctly in node.js\n\n\nif (typeof global !== 'undefined') {\n  global.Prism = Prism;\n} // some additional documentation/types\n\n/**\n * The expansion of a simple `RegExp` literal to support additional properties.\n *\n * @typedef GrammarToken\n * @property {RegExp} pattern The regular expression of the token.\n * @property {boolean} [lookbehind=false] If `true`, then the first capturing group of `pattern` will (effectively)\n * behave as a lookbehind group meaning that the captured text will not be part of the matched text of the new token.\n * @property {boolean} [greedy=false] Whether the token is greedy.\n * @property {string|string[]} [alias] An optional alias or list of aliases.\n * @property {Grammar} [inside] The nested grammar of this token.\n *\n * The `inside` grammar will be used to tokenize the text value of each token of this kind.\n *\n * This can be used to make nested and even recursive language definitions.\n *\n * Note: This can cause infinite recursion. Be careful when you embed different languages or even the same language into\n * each another.\n * @global\n * @public\n*/\n\n/**\n * @typedef Grammar\n * @type {Object<string, RegExp | GrammarToken | Array<RegExp | GrammarToken>>}\n * @property {Grammar} [rest] An optional grammar object that will be appended to this grammar.\n * @global\n * @public\n */\n\n/**\n * A function which will invoked after an element was successfully highlighted.\n *\n * @callback HighlightCallback\n * @param {Element} element The element successfully highlighted.\n * @returns {void}\n * @global\n * @public\n*/\n\n/**\n * @callback HookCallback\n * @param {Object<string, any>} env The environment variables of the hook.\n * @returns {void}\n * @global\n * @public\n */\n\n/* **********************************************\n     Begin prism-markup.js\n********************************************** */\n\n\nPrism.languages.markup = {\n  'comment': /<!--[\\s\\S]*?-->/,\n  'prolog': /<\\?[\\s\\S]+?\\?>/,\n  'doctype': {\n    // https://www.w3.org/TR/xml/#NT-doctypedecl\n    pattern: /<!DOCTYPE(?:[^>\"'[\\]]|\"[^\"]*\"|'[^']*')+(?:\\[(?:[^<\"'\\]]|\"[^\"]*\"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\\]\\s*)?>/i,\n    greedy: true,\n    inside: {\n      'internal-subset': {\n        pattern: /(\\[)[\\s\\S]+(?=\\]>$)/,\n        lookbehind: true,\n        greedy: true,\n        inside: null // see below\n\n      },\n      'string': {\n        pattern: /\"[^\"]*\"|'[^']*'/,\n        greedy: true\n      },\n      'punctuation': /^<!|>$|[[\\]]/,\n      'doctype-tag': /^DOCTYPE/,\n      'name': /[^\\s<>'\"]+/\n    }\n  },\n  'cdata': /<!\\[CDATA\\[[\\s\\S]*?]]>/i,\n  'tag': {\n    pattern: /<\\/?(?!\\d)[^\\s>\\/=$<%]+(?:\\s(?:\\s*[^\\s>\\/=]+(?:\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s'\">=]+(?=[\\s>]))|(?=[\\s/>])))+)?\\s*\\/?>/,\n    greedy: true,\n    inside: {\n      'tag': {\n        pattern: /^<\\/?[^\\s>\\/]+/,\n        inside: {\n          'punctuation': /^<\\/?/,\n          'namespace': /^[^\\s>\\/:]+:/\n        }\n      },\n      'attr-value': {\n        pattern: /=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s'\">=]+)/,\n        inside: {\n          'punctuation': [{\n            pattern: /^=/,\n            alias: 'attr-equals'\n          }, /\"|'/]\n        }\n      },\n      'punctuation': /\\/?>/,\n      'attr-name': {\n        pattern: /[^\\s>\\/]+/,\n        inside: {\n          'namespace': /^[^\\s>\\/:]+:/\n        }\n      }\n    }\n  },\n  'entity': [{\n    pattern: /&[\\da-z]{1,8};/i,\n    alias: 'named-entity'\n  }, /&#x?[\\da-f]{1,8};/i]\n};\nPrism.languages.markup['tag'].inside['attr-value'].inside['entity'] = Prism.languages.markup['entity'];\nPrism.languages.markup['doctype'].inside['internal-subset'].inside = Prism.languages.markup; // Plugin to make entity title show the real entity, idea by Roman Komarov\n\nPrism.hooks.add('wrap', function (env) {\n  if (env.type === 'entity') {\n    env.attributes['title'] = env.content.replace(/&amp;/, '&');\n  }\n});\nObject.defineProperty(Prism.languages.markup.tag, 'addInlined', {\n  /**\n   * Adds an inlined language to markup.\n   *\n   * An example of an inlined language is CSS with `<style>` tags.\n   *\n   * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as\n   * case insensitive.\n   * @param {string} lang The language key.\n   * @example\n   * addInlined('style', 'css');\n   */\n  value: function addInlined(tagName, lang) {\n    var includedCdataInside = {};\n    includedCdataInside['language-' + lang] = {\n      pattern: /(^<!\\[CDATA\\[)[\\s\\S]+?(?=\\]\\]>$)/i,\n      lookbehind: true,\n      inside: Prism.languages[lang]\n    };\n    includedCdataInside['cdata'] = /^<!\\[CDATA\\[|\\]\\]>$/i;\n    var inside = {\n      'included-cdata': {\n        pattern: /<!\\[CDATA\\[[\\s\\S]*?\\]\\]>/i,\n        inside: includedCdataInside\n      }\n    };\n    inside['language-' + lang] = {\n      pattern: /[\\s\\S]+/,\n      inside: Prism.languages[lang]\n    };\n    var def = {};\n    def[tagName] = {\n      pattern: RegExp(/(<__[^>]*>)(?:<!\\[CDATA\\[(?:[^\\]]|\\](?!\\]>))*\\]\\]>|(?!<!\\[CDATA\\[)[\\s\\S])*?(?=<\\/__>)/.source.replace(/__/g, function () {\n        return tagName;\n      }), 'i'),\n      lookbehind: true,\n      greedy: true,\n      inside: inside\n    };\n    Prism.languages.insertBefore('markup', 'cdata', def);\n  }\n});\nPrism.languages.html = Prism.languages.markup;\nPrism.languages.mathml = Prism.languages.markup;\nPrism.languages.svg = Prism.languages.markup;\nPrism.languages.xml = Prism.languages.extend('markup', {});\nPrism.languages.ssml = Prism.languages.xml;\nPrism.languages.atom = Prism.languages.xml;\nPrism.languages.rss = Prism.languages.xml;\n/* **********************************************\n     Begin prism-css.js\n********************************************** */\n\n(function (Prism) {\n  var string = /(\"|')(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/;\n  Prism.languages.css = {\n    'comment': /\\/\\*[\\s\\S]*?\\*\\//,\n    'atrule': {\n      pattern: /@[\\w-](?:[^;{\\s]|\\s+(?![\\s{]))*(?:;|(?=\\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': RegExp('[^{}\\\\s](?:[^{};\"\\'\\\\s]|\\\\s+(?![\\\\s{])|' + string.source + ')*(?=\\\\s*\\\\{)'),\n    'string': {\n      pattern: string,\n      greedy: true\n    },\n    'property': /(?!\\s)[-_a-z\\xA0-\\uFFFF](?:(?!\\s)[-\\w\\xA0-\\uFFFF])*(?=\\s*:)/i,\n    'important': /!important\\b/i,\n    'function': /[-a-z0-9]+(?=\\()/i,\n    'punctuation': /[(){};:,]/\n  };\n  Prism.languages.css['atrule'].inside.rest = Prism.languages.css;\n  var markup = Prism.languages.markup;\n\n  if (markup) {\n    markup.tag.addInlined('style', 'css');\n    Prism.languages.insertBefore('inside', 'attr-value', {\n      'style-attr': {\n        pattern: /(^|[\"'\\s])style\\s*=\\s*(?:\"[^\"]*\"|'[^']*')/i,\n        lookbehind: true,\n        inside: {\n          'attr-value': {\n            pattern: /=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s'\">=]+)/,\n            inside: {\n              'style': {\n                pattern: /([\"'])[\\s\\S]+(?=[\"']$)/,\n                lookbehind: true,\n                alias: 'language-css',\n                inside: Prism.languages.css\n              },\n              'punctuation': [{\n                pattern: /^=/,\n                alias: 'attr-equals'\n              }, /\"|'/]\n            }\n          },\n          'attr-name': /^style/i\n        }\n      }\n    }, markup.tag);\n  }\n})(Prism);\n/* **********************************************\n     Begin prism-clike.js\n********************************************** */\n\n\nPrism.languages.clike = {\n  'comment': [{\n    pattern: /(^|[^\\\\])\\/\\*[\\s\\S]*?(?:\\*\\/|$)/,\n    lookbehind: true,\n    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|interface|extends|implements|trait|instanceof|new)\\s+|\\bcatch\\s+\\()[\\w.\\\\]+/i,\n    lookbehind: true,\n    inside: {\n      'punctuation': /[.\\\\]/\n    }\n  },\n  'keyword': /\\b(?:if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\\b/,\n  'boolean': /\\b(?:true|false)\\b/,\n  'function': /\\w+(?=\\()/,\n  'number': /\\b0x[\\da-f]+\\b|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e[+-]?\\d+)?/i,\n  'operator': /[<>]=?|[!=]=?=?|--?|\\+\\+?|&&?|\\|\\|?|[?*/~^%]/,\n  'punctuation': /[{}[\\];(),.:]/\n};\n/* **********************************************\n     Begin prism-javascript.js\n********************************************** */\n\nPrism.languages.javascript = Prism.languages.extend('clike', {\n  'class-name': [Prism.languages.clike['class-name'], {\n    pattern: /(^|[^$\\w\\xA0-\\uFFFF])(?!\\s)[_$A-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*(?=\\.(?:prototype|constructor))/,\n    lookbehind: true\n  }],\n  'keyword': [{\n    pattern: /((?:^|})\\s*)(?:catch|finally)\\b/,\n    lookbehind: true\n  }, {\n    pattern: /(^|[^.]|\\.\\.\\.\\s*)\\b(?:as|async(?=\\s*(?:function\\b|\\(|[$\\w\\xA0-\\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|for|from|function|(?:get|set)(?=\\s*[\\[$\\w\\xA0-\\uFFFF])|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\\b/,\n    lookbehind: true\n  }],\n  // 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': /\\b(?:(?:0[xX](?:[\\dA-Fa-f](?:_[\\dA-Fa-f])?)+|0[bB](?:[01](?:_[01])?)+|0[oO](?:[0-7](?:_[0-7])?)+)n?|(?:\\d(?:_\\d)?)+n|NaN|Infinity)\\b|(?:\\b(?:\\d(?:_\\d)?)+\\.?(?:\\d(?:_\\d)?)*|\\B\\.(?:\\d(?:_\\d)?)+)(?:[Ee][+-]?(?:\\d(?:_\\d)?)+)?/,\n  'operator': /--|\\+\\+|\\*\\*=?|=>|&&=?|\\|\\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\\.{3}|\\?\\?=?|\\?\\.?|[~:]/\n});\nPrism.languages.javascript['class-name'][0].pattern = /(\\b(?:class|interface|extends|implements|instanceof|new)\\s+)[\\w.\\\\]+/;\nPrism.languages.insertBefore('javascript', 'keyword', {\n  'regex': {\n    pattern: /((?:^|[^$\\w\\xA0-\\uFFFF.\"'\\])\\s]|\\b(?:return|yield))\\s*)\\/(?:\\[(?:[^\\]\\\\\\r\\n]|\\\\.)*]|\\\\.|[^/\\\\\\[\\r\\n])+\\/[gimyus]{0,6}(?=(?:\\s|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/)*(?:$|[\\r\\n,.;:})\\]]|\\/\\/))/,\n    lookbehind: true,\n    greedy: true,\n    inside: {\n      'regex-source': {\n        pattern: /^(\\/)[\\s\\S]+(?=\\/[a-z]*$)/,\n        lookbehind: true,\n        alias: 'language-regex',\n        inside: Prism.languages.regex\n      },\n      'regex-flags': /[a-z]+$/,\n      'regex-delimiter': /^\\/|\\/$/\n    }\n  },\n  // This must be declared before keyword because we use \"function\" inside the look-forward\n  'function-variable': {\n    pattern: /#?(?!\\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: /(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*(?=\\s*=>)/i,\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  'template-string': {\n    pattern: /`(?:\\\\[\\s\\S]|\\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})+}|(?!\\${)[^\\\\`])*`/,\n    greedy: true,\n    inside: {\n      'template-punctuation': {\n        pattern: /^`|`$/,\n        alias: 'string'\n      },\n      'interpolation': {\n        pattern: /((?:^|[^\\\\])(?:\\\\{2})*)\\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})+}/,\n        lookbehind: true,\n        inside: {\n          'interpolation-punctuation': {\n            pattern: /^\\${|}$/,\n            alias: 'punctuation'\n          },\n          rest: Prism.languages.javascript\n        }\n      },\n      'string': /[\\s\\S]+/\n    }\n  }\n});\n\nif (Prism.languages.markup) {\n  Prism.languages.markup.tag.addInlined('script', 'javascript');\n}\n\nPrism.languages.js = Prism.languages.javascript;\n/* **********************************************\n     Begin prism-file-highlight.js\n********************************************** */\n\n(function () {\n  if (typeof self === 'undefined' || !self.Prism || !self.document) {\n    return;\n  } // https://developer.mozilla.org/en-US/docs/Web/API/Element/matches#Polyfill\n\n\n  if (!Element.prototype.matches) {\n    Element.prototype.matches = Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;\n  }\n\n  var Prism = window.Prism;\n  var LOADING_MESSAGE = 'Loading…';\n\n  var FAILURE_MESSAGE = function FAILURE_MESSAGE(status, message) {\n    return '✖ Error ' + status + ' while fetching file: ' + message;\n  };\n\n  var FAILURE_EMPTY_MESSAGE = '✖ Error: File does not exist or is empty';\n  var EXTENSIONS = {\n    'js': 'javascript',\n    'py': 'python',\n    'rb': 'ruby',\n    'ps1': 'powershell',\n    'psm1': 'powershell',\n    'sh': 'bash',\n    'bat': 'batch',\n    'h': 'c',\n    'tex': 'latex'\n  };\n  var STATUS_ATTR = 'data-src-status';\n  var STATUS_LOADING = 'loading';\n  var STATUS_LOADED = 'loaded';\n  var STATUS_FAILED = 'failed';\n  var SELECTOR = 'pre[data-src]:not([' + STATUS_ATTR + '=\"' + STATUS_LOADED + '\"])' + ':not([' + STATUS_ATTR + '=\"' + STATUS_LOADING + '\"])';\n  var lang = /\\blang(?:uage)?-([\\w-]+)\\b/i;\n  /**\n   * Sets the Prism `language-xxxx` or `lang-xxxx` class to the given language.\n   *\n   * @param {HTMLElement} element\n   * @param {string} language\n   * @returns {void}\n   */\n\n  function setLanguageClass(element, language) {\n    var className = element.className;\n    className = className.replace(lang, ' ') + ' language-' + language;\n    element.className = className.replace(/\\s+/g, ' ').trim();\n  }\n\n  Prism.hooks.add('before-highlightall', function (env) {\n    env.selector += ', ' + SELECTOR;\n  });\n  Prism.hooks.add('before-sanity-check', function (env) {\n    var pre =\n    /** @type {HTMLPreElement} */\n    env.element;\n\n    if (pre.matches(SELECTOR)) {\n      env.code = ''; // fast-path the whole thing and go to complete\n\n      pre.setAttribute(STATUS_ATTR, STATUS_LOADING); // mark as loading\n      // add code element with loading message\n\n      var code = pre.appendChild(document.createElement('CODE'));\n      code.textContent = LOADING_MESSAGE;\n      var src = pre.getAttribute('data-src');\n      var language = env.language;\n\n      if (language === 'none') {\n        // the language might be 'none' because there is no language set;\n        // in this case, we want to use the extension as the language\n        var extension = (/\\.(\\w+)$/.exec(src) || [, 'none'])[1];\n        language = EXTENSIONS[extension] || extension;\n      } // set language classes\n\n\n      setLanguageClass(code, language);\n      setLanguageClass(pre, language); // preload the language\n\n      var autoloader = Prism.plugins.autoloader;\n\n      if (autoloader) {\n        autoloader.loadLanguages(language);\n      } // load file\n\n\n      var xhr = new XMLHttpRequest();\n      xhr.open('GET', src, true);\n\n      xhr.onreadystatechange = function () {\n        if (xhr.readyState == 4) {\n          if (xhr.status < 400 && xhr.responseText) {\n            // mark as loaded\n            pre.setAttribute(STATUS_ATTR, STATUS_LOADED); // highlight code\n\n            code.textContent = xhr.responseText;\n            Prism.highlightElement(code);\n          } else {\n            // mark as failed\n            pre.setAttribute(STATUS_ATTR, STATUS_FAILED);\n\n            if (xhr.status >= 400) {\n              code.textContent = FAILURE_MESSAGE(xhr.status, xhr.statusText);\n            } else {\n              code.textContent = FAILURE_EMPTY_MESSAGE;\n            }\n          }\n        }\n      };\n\n      xhr.send(null);\n    }\n  });\n  Prism.plugins.fileHighlight = {\n    /**\n     * Executes the File Highlight plugin for all matching `pre` elements under the given container.\n     *\n     * Note: Elements which are already loaded or currently loading will not be touched by this method.\n     *\n     * @param {ParentNode} [container=document]\n     */\n    highlight: function highlight(container) {\n      var elements = (container || document).querySelectorAll(SELECTOR);\n\n      for (var i = 0, element; element = elements[i++];) {\n        Prism.highlightElement(element);\n      }\n    }\n  };\n  var logged = false;\n  /** @deprecated Use `Prism.plugins.fileHighlight.highlight` instead. */\n\n  Prism.fileHighlight = function () {\n    if (!logged) {\n      console.warn('Prism.fileHighlight is deprecated. Use `Prism.plugins.fileHighlight.highlight` instead.');\n      logged = true;\n    }\n\n    Prism.plugins.fileHighlight.highlight.apply(this, arguments);\n  };\n})();","!function (e) {\n  var n = /[*&][^\\s[\\]{},]+/,\n      r = /!(?:<[\\w\\-%#;/?:@&=+$,.!~*'()[\\]]+>|(?:[a-zA-Z\\d-]*!)?[\\w\\-%#;/?:@&=+$.~*'()]+)?/,\n      t = \"(?:\" + r.source + \"(?:[ \\t]+\" + n.source + \")?|\" + n.source + \"(?:[ \\t]+\" + r.source + \")?)\",\n      a = \"(?:[^\\\\s\\\\x00-\\\\x08\\\\x0e-\\\\x1f!\\\"#%&'*,\\\\-:>?@[\\\\]`{|}\\\\x7f-\\\\x84\\\\x86-\\\\x9f\\\\ud800-\\\\udfff\\\\ufffe\\\\uffff]|[?:-]<PLAIN>)(?:[ \\t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*\".replace(/<PLAIN>/g, function () {\n    return \"[^\\\\s\\\\x00-\\\\x08\\\\x0e-\\\\x1f,[\\\\]{}\\\\x7f-\\\\x84\\\\x86-\\\\x9f\\\\ud800-\\\\udfff\\\\ufffe\\\\uffff]\";\n  }),\n      d = \"\\\"(?:[^\\\"\\\\\\\\\\r\\n]|\\\\\\\\.)*\\\"|'(?:[^'\\\\\\\\\\r\\n]|\\\\\\\\.)*'\";\n\n  function o(e, n) {\n    n = (n || \"\").replace(/m/g, \"\") + \"m\";\n    var r = \"([:\\\\-,[{]\\\\s*(?:\\\\s<<prop>>[ \\t]+)?)(?:<<value>>)(?=[ \\t]*(?:$|,|]|}|(?:[\\r\\n]\\\\s*)?#))\".replace(/<<prop>>/g, function () {\n      return t;\n    }).replace(/<<value>>/g, function () {\n      return e;\n    });\n    return RegExp(r, n);\n  }\n\n  e.languages.yaml = {\n    scalar: {\n      pattern: RegExp(\"([\\\\-:]\\\\s*(?:\\\\s<<prop>>[ \\t]+)?[|>])[ \\t]*(?:((?:\\r?\\n|\\r)[ \\t]+)\\\\S[^\\r\\n]*(?:\\\\2[^\\r\\n]+)*)\".replace(/<<prop>>/g, function () {\n        return t;\n      })),\n      lookbehind: !0,\n      alias: \"string\"\n    },\n    comment: /#.*/,\n    key: {\n      pattern: RegExp(\"((?:^|[:\\\\-,[{\\r\\n?])[ \\t]*(?:<<prop>>[ \\t]+)?)<<key>>(?=\\\\s*:\\\\s)\".replace(/<<prop>>/g, function () {\n        return t;\n      }).replace(/<<key>>/g, function () {\n        return \"(?:\" + a + \"|\" + d + \")\";\n      })),\n      lookbehind: !0,\n      greedy: !0,\n      alias: \"atrule\"\n    },\n    directive: {\n      pattern: /(^[ \\t]*)%.+/m,\n      lookbehind: !0,\n      alias: \"important\"\n    },\n    datetime: {\n      pattern: o(\"\\\\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*)?)?\"),\n      lookbehind: !0,\n      alias: \"number\"\n    },\n    boolean: {\n      pattern: o(\"true|false\", \"i\"),\n      lookbehind: !0,\n      alias: \"important\"\n    },\n    null: {\n      pattern: o(\"null|~\", \"i\"),\n      lookbehind: !0,\n      alias: \"important\"\n    },\n    string: {\n      pattern: o(d),\n      lookbehind: !0,\n      greedy: !0\n    },\n    number: {\n      pattern: o(\"[+-]?(?:0x[\\\\da-f]+|0o[0-7]+|(?:\\\\d+(?:\\\\.\\\\d*)?|\\\\.?\\\\d+)(?:e[+-]?\\\\d+)?|\\\\.inf|\\\\.nan)\", \"i\"),\n      lookbehind: !0\n    },\n    tag: r,\n    important: n,\n    punctuation: /---|[:[\\]{}\\-,|>?]|\\.\\.\\./\n  }, e.languages.yml = e.languages.yaml;\n}(Prism);"],"sourceRoot":""}