Prism.js



/* **********************************************
     Begin prism-core.js
********************************************** */

/**
 * Prism: Lightweight, robust, elegant syntax highlighting
 * MIT license http://www.opensource.org/licenses/mit-license.php/
 * @author Lea Verou http://lea.verou.me
 */

(function () {

    // Private helper vars
    var lang = /\blang(?:uage)?-(?!\*)(\w+)\b/i;

    var _ = self.Prism = {
        util: {
            type: function (o) {
                return Object.prototype.toString.call(o).match(/\[object (\w+)\]/)[1];
            },

            // Deep clone a language definition (e.g. to extend it)
            clone: function (o) {
                var type = _.util.type(o);

                switch (type) {
                    case "Object":
                        var clone = {};

                        for (var key in o) {
                            if (o.hasOwnProperty(key)) {
                                clone[key] = _.util.clone(o[key]);
                            }
                        }

                        return clone;

                    case "Array":
                        return o.slice();
                }

                return o;
            }
        },

        languages: {
            extend: function (id, redef) {
                var lang = _.util.clone(_.languages[id]);

                for (var key in redef) {
                    lang[key] = redef[key];
                }

                return lang;
            },

            // Insert a token before another token in a language literal
            insertBefore: function (inside, before, insert, root) {
                root = root || _.languages;
                var grammar = root[inside];
                var ret = {};

                for (var token in grammar) {

                    if (grammar.hasOwnProperty(token)) {

                        if (token == before) {

                            for (var newToken in insert) {

                                if (insert.hasOwnProperty(newToken)) {
                                    ret[newToken] = insert[newToken];
                                }
                            }
                        }

                        ret[token] = grammar[token];
                    }
                }

                return root[inside] = ret;
            },

            // Traverse a language definition with Depth First Search
            DFS: function (o, callback) {
                for (var i in o) {
                    callback.call(o, i, o[i]);

                    if (_.util.type(o) === "Object") {
                        _.languages.DFS(o[i], callback);
                    }
                }
            }
        },

        highlightAll: function (async, callback) {
            var elements = document.querySelectorAll("code[class*=\"language-\"], [class*=\"language-\"] code, code[class*=\"lang-\"], [class*=\"lang-\"] code");

            for (var i = 0, element; element = elements[i++];) {
                _.highlightElement(element, async === true, callback);
            }
        },

        highlightElement: function (element, async, callback) {
            // Find language
            var language, grammar, parent = element;

            while (parent && !lang.test(parent.className)) {
                parent = parent.parentNode;
            }

            if (parent) {
                language = (parent.className.match(lang) || [, ""])[1];
                grammar = _.languages[language];
            }

            if (!grammar) {
                return;
            }

            // Set language on the element, if not present
            element.className = element.className.replace(lang, "").replace(/\s+/g, " ") + " language-" + language;

            // Set language on the parent, for styling
            parent = element.parentNode;

            if (/pre/i.test(parent.nodeName)) {
                parent.className = parent.className.replace(lang, "").replace(/\s+/g, " ") + " language-" + language;
            }

            var code = element.textContent;

            if (!code) {
                return;
            }

            code = code.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/\u00a0/g, " ");

            var env = {
                element: element,
                language: language,
                grammar: grammar,
                code: code
            };

            _.hooks.run("before-highlight", env);

            if (async && self.Worker) {
                var worker = new Worker(_.filename);

                worker.onmessage = function (evt) {
                    env.highlightedCode = Token.stringify(JSON.parse(evt.data), language);

                    _.hooks.run("before-insert", env);

                    env.element.innerHTML = env.highlightedCode;

                    callback && callback.call(env.element);
                    _.hooks.run("after-highlight", env);
                };

                worker.postMessage(JSON.stringify({
                    language: env.language,
                    code: env.code
                }));
            }
            else {
                env.highlightedCode = _.highlight(env.code, env.grammar, env.language)

                _.hooks.run("before-insert", env);

                env.element.innerHTML = env.highlightedCode;

                callback && callback.call(element);

                _.hooks.run("after-highlight", env);
            }
        },

        highlight: function (text, grammar, language) {
            return Token.stringify(_.tokenize(text, grammar), language);
        },

        tokenize: function (text, grammar, language) {
            var Token = _.Token;

            var strarr = [text];

            var rest = grammar.rest;

            if (rest) {
                for (var token in rest) {
                    grammar[token] = rest[token];
                }

                delete grammar.rest;
            }

            tokenloop: for (var token in grammar) {
                if (!grammar.hasOwnProperty(token) || !grammar[token]) {
                    continue;
                }

                var pattern = grammar[token],
                    inside = pattern.inside,
                    lookbehind = !!pattern.lookbehind,
                    lookbehindLength = 0;

                pattern = pattern.pattern || pattern;

                for (var i = 0; i < strarr.length; i++) { // Don’t cache length as it changes during the loop

                    var str = strarr[i];

                    if (strarr.length > text.length) {
                        // Something went terribly wrong, ABORT, ABORT!
                        break tokenloop;
                    }

                    if (str instanceof Token) {
                        continue;
                    }

                    pattern.lastIndex = 0;

                    var match = pattern.exec(str);

                    if (match) {
                        if (lookbehind) {
                            lookbehindLength = match[1].length;
                        }

                        var from = match.index - 1 + lookbehindLength,
                            match = match[0].slice(lookbehindLength),
                            len = match.length,
                            to = from + len,
                            before = str.slice(0, from + 1),
                            after = str.slice(to + 1);

                        var args = [i, 1];

                        if (before) {
                            args.push(before);
                        }

                        var wrapped = new Token(token, inside ? _.tokenize(match, inside) : match);

                        args.push(wrapped);

                        if (after) {
                            args.push(after);
                        }

                        Array.prototype.splice.apply(strarr, args);
                    }
                }
            }

            return strarr;
        },

        hooks: {
            all: {},

            add: function (name, callback) {
                var hooks = _.hooks.all;

                hooks[name] = hooks[name] || [];

                hooks[name].push(callback);
            },

            run: function (name, env) {
                var callbacks = _.hooks.all[name];

                if (!callbacks || !callbacks.length) {
                    return;
                }

                for (var i = 0, callback; callback = callbacks[i++];) {
                    callback(env);
                }
            }
        }
    };

    var Token = _.Token = function (type, content) {
        this.type = type;
        this.content = content;
    };

    Token.stringify = function (o, language, parent) {
        if (typeof o == "string") {
            return o;
        }

        if (Object.prototype.toString.call(o) == "[object Array]") {
            return o.map(function (element) {
                return Token.stringify(element, language, o);
            }).join("");
        }

        var env = {
            type: o.type,
            content: Token.stringify(o.content, language, parent),
            tag: "span",
            classes: ["token", o.type],
            attributes: {},
            language: language,
            parent: parent
        };

        if (env.type == "comment") {
            env.attributes["spellcheck"] = "true";
        }

        _.hooks.run("wrap", env);

        var attributes = "";

        for (var name in env.attributes) {
            attributes += name + "=\"" + (env.attributes[name] || "") + "\"";
        }

        return "<" + env.tag + " class=\"" + env.classes.join(" ") + "\" " + attributes + ">" + env.content + "</" + env.tag + ">";

    };

    if (!self.document) {
        // In worker
        self.addEventListener("message", function (evt) {
            var message = JSON.parse(evt.data),
                lang = message.language,
                code = message.code;

            self.postMessage(JSON.stringify(_.tokenize(code, _.languages[lang])));
            self.close();
        }, false);

        return;
    }

    // Get current script and highlight
    var script = document.getElementsByTagName("script");

    script = script[script.length - 1];

    if (script) {
        _.filename = script.src;

        if (document.addEventListener && !script.hasAttribute("data-manual")) {
            document.addEventListener("DOMContentLoaded", _.highlightAll);
        }
    }

})();

