source: node_modules/prismjs/components/prism-graphql.js

Prism.languages.graphql = {
        'comment': /#.*/,
        'description': {
                pattern: /(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i,
                greedy: true,
                alias: 'string',
                inside: {
                        'language-markdown': {
                                pattern: /(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/,
                                lookbehind: true,
                                inside: Prism.languages.markdown
                        }
                }
        },
        'string': {
                pattern: /"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*"/,
                greedy: true
        },
        'number': /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
        'boolean': /\b(?:false|true)\b/,
        'variable': /\$[a-z_]\w*/i,
        'directive': {
                pattern: /@[a-z_]\w*/i,
                alias: 'function'
        },
        'attr-name': {
                pattern: /\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\"\r\n])*")*\))?:)/i,
                greedy: true
        },
        'atom-input': {
                pattern: /\b[A-Z]\w*Input\b/,
                alias: 'class-name'
        },
        'scalar': /\b(?:Boolean|Float|ID|Int|String)\b/,
        'constant': /\b[A-Z][A-Z_\d]*\b/,
        'class-name': {
                pattern: /(\b(?:enum|implements|interface|on|scalar|type|union)\s+|&\s*|:\s*|\[)[A-Z_]\w*/,
                lookbehind: true
        },
        'fragment': {
                pattern: /(\bfragment\s+|\.{3}\s*(?!on\b))[a-zA-Z_]\w*/,
                lookbehind: true,
                alias: 'function'
        },
        'definition-mutation': {
                pattern: /(\bmutation\s+)[a-zA-Z_]\w*/,
                lookbehind: true,
                alias: 'function'
        },
        'definition-query': {
                pattern: /(\bquery\s+)[a-zA-Z_]\w*/,
                lookbehind: true,
                alias: 'function'
        },
        'keyword': /\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\b/,
        'operator': /[!=|&]|\.{3}/,
        'property-query': /\w+(?=\s*\()/,
        'object': /\w+(?=\s*\{)/,
        'punctuation': /[!(){}\[\]:=,]/,
        'property': /\w+/
};

Prism.hooks.add('after-tokenize', function afterTokenizeGraphql(env) {
        if (env.language !== 'graphql') {
                return;
        }

        /**
         * get the graphql token stream that we want to customize
         *
         * @typedef {InstanceType<import("./prism-core")["Token"]>} Token
         * @type {Token[]}
         */
        var validTokens = env.tokens.filter(function (token) {
                return typeof token !== 'string' && token.type !== 'comment' && token.type !== 'scalar';
        });

        var currentIndex = 0;

        /**
         * Returns whether the token relative to the current index has the given type.
         *
         * @param {number} offset
         * @returns {Token | undefined}
         */
        function getToken(offset) {
                return validTokens[currentIndex + offset];
        }

        /**
         * Returns whether the token relative to the current index has the given type.
         *
         * @param {readonly string[]} types
         * @param {number} [offset=0]
         * @returns {boolean}
         */
        function isTokenType(types, offset) {
                offset = offset || 0;
                for (var i = 0; i < types.length; i++) {
                        var token = getToken(i + offset);
                        if (!token || token.type !== types[i]) {
                                return false;
                        }
                }
                return true;
        }

        /**
         * Returns the index of the closing bracket to an opening bracket.
         *
         * It is assumed that `token[currentIndex - 1]` is an opening bracket.
         *
         * If no closing bracket could be found, `-1` will be returned.
         *
         * @param {RegExp} open
         * @param {RegExp} close
         * @returns {number}
         */
        function findClosingBracket(open, close) {
                var stackHeight = 1;

                for (var i = currentIndex; i < validTokens.length; i++) {
                        var token = validTokens[i];
                        var content = token.content;

                        if (token.type === 'punctuation' && typeof content === 'string') {
                                if (open.test(content)) {
                                        stackHeight++;
                                } else if (close.test(content)) {
                                        stackHeight--;

                                        if (stackHeight === 0) {
                                                return i;
                                        }
                                }
                        }
                }

                return -1;
        }

        /**
         * Adds an alias to the given token.
         *
         * @param {Token} token
         * @param {string} alias
         * @returns {void}
         */
        function addAlias(token, alias) {
                var aliases = token.alias;
                if (!aliases) {
                        token.alias = aliases = [];
                } else if (!Array.isArray(aliases)) {
                        token.alias = aliases = [aliases];
                }
                aliases.push(alias);
        }

        for (; currentIndex < validTokens.length;) {
                var startToken = validTokens[currentIndex++];

                // add special aliases for mutation tokens
                if (startToken.type === 'keyword' && startToken.content === 'mutation') {
                        // any array of the names of all input variables (if any)
                        var inputVariables = [];

                        if (isTokenType(['definition-mutation', 'punctuation']) && getToken(1).content === '(') {
                                // definition

                                currentIndex += 2; // skip 'definition-mutation' and 'punctuation'

                                var definitionEnd = findClosingBracket(/^\($/, /^\)$/);
                                if (definitionEnd === -1) {
                                        continue;
                                }

                                // find all input variables
                                for (; currentIndex < definitionEnd; currentIndex++) {
                                        var t = getToken(0);
                                        if (t.type === 'variable') {
                                                addAlias(t, 'variable-input');
                                                inputVariables.push(t.content);
                                        }
                                }

                                currentIndex = definitionEnd + 1;
                        }

                        if (isTokenType(['punctuation', 'property-query']) && getToken(0).content === '{') {
                                currentIndex++; // skip opening bracket

                                addAlias(getToken(0), 'property-mutation');

                                if (inputVariables.length > 0) {
                                        var mutationEnd = findClosingBracket(/^\{$/, /^\}$/);
                                        if (mutationEnd === -1) {
                                                continue;
                                        }

                                        // give references to input variables a special alias
                                        for (var i = currentIndex; i < mutationEnd; i++) {
                                                var varToken = validTokens[i];
                                                if (varToken.type === 'variable' && inputVariables.indexOf(varToken.content) >= 0) {
                                                        addAlias(varToken, 'variable-input');
                                                }
                                        }
                                }
                        }
                }
        }
});