/* prismjs.com/download.html?themes=prism-okaidia&languages=css+scss+sql */ self = (typeof window !== 'undefined')

? window   // if in browser
: (
        (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope)
        ? self // if in worker
        : {}   // if in node js
);

/**

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

var Prism = (function(){

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

var _ = self.Prism = {

util: {
        encode: function (tokens) {
                if (tokens instanceof Token) {
                        return new Token(tokens.type, _.util.encode(tokens.content), tokens.alias);
                } else if (_.util.type(tokens) === 'Array') {
                        return tokens.map(_.util.encode);
                } else {
                        return tokens.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/\u00a0/g, ' ');
                }
        },

        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;
        }

        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) {
        var tokens = _.tokenize(text, grammar);
        return Token.stringify(_.util.encode(tokens), 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 patterns = grammar[token];
                patterns = (_.util.type(patterns) === "Array") ? patterns : [patterns];

                for (var j = 0; j < patterns.length; ++j) {
                        var pattern = patterns[j],
                                inside = pattern.inside,
                                lookbehind = !!pattern.lookbehind,
                                lookbehindLength = 0,
                                alias = pattern.alias;

                        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, alias);

                                        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, alias) {

this.type = type;
this.content = content;
this.alias = alias;

};

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';
}

if (o.alias) {
        var aliases = _.util.type(o.alias) === 'Array' ? o.alias : [o.alias];
        Array.prototype.push.apply(env.classes, aliases);
}

_.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) {

if (!self.addEventListener) {
        // in Node.js
        return self.Prism;
}
// In worker
self.addEventListener('message', function(evt) {
        var message = JSON.parse(evt.data),
            lang = message.language,
            code = message.code;

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

return self.Prism;

}

// 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);
}

}

return self.Prism;

})();

if (typeof module !== 'undefined' && module.exports) {

module.exports = Prism;

} ; 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,
'punctuation': /[\{\};:]/g,
'function': /[-a-z0-9]+(?=\()/ig

};

if (Prism.languages.markup) {

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

}; Prism.languages.scss = Prism.languages.extend('css', {

'comment': {
        pattern: /(^|[^\\])(\/\*[\w\W]*?\*\/|\/\/.*?(\r?\n|$))/g,
        lookbehind: true
},
// aturle is just the @***, not the entire rule (to highlight var & stuffs)
// + add ability to highlight number & unit for media queries
'atrule': /@[\w-]+(?=\s+(\(|\{|;))/gi,
// url, compassified
'url': /([-a-z]+-)*url(?=\()/gi,
// CSS selector regex is not appropriate for Sass
// since there can be lot more things (var, @ directive, nesting..)
// a selector must start at the end of a property or after a brace (end of other rules or nesting)
// it can contain some caracters that aren't used for defining rules or end of selector, & (parent selector), or interpolated variable
// the end of a selector is found when there is no rules in it ( {} or {\s}) or if there is a property (because an interpolated var
// can "pass" as a selector- e.g: proper#{$erty})
// this one was ard to do, so please be careful if you edit this one :)
'selector': /([^@;\{\}\(\)]?([^@;\{\}\(\)]|&|\#\{\$[-_\w]+\})+)(?=\s*\{(\}|\s|[^\}]+(:|\{)[^\}]+))/gm

});

Prism.languages.insertBefore('scss', 'atrule', {

'keyword': /@(if|else if|else|for|each|while|import|extend|debug|warn|mixin|include|function|return|content)|(?=@for\s+\$[-_\w]+\s)+from/i

});

Prism.languages.insertBefore('scss', 'property', {

// var and interpolated vars
'variable': /((\$[-_\w]+)|(#\{\$[-_\w]+\}))/i

});

Prism.languages.insertBefore('scss', 'ignore', {

'placeholder': /%[-_\w]+/i,
'statement': /\B!(default|optional)\b/gi,
'boolean': /\b(true|false)\b/g,
'null': /\b(null)\b/g,
'operator': /\s+([-+]{1,2}|={1,2}|!=|\|?\||\?|\*|\/|\%)\s+/g

}); ; Prism.languages.cql= {

'comment': {
        pattern: /(^|[^\\])(\/\*[\w\W]*?\*\/|((--)|(\/\/)|#).*?(\r?\n|$))/g,
        lookbehind: true
},
'string' : /("|')(\\?[\s\S])*?\1/g,
'keyword' : /\b(ADD|ALL|ALTER|AND|ANY|APPLY|AS|ASC|AUTHORIZE|BATCH|BEGIN|BY|CLUSTERING|COLUMNFAMILY|COMPACT|CONSISTENCY|CONTAINS|COUNT|CREATE|CUSTOM|DELETE|DESC|DROP|DISTINCT|EXISTS|FROM|GRANT|IF|IN|INDEX|INSERT|INTO|KEY|KEYSPACE|LEVEL|LIMIT|MODIFY|NORECURSIVE|NOSUPERUSER|NOT|OF|ON|ORDER|PERMISSION|PERMISSIONS|PRIMARY|REVOKE|SCHEMA|SELECT|STATIC|STORAGE|SUPERUSER|TABLE|TOKEN|TRIGGER|TRUNCATE|TTL|TYPE|UPDATE|USE|USER|USERS|USING|VALUES|WHERE|WITH|WRITETIME|ASCII|BIGINT|BLOB|BOOLEAN|COUNTER|DECIMAL|DOUBLE|FLOAT|INET|INT|TEXT|TIMESTAMP|TIMEUUID|UUID|VARCHAR|VARINT|LIST|SET|MAP|NAN|INFINITY)\b/gi,
'boolean' : /\b(TRUE|FALSE|NULL)\b/gi,
'number' : /\b-?(0x)?\d*\.?[\da-f]+\b/g,
'operator' : /[-+]{1}|!|=?&lt;|=?&gt;|={1}|(&amp;){1,2}|\|?\||\?|\*|\//gi,
'ignore' : /&(lt|gt|amp);/gi,
'punctuation' : /[;[\]{}:()`,.]/g

}; ;