/* **********************************************
     Begin prism-markup.js
********************************************** */

Prism.languages.markup = {
    'comment': /&lt;!--[\w\W]*?-->/g,
    'prolog': /&lt;\?.+?\?>/,
    'doctype': /&lt;!DOCTYPE.+?>/,
    'cdata': /&lt;!\[CDATA\[[\w\W]*?]]>/i,
    'tag': {
        pattern: /&lt;\/?[\w:-]+\s*(?:\s+[\w:-]+(?:=(?:("|')(\\?[\w\W])*?\1|[^\s'">=]+))?\s*)*\/?>/gi,
        inside: {
            'tag': {
                pattern: /^&lt;\/?[\w:-]+/i,
                inside: {
                    'punctuation': /^&lt;\/?/,
                    'namespace': /^[\w-]+?:/
                }
            },
            'attr-value': {
                pattern: /=(?:('|")[\w\W]*?(\1)|[^\s>]+)/gi,
                inside: {
                    'punctuation': /=|>|"/g
                }
            },
            'punctuation': /\/?>/g,
            'attr-name': {
                pattern: /[\w:-]+/g,
                inside: {
                    'namespace': /^[\w-]+?:/
                }
            }

        }
    },
    'entity': /&amp;#?[\da-z]{1,8};/gi
};

// Plugin to make entity title show the real entity, idea by Roman Komarov
Prism.hooks.add("wrap", function (env) {

    if (env.type === "entity") {
        env.attributes["title"] = env.content.replace(/&amp;/, "&");
    }
});


/* **********************************************
     Begin prism-css.js
********************************************** */

Prism.languages.css = {
    'comment': /\/\*[\w\W]*?\*\//g,
    'atrule': {
        pattern: /@[\w-]+?.*?(;|(?=\s*{))/gi,
        inside: {
            'punctuation': /[;:]/g
        }
    },
    'url': /url\((["']?).*?\1\)/gi,
    'selector': /[^\{\}\s][^\{\};]*(?=\s*\{)/g,
    'property': /(\b|\B)[\w-]+(?=\s*:)/ig,
    'string': /("|')(\\?.)*?\1/g,
    'important': /\B!important\b/gi,
    'ignore': /&(lt|gt|amp);/gi,
    'punctuation': /[\{\};:]/g
};

if (Prism.languages.markup) {
    Prism.languages.insertBefore("markup", "tag", {
        'style': {
            pattern: /(&lt;|<)style[\w\W]*?(>|&gt;)[\w\W]*?(&lt;|<)\/style(>|&gt;)/ig,
            inside: {
                'tag': {
                    pattern: /(&lt;|<)style[\w\W]*?(>|&gt;)|(&lt;|<)\/style(>|&gt;)/ig,
                    inside: Prism.languages.markup.tag.inside
                },
                rest: Prism.languages.css
            }
        }
    });
}

/* **********************************************
     Begin prism-clike.js
********************************************** */

Prism.languages.clike = {
    'comment': {
        pattern: /(^|[^\\])(\/\*[\w\W]*?\*\/|(^|[^:])\/\/.*?(\r?\n|$))/g,
        lookbehind: true
    },
    'string': /("|')(\\?.)*?\1/g,
    'class-name': {
        pattern: /((?:(?:class|interface|extends|implements|trait|instanceof|new)\s+)|(?:catch\s+\())[a-z0-9_\.\\]+/ig,
        lookbehind: true,
        inside: {
            punctuation: /(\.|\\)/
        }
    },
    'keyword': /\b(if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\b/g,
    'boolean': /\b(true|false)\b/g,
    'function': {
        pattern: /[a-z0-9_]+\(/ig,
        inside: {
            punctuation: /\(/
        }
    },
    'number': /\b-?(0x[\dA-Fa-f]+|\d*\.?\d+([Ee]-?\d+)?)\b/g,
    'operator': /[-+]{1,2}|!|&lt;=?|>=?|={1,3}|(&amp;){1,2}|\|?\||\?|\*|\/|\~|\^|\%/g,
    'ignore': /&(lt|gt|amp);/gi,
    'punctuation': /[{}[\];(),.:]/g
};


/* **********************************************
     Begin prism-javascript.js
********************************************** */

Prism.languages.javascript = Prism.languages.extend("clike", {
    'keyword': /\b(var|let|if|else|while|do|for|return|in|instanceof|function|get|set|new|with|typeof|try|throw|catch|finally|null|break|continue)\b/g,
    'number': /\b-?(0x[\dA-Fa-f]+|\d*\.?\d+([Ee]-?\d+)?|NaN|-?Infinity)\b/g
});

Prism.languages.insertBefore("javascript", "keyword", {
    'regex': {
        pattern: /(^|[^/])\/(?!\/)(\[.+?]|\\.|[^/\r\n])+\/[gim]{0,3}(?=\s*($|[\r\n,.;})]))/g,
        lookbehind: true
    }
});

if (Prism.languages.markup) {
    Prism.languages.insertBefore("markup", "tag", {
        'script': {
            pattern: /(&lt;|<)script[\w\W]*?(>|&gt;)[\w\W]*?(&lt;|<)\/script(>|&gt;)/ig,
            inside: {
                'tag': {
                    pattern: /(&lt;|<)script[\w\W]*?(>|&gt;)|(&lt;|<)\/script(>|&gt;)/ig,
                    inside: Prism.languages.markup.tag.inside
                },
                rest: Prism.languages.javascript
            }
        }
    });
}


/* **********************************************
     Begin prism-file-highlight.js
********************************************** */

(function () {

    if (!self.Prism || !self.document || !document.querySelector) {
        return;
    }

    var Extensions = {
        'js': "javascript",
        'html': "markup",
        'svg': "markup"
    };

    Array.prototype.slice.call(document.querySelectorAll("pre[data-src]")).forEach(function (pre) {
        var src = pre.getAttribute("data-src");
        var extension = (src.match(/\.(\w+)$/) || [, ""])[1];
        var language = Extensions[extension] || extension;

        var code = document.createElement("code");
        code.className = "language-" + language;

        pre.textContent = "";

        code.textContent = "Loading…";

        pre.appendChild(code);

        var xhr = new XMLHttpRequest();

        xhr.open("GET", src, true);

        xhr.onreadystatechange = function () {
            if (xhr.readyState == 4) {

                if (xhr.status < 400 && xhr.responseText) {
                    code.textContent = xhr.responseText;

                    Prism.highlightElement(code);
                }
                else if (xhr.status >= 400) {
                    code.textContent = "✖ Error " + xhr.status + " while fetching file: " + xhr.statusText;
                }
                else {
                    code.textContent = "✖ Error: File does not exist or is empty";
                }
            }
        };

        xhr.send(null);
    });

})();