(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
    typeof define === 'function' && define.amd ? define(factory) :
    (global.Rainbow = factory());
}(this, function () { 'use strict';

    function isNode$1() {
        /* globals module */
        return typeof module !== 'undefined' && typeof module.exports === 'object';
    }

    function isWorker$1() {
        return typeof document === 'undefined' && typeof self !== 'undefined';
    }

    /**
     * Browser Only - Gets the language for this block of code
     *
     * @param {Element} block
     * @return {string|null}
     */
    function getLanguageForBlock(block) {

        // If this doesn't have a language but the parent does then use that.
        //
        // This means if for example you have: <pre data-language="php">
        // with a bunch of <code> blocks inside then you do not have
        // to specify the language for each block.
        var language = block.getAttribute('data-language') || block.parentNode.getAttribute('data-language');

        // This adds support for specifying language via a CSS class.
        //
        // You can use the Google Code Prettify style: <pre class="lang-php">
        // or the HTML5 style: <pre><code class="language-php">
        if (!language) {
            var pattern = /\blang(?:uage)?-(\w+)/;
            var match = block.className.match(pattern) || block.parentNode.className.match(pattern);

            if (match) {
                language = match[1];
            }
        }

        if (language) {
            return language.toLowerCase();
        }

        return null;
    }

    /**
     * Determines if two different matches have complete overlap with each other
     *
     * @param {number} start1   start position of existing match
     * @param {number} end1     end position of existing match
     * @param {number} start2   start position of new match
     * @param {number} end2     end position of new match
     * @return {boolean}
     */
    function hasCompleteOverlap(start1, end1, start2, end2) {

        // If the starting and end positions are exactly the same
        // then the first one should stay and this one should be ignored.
        if (start2 === start1 && end2 === end1) {
            return false;
        }

        return start2 <= start1 && end2 >= end1;
    }

    /**
     * Encodes < and > as html entities
     *
     * @param {string} code
     * @return {string}
     */
    function htmlEntities(code) {
        return code.replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/&(?![\w\#]+;)/g, '&amp;');
    }

    /**
     * Finds out the position of group match for a regular expression
     *
     * @see http://stackoverflow.com/questions/1985594/how-to-find-index-of-groups-in-match
     * @param {Object} match
     * @param {number} groupNumber
     * @return {number}
     */
    function indexOfGroup(match, groupNumber) {
        var index = 0;

        for (var i = 1; i < groupNumber; ++i) {
            if (match[i]) {
                index += match[i].length;
            }
        }

        return index;
    }

    /**
     * Determines if a new match intersects with an existing one
     *
     * @param {number} start1    start position of existing match
     * @param {number} end1      end position of existing match
     * @param {number} start2    start position of new match
     * @param {number} end2      end position of new match
     * @return {boolean}
     */
    function intersects(start1, end1, start2, end2) {
        if (start2 >= start1 && start2 < end1) {
            return true;
        }

        return end2 > start1 && end2 < end1;
    }

    /**
     * Sorts an objects keys by index descending
     *
     * @param {Object} object
     * @return {Array}
     */
    function keys(object) {
        var locations = [];

        for (var location in object) {
            if (object.hasOwnProperty(location)) {
                locations.push(location);
            }
        }

        // numeric descending
        return locations.sort(function (a, b) { return b - a; });
    }

    /**
     * Substring replace call to replace part of a string at a certain position
     *
     * @param {number} position         the position where the replacement
     *                                  should happen
     * @param {string} replace          the text we want to replace
     * @param {string} replaceWith      the text we want to replace it with
     * @param {string} code             the code we are doing the replacing in
     * @return {string}
     */
    function replaceAtPosition(position, replace, replaceWith, code) {
        var subString = code.substr(position);

        // This is needed to fix an issue where $ signs do not render in the
        // highlighted code
        //
        // @see https://github.com/ccampbell/rainbow/issues/208
        replaceWith = replaceWith.replace(/\$/g, '$$$$');

        return code.substr(0, position) + subString.replace(replace, replaceWith);
    }

    /**
     * Creates a usable web worker from an anonymous function
     *
     * mostly borrowed from https://github.com/zevero/worker-create
     *
     * @param {Function} fn
     * @param {Prism} Prism
     * @return {Worker}
     */
    function createWorker(fn, Prism) {
        if (isNode$1()) {
            /* globals global, require, __filename */
            global.Worker = require('web-worker');
            return new Worker(__filename);
        }

        var prismFunction = Prism.toString();

        var code = keys.toString();
        code += htmlEntities.toString();
        code += hasCompleteOverlap.toString();
        code += intersects.toString();
        code += replaceAtPosition.toString();
        code += indexOfGroup.toString();
        code += prismFunction;

        var fullString = code + "\tthis.onmessage=" + (fn.toString());

        var blob = new Blob([fullString], { type: 'text/javascript' });
        return new Worker((window.URL || window.webkitURL).createObjectURL(blob));
    }

    /**
     * Prism is a class used to highlight individual blocks of code
     *
     * @class
     */
    var Prism = function Prism(options) {
        /**
         * Object of replacements to process at the end of the processing
         *
         * @type {Object}
         */
        var replacements = {};

        /**
         * Language associated with this Prism object
         *
         * @type {string}
         */
        var currentLanguage;

        /**
         * Object of start and end positions of blocks to be replaced
         *
         * @type {Object}
         */
        var replacementPositions = {};

        /**
         * Determines if the match passed in falls inside of an existing match.
         * This prevents a regex pattern from matching inside of another pattern
         * that matches a larger amount of code.
         *
         * For example this prevents a keyword from matching `function` if there
         * is already a match for `function (.*)`.
         *
         * @param {number} startstart position of new match
         * @param {number} end  end position of new match
         * @return {boolean}
         */
        function _matchIsInsideOtherMatch(start, end) {
            for (var key in replacementPositions) {
                key = parseInt(key, 10);

                // If this block completely overlaps with another block
                // then we should remove the other block and return `false`.
                if (hasCompleteOverlap(key, replacementPositions[key], start, end)) {
                    delete replacementPositions[key];
                    delete replacements[key];
                }

                if (intersects(key, replacementPositions[key], start, end)) {
                    return true;
                }
            }

            return false;
        }

        /**
         * Takes a string of code and wraps it in a span tag based on the name
         *
         * @param {string} name    name of the pattern (ie keyword.regex)
         * @param {string} code    block of code to wrap
         * @param {string} globalClass class to apply to every span
         * @return {string}
         */
        function _wrapCodeInSpan(name, code) {
            var className = name.replace(/\./g, ' ');

            var globalClass = options.globalClass;
            if (globalClass) {
                className += " " + globalClass;
            }

            return ("<span class=\"" + className + "\">" + code + "</span>");
        }

        /**
         * Process replacements in the string of code to actually update
         * the markup
         *
         * @param {string} code     the code to process replacements in
         * @return {string}
         */
        function _processReplacements(code) {
            var positions = keys(replacements);
            for (var i = 0, list = positions; i < list.length; i += 1) {
                var position = list[i];

                var replacement = replacements[position];
                code = replaceAtPosition(position, replacement.replace, replacement.with, code);
            }
            return code;
        }

        /**
         * It is so we can create a new regex object for each call to
         * _processPattern to avoid state carrying over when running exec
         * multiple times.
         *
         * The global flag should not be carried over because we are simulating
         * it by processing the regex in a loop so we only care about the first
         * match in each string. This also seems to improve performance quite a
         * bit.
         *
         * @param {RegExp} regex
         * @return {string}
         */
        function _cloneRegex(regex) {
            var flags = '';

            if (regex.ignoreCase) {
                flags += 'i';
            }

            if (regex.multiline) {
                flags += 'm';
            }

            return new RegExp(regex.source, flags);
        }

        /**
         * Matches a regex pattern against a block of code, finds all matches
         * that should be processed, and stores the positions of where they
         * should be replaced within the string.
         *
         * This is where pretty much all the work is done but it should not
         * be called directly.
         *
         * @param {Object} pattern
         * @param {string} code
         * @param {number} offset
         * @return {mixed}
         */
        function _processPattern(pattern, code, offset) {
            if ( offset === void 0 ) offset = 0;

            var regex = pattern.pattern;
            if (!regex) {
                return false;
            }

            // Since we are simulating global regex matching we need to also
            // make sure to stop after one match if the pattern is not global
            var shouldStop = !regex.global;

            regex = _cloneRegex(regex);
            var match = regex.exec(code);
            if (!match) {
                return false;
            }

            // Treat match 0 the same way as name
            if (!pattern.name && pattern.matches && typeof pattern.matches[0] === 'string') {
                pattern.name = pattern.matches[0];
                delete pattern.matches[0];
            }

            var replacement = match[0];
                var startPos = match.index + offset;
            var endPos = match[0].length + startPos;

            // In some cases when the regex matches a group such as \s* it is
            // possible for there to be a match, but have the start position
            // equal the end position. In those cases we should be able to stop
            // matching. Otherwise this can lead to an infinite loop.
            if (startPos === endPos) {
                return false;
            }

            // If this is not a child match and it falls inside of another
            // match that already happened we should skip it and continue
            // processing.
            if (_matchIsInsideOtherMatch(startPos, endPos)) {
                return {
                    remaining: code.substr(endPos - offset),
                    offset: endPos
                };
            }

            /**
             * Callback for when a match was successfully processed
             *
             * @param {string} repl
             * @return {void}
             */
            function onMatchSuccess(repl) {

                // If this match has a name then wrap it in a span tag
                if (pattern.name) {
                    repl = _wrapCodeInSpan(pattern.name, repl);
                }

                // For debugging
                // console.log('Replace ' + match[0] + ' with ' + replacement + ' at position ' + startPos + ' to ' + endPos);

                // Store what needs to be replaced with what at this position
                replacements[startPos] = {
                    'replace': match[0],
                    'with': repl
                };

                // Store the range of this match so we can use it for
                // comparisons with other matches later.
                replacementPositions[startPos] = endPos;

                if (shouldStop) {
                    return false;
                }

                return {
                    remaining: code.substr(endPos - offset),
                    offset: endPos
                };
            }

            /**
             * Helper function for processing a sub group
             *
             * @param {number} groupKey  index of group
             * @return {void}
             */
            function _processGroup(groupKey) {
                var block = match[groupKey];

                // If there is no match here then move on
                if (!block) {
                    return;
                }

                var group = pattern.matches[groupKey];
                var language = group.language;

                /**
                 * Process group is what group we should use to actually process
                 * this match group.
                 *
                 * For example if the subgroup pattern looks like this:
                 *
                 * 2: {
                 * 'name': 'keyword',
                 * 'pattern': /true/g
                 * }
                 *
                 * then we use that as is, but if it looks like this:
                 *
                 * 2: {
                 * 'name': 'keyword',
                 * 'matches': {
                 *      'name': 'special',
                 *      'pattern': /whatever/g
                 *  }
                 * }
                 *
                 * we treat the 'matches' part as the pattern and keep
                 * the name around to wrap it with later
                 */
                var groupToProcess = group.name && group.matches ? group.matches : group;

                /**
                 * Takes the code block matched at this group, replaces it
                 * with the highlighted block, and optionally wraps it with
                 * a span with a name
                 *
                 * @param {string} passedBlock
                 * @param {string} replaceBlock
                 * @param {string|null} matchName
                 */
                var _getReplacement = function(passedBlock, replaceBlock, matchName) {
                    replacement = replaceAtPosition(indexOfGroup(match, groupKey), passedBlock, matchName ? _wrapCodeInSpan(matchName, replaceBlock) : replaceBlock, replacement);
                    return;
                };

                // If this is a string then this match is directly mapped
                // to selector so all we have to do is wrap it in a span
                // and continue.
                if (typeof group === 'string') {
                    _getReplacement(block, block, group);
                    return;
                }

                var localCode;
                var prism = new Prism(options);

                // If this is a sublanguage go and process the block using
                // that language
                if (language) {
                    localCode = prism.refract(block, language);
                    _getReplacement(block, localCode);
                    return;
                }

                // The process group can be a single pattern or an array of
                // patterns. `_processCodeWithPatterns` always expects an array
                // so we convert it here.
                localCode = prism.refract(block, currentLanguage, groupToProcess.length ? groupToProcess : [groupToProcess]);
                _getReplacement(block, localCode, group.matches ? group.name : 0);
            }

            // If this pattern has sub matches for different groups in the regex
            // then we should process them one at a time by running them through
            // the _processGroup function to generate the new replacement.
            //
            // We use the `keys` function to run through them backwards because
            // the match position of earlier matches will not change depending
            // on what gets replaced in later matches.
            var groupKeys = keys(pattern.matches);
            for (var i = 0, list = groupKeys; i < list.length; i += 1) {
                var groupKey = list[i];

                _processGroup(groupKey);
            }

            // Finally, call `onMatchSuccess` with the replacement
            return onMatchSuccess(replacement);
        }

        /**
         * Processes a block of code using specified patterns
         *
         * @param {string} code
         * @param {Array} patterns
         * @return {string}
         */
        function _processCodeWithPatterns(code, patterns) {
            for (var i = 0, list = patterns; i < list.length; i += 1) {
                var pattern = list[i];

                var result = _processPattern(pattern, code);
                while (result) {
                    result = _processPattern(pattern, result.remaining, result.offset);
                }
            }

            // We are done processing the patterns so we should actually replace
            // what needs to be replaced in the code.
            return _processReplacements(code);
        }

        /**
         * Returns a list of regex patterns for this language
         *
         * @param {string} language
         * @return {Array}
         */
        function getPatternsForLanguage(language) {
            var patterns = options.patterns[language] || [];
            while (options.inheritenceMap[language]) {
                language = options.inheritenceMap[language];
                patterns = patterns.concat(options.patterns[language] || []);
            }

            return patterns;
        }

        /**
         * Takes a string of code and highlights it according to the language
         * specified
         *
         * @param {string} code
         * @param {string} language
         * @param {object} patterns optionally specify a list of patterns
         * @return {string}
         */
        function _highlightBlockForLanguage(code, language, patterns) {
            currentLanguage = language;
            patterns = patterns || getPatternsForLanguage(language);
            return _processCodeWithPatterns(htmlEntities(code), patterns);
        }

        this.refract = _highlightBlockForLanguage;
    };

    function rainbowWorker(e) {
        var message = e.data;

        var prism = new Prism(message.options);
        var result = prism.refract(message.code, message.lang);

        function _reply() {
            self.postMessage({
                id: message.id,
                lang: message.lang,
                result: result
            });
        }

        if (message.isNode) {
            _reply();
            return;
        }

        setTimeout(function () {
            _reply();
        }, message.options.delay * 1000);
    }

    /**
     * An array of the language patterns specified for each language
     *
     * @type {Object}
     */
    var patterns = {};

    /**
     * An object of languages mapping to what language they should inherit from
     *
     * @type {Object}
     */
    var inheritenceMap = {};

    /**
     * A mapping of language aliases
     *
     * @type {Object}
     */
    var aliases = {};

    /**
     * Representation of the actual rainbow object
     *
     * @type {Object}
     */
    var Rainbow = {};

    /**
     * Callback to fire after each block is highlighted
     *
     * @type {null|Function}
     */
    var onHighlightCallback;

    /**
     * Counter for block ids
     * @see https://github.com/ccampbell/rainbow/issues/207
     */
    var id = 0;

    var isNode = isNode$1();
    var isWorker = isWorker$1();

    var cachedWorker = null;
    function _getWorker() {
        if (isNode || cachedWorker === null) {
            cachedWorker = createWorker(rainbowWorker, Prism);
        }

        return cachedWorker;
    }

    /**
     * Helper for matching up callbacks directly with the
     * post message requests to a web worker.
     *
     * @param {object} message      data to send to web worker
     * @param {Function} callback   callback function for worker to reply to
     * @return {void}
     */
    function _messageWorker(message, callback) {
        var worker = _getWorker();

        function _listen(e) {
            if (e.data.id === message.id) {
                callback(e.data);
                worker.removeEventListener('message', _listen);

                // I realized down the road I might look at this and wonder what is going on
                // so probably it is not a bad idea to leave a comment.
                //
                // This is needed because right now the node library for simulating web
                // workers “web-worker” will keep the worker open and it causes
                // scripts running from the command line to hang unless the worker is
                // explicitly closed.
                //
                // This means for node we will spawn a new thread for every asynchronous
                // block we are highlighting, but in the browser we will keep a single
                // worker open for all requests.
                if (isNode) {
                    worker.terminate();
                }
            }
        }

        worker.addEventListener('message', _listen);
        worker.postMessage(message);
    }

    /**
     * Browser Only - Handles response from web worker, updates DOM with
     * resulting code, and fires callback
     *
     * @param {Element} element
     * @param {object} waitingOn
     * @param {Function} callback
     * @return {void}
     */
    function _generateHandler(element, waitingOn, callback) {
        return function _handleResponseFromWorker(data) {
            element.innerHTML = data.result;
            element.classList.remove('loading');
            element.classList.add('rainbow-show');

            if (element.parentNode.tagName === 'PRE') {
                element.parentNode.classList.remove('loading');
                element.parentNode.classList.add('rainbow-show');
            }

            // element.addEventListener('animationend', (e) => {
            //     if (e.animationName === 'fade-in') {
            //         setTimeout(() => {
            //             element.classList.remove('decrease-delay');
            //         }, 1000);
            //     }
            // });

            if (onHighlightCallback) {
                onHighlightCallback(element, data.lang);
            }

            if (--waitingOn.c === 0) {
                callback();
            }
        };
    }

    /**
     * Gets options needed to pass into Prism
     *
     * @param {object} options
     * @return {object}
     */
    function _getPrismOptions(options) {
        return {
            patterns: patterns,
            inheritenceMap: inheritenceMap,
            aliases: aliases,
            globalClass: options.globalClass,
            delay: !isNaN(options.delay) ? options.delay : 0
        };
    }

    /**
     * Gets data to send to webworker
     *
     * @param  {string} code
     * @param  {string} lang
     * @return {object}
     */
    function _getWorkerData(code, lang) {
        var options = {};
        if (typeof lang === 'object') {
            options = lang;
            lang = options.language;
        }

        lang = aliases[lang] || lang;

        var workerData = {
            id: id++,
            code: code,
            lang: lang,
            options: _getPrismOptions(options),
            isNode: isNode
        };

        return workerData;
    }

    /**
     * Browser Only - Sends messages to web worker to highlight elements passed
     * in
     *
     * @param {Array} codeBlocks
     * @param {Function} callback
     * @return {void}
     */
    function _highlightCodeBlocks(codeBlocks, callback) {
        var waitingOn = { c: 0 };
        for (var i = 0, list = codeBlocks; i < list.length; i += 1) {
            var block = list[i];

            var language = getLanguageForBlock(block);
            if (block.classList.contains('rainbow') || !language) {
                continue;
            }

            // This cancels the pending animation to fade the code in on load
            // since we want to delay doing this until it is actually
            // highlighted
            block.classList.add('loading');
            block.classList.add('rainbow');

            // We need to make sure to also add the loading class to the pre tag
            // because that is how we will know to show a preloader
            if (block.parentNode.tagName === 'PRE') {
                block.parentNode.classList.add('loading');
            }

            var globalClass = block.getAttribute('data-global-class');
            var delay = parseInt(block.getAttribute('data-delay'), 10);

            ++waitingOn.c;
            _messageWorker(_getWorkerData(block.innerHTML, { language: language, globalClass: globalClass, delay: delay }), _generateHandler(block, waitingOn, callback));
        }

        if (waitingOn.c === 0) {
            callback();
        }
    }

    function _addPreloader(preBlock) {
        var preloader = document.createElement('div');
        preloader.className = 'preloader';
        for (var i = 0; i < 7; i++) {
            preloader.appendChild(document.createElement('div'));
        }
        preBlock.appendChild(preloader);
    }

    /**
     * Browser Only - Start highlighting all the code blocks
     *
     * @param {Element} node       HTMLElement to search within
     * @param {Function} callback
     * @return {void}
     */
    function _highlight(node, callback) {
        callback = callback || function() {};

        // The first argument can be an Event or a DOM Element.
        //
        // I was originally checking instanceof Event but that made it break
        // when using mootools.
        //
        // @see https://github.com/ccampbell/rainbow/issues/32
        node = node && typeof node.getElementsByTagName === 'function' ? node : document;

        var preBlocks = node.getElementsByTagName('pre');
        var codeBlocks = node.getElementsByTagName('code');
        var finalPreBlocks = [];
        var finalCodeBlocks = [];

        // First loop through all pre blocks to find which ones to highlight
        for (var i = 0, list = preBlocks; i < list.length; i += 1) {
            var preBlock = list[i];

            _addPreloader(preBlock);

            // Strip whitespace around code tags when they are inside of a pre
            // tag.  This makes the themes look better because you can't
            // accidentally add extra linebreaks at the start and end.
            //
            // When the pre tag contains a code tag then strip any extra
            // whitespace.
            //
            // For example:
            //
            // <pre>
            //      <code>var foo = true;</code>
            // </pre>
            //
            // will become:
            //
            // <pre><code>var foo = true;</code></pre>
            //
            // If you want to preserve whitespace you can use a pre tag on
            // its own without a code tag inside of it.
            if (preBlock.getElementsByTagName('code').length) {

                // This fixes a race condition when Rainbow.color is called before
                // the previous color call has finished.
                if (!preBlock.getAttribute('data-trimmed')) {
                    preBlock.setAttribute('data-trimmed', true);
                    preBlock.innerHTML = preBlock.innerHTML.trim();
                }
                continue;
            }

            // If the pre block has no code blocks then we are going to want to
            // process it directly.
            finalPreBlocks.push(preBlock);
        }

        // @see http://stackoverflow.com/questions/2735067/how-to-convert-a-dom-node-list-to-an-array-in-javascript
        // We are going to process all <code> blocks
        for (var i$1 = 0, list$1 = codeBlocks; i$1 < list$1.length; i$1 += 1) {
            var codeBlock = list$1[i$1];

            finalCodeBlocks.push(codeBlock);
        }

        _highlightCodeBlocks(finalCodeBlocks.concat(finalPreBlocks), callback);
    }

    /**
     * Callback to let you do stuff in your app after a piece of code has
     * been highlighted
     *
     * @param {Function} callback
     * @return {void}
     */
    function onHighlight(callback) {
        onHighlightCallback = callback;
    }

    /**
     * Extends the language pattern matches
     *
     * @param {string} language            name of language
     * @param {object} languagePatterns    object of patterns to add on
     * @param {string|undefined} inherits  optional language that this language
     *                                     should inherit rules from
     */
    function extend(language, languagePatterns, inherits) {

        // If we extend a language again we shouldn't need to specify the
        // inheritence for it. For example, if you are adding special highlighting
        // for a javascript function that is not in the base javascript rules, you
        // should be able to do
        //
        // Rainbow.extend('javascript', [ … ]);
        //
        // Without specifying a language it should inherit (generic in this case)
        if (!inheritenceMap[language]) {
            inheritenceMap[language] = inherits;
        }

        patterns[language] = languagePatterns.concat(patterns[language] || []);
    }

    function remove(language) {
        delete inheritenceMap[language];
        delete patterns[language];
    }

    /**
     * Starts the magic rainbow
     *
     * @return {void}
     */
    function color() {
        var args = [], len = arguments.length;
        while ( len-- ) args[ len ] = arguments[ len ];


        // If you want to straight up highlight a string you can pass the
        // string of code, the language, and a callback function.
        //
        // Example:
        //
        // Rainbow.color(code, language, function(highlightedCode, language) {
        //     // this code block is now highlighted
        // });
        if (typeof args[0] === 'string') {
            var workerData = _getWorkerData(args[0], args[1]);
            _messageWorker(workerData, (function(cb) {
                return function(data) {
                    if (cb) {
                        cb(data.result, data.lang);
                    }
                };
            }(args[2])));
            return;
        }

        // If you pass a callback function then we rerun the color function
        // on all the code and call the callback function on complete.
        //
        // Example:
        //
        // Rainbow.color(function() {
        //     console.log('All matching tags on the page are now highlighted');
        // });
        if (typeof args[0] === 'function') {
            _highlight(0, args[0]);
            return;
        }

        // Otherwise we use whatever node you passed in with an optional
        // callback function as the second parameter.
        //
        // Example:
        //
        // var preElement = document.createElement('pre');
        // var codeElement = document.createElement('code');
        // codeElement.setAttribute('data-language', 'javascript');
        // codeElement.innerHTML = '// Here is some JavaScript';
        // preElement.appendChild(codeElement);
        // Rainbow.color(preElement, function() {
        //     // New element is now highlighted
        // });
        //
        // If you don't pass an element it will default to `document`
        _highlight(args[0], args[1]);
    }

    /**
     * Method to add an alias for an existing language.
     *
     * For example if you want to have "coffee" map to "coffeescript"
     *
     * @see https://github.com/ccampbell/rainbow/issues/154
     * @param {string} alias
     * @param {string} originalLanguage
     * @return {void}
     */
    function addAlias(alias, originalLanguage) {
        aliases[alias] = originalLanguage;
    }

    /**
     * public methods
     */
    Rainbow = {
        extend: extend,
        remove: remove,
        onHighlight: onHighlight,
        addAlias: addAlias,
        color: color
    };

    if (isNode) {
        Rainbow.colorSync = function(code, lang) {
            var workerData = _getWorkerData(code, lang);
            var prism = new Prism(workerData.options);
            return prism.refract(workerData.code, workerData.lang);
        };
    }

    // In the browser hook it up to color on page load
    if (!isNode && !isWorker) {
        document.addEventListener('DOMContentLoaded', function (event) {
            if (!Rainbow.defer) {
                Rainbow.color(event);
            }
        }, false);
    }

    // From a node worker, handle the postMessage requests to it
    if (isWorker) {
        self.onmessage = rainbowWorker;
    }

    var Rainbow$1 = Rainbow;

    return Rainbow$1;

}));
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":null,"sources":["../src/util.js","../src/prism.js","../src/worker.js","../src/rainbow.js"],"sourcesContent":["\nexport function isNode() {\n    /* globals module */\n    return typeof module !== 'undefined' && typeof module.exports === 'object';\n}\n\nexport function isWorker() {\n    return typeof document === 'undefined' && typeof self !== 'undefined';\n}\n\n/**\n * Browser Only - Gets the language for this block of code\n *\n * @param {Element} block\n * @return {string|null}\n */\nexport function getLanguageForBlock(block) {\n\n    // If this doesn't have a language but the parent does then use that.\n    //\n    // This means if for example you have: <pre data-language=\"php\">\n    // with a bunch of <code> blocks inside then you do not have\n    // to specify the language for each block.\n    let language = block.getAttribute('data-language') || block.parentNode.getAttribute('data-language');\n\n    // This adds support for specifying language via a CSS class.\n    //\n    // You can use the Google Code Prettify style: <pre class=\"lang-php\">\n    // or the HTML5 style: <pre><code class=\"language-php\">\n    if (!language) {\n        const pattern = /\\blang(?:uage)?-(\\w+)/;\n        const match = block.className.match(pattern) || block.parentNode.className.match(pattern);\n\n        if (match) {\n            language = match[1];\n        }\n    }\n\n    if (language) {\n        return language.toLowerCase();\n    }\n\n    return null;\n}\n\n/**\n * Determines if two different matches have complete overlap with each other\n *\n * @param {number} start1   start position of existing match\n * @param {number} end1     end position of existing match\n * @param {number} start2   start position of new match\n * @param {number} end2     end position of new match\n * @return {boolean}\n */\nexport function hasCompleteOverlap(start1, end1, start2, end2) {\n\n    // If the starting and end positions are exactly the same\n    // then the first one should stay and this one should be ignored.\n    if (start2 === start1 && end2 === end1) {\n        return false;\n    }\n\n    return start2 <= start1 && end2 >= end1;\n}\n\n/**\n * Encodes < and > as html entities\n *\n * @param {string} code\n * @return {string}\n */\nexport function htmlEntities(code) {\n    return code.replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/&(?![\\w\\#]+;)/g, '&amp;');\n}\n\n/**\n * Finds out the position of group match for a regular expression\n *\n * @see http://stackoverflow.com/questions/1985594/how-to-find-index-of-groups-in-match\n * @param {Object} match\n * @param {number} groupNumber\n * @return {number}\n */\nexport function indexOfGroup(match, groupNumber) {\n    let index = 0;\n\n    for (let i = 1; i < groupNumber; ++i) {\n        if (match[i]) {\n            index += match[i].length;\n        }\n    }\n\n    return index;\n}\n\n/**\n * Determines if a new match intersects with an existing one\n *\n * @param {number} start1    start position of existing match\n * @param {number} end1      end position of existing match\n * @param {number} start2    start position of new match\n * @param {number} end2      end position of new match\n * @return {boolean}\n */\nexport function intersects(start1, end1, start2, end2) {\n    if (start2 >= start1 && start2 < end1) {\n        return true;\n    }\n\n    return end2 > start1 && end2 < end1;\n}\n\n/**\n * Sorts an objects keys by index descending\n *\n * @param {Object} object\n * @return {Array}\n */\nexport function keys(object) {\n    const locations = [];\n\n    for (const location in object) {\n        if (object.hasOwnProperty(location)) {\n            locations.push(location);\n        }\n    }\n\n    // numeric descending\n    return locations.sort((a, b) => b - a);\n}\n\n/**\n * Substring replace call to replace part of a string at a certain position\n *\n * @param {number} position         the position where the replacement\n *                                  should happen\n * @param {string} replace          the text we want to replace\n * @param {string} replaceWith      the text we want to replace it with\n * @param {string} code             the code we are doing the replacing in\n * @return {string}\n */\nexport function replaceAtPosition(position, replace, replaceWith, code) {\n    const subString = code.substr(position);\n\n    // This is needed to fix an issue where $ signs do not render in the\n    // highlighted code\n    //\n    // @see https://github.com/ccampbell/rainbow/issues/208\n    replaceWith = replaceWith.replace(/\\$/g, '$$$$');\n\n    return code.substr(0, position) + subString.replace(replace, replaceWith);\n}\n\n/**\n * Creates a usable web worker from an anonymous function\n *\n * mostly borrowed from https://github.com/zevero/worker-create\n *\n * @param {Function} fn\n * @param {Prism} Prism\n * @return {Worker}\n */\nexport function createWorker(fn, Prism) {\n    if (isNode()) {\n        /* globals global, require, __filename */\n        global.Worker = require('web-worker');\n        return new Worker(__filename);\n    }\n\n    const prismFunction = Prism.toString();\n\n    let code = keys.toString();\n    code += htmlEntities.toString();\n    code += hasCompleteOverlap.toString();\n    code += intersects.toString();\n    code += replaceAtPosition.toString();\n    code += indexOfGroup.toString();\n    code += prismFunction;\n\n    const fullString = `${code}\\tthis.onmessage=${fn.toString()}`;\n\n    const blob = new Blob([fullString], { type: 'text/javascript' });\n    return new Worker((window.URL || window.webkitURL).createObjectURL(blob));\n}\n","import { replaceAtPosition, indexOfGroup, keys, htmlEntities, hasCompleteOverlap, intersects } from './util';\n\n/**\n * Prism is a class used to highlight individual blocks of code\n *\n * @class\n */\nclass Prism {\n    constructor(options) {\n        /**\n         * Object of replacements to process at the end of the processing\n         *\n         * @type {Object}\n         */\n        const replacements = {};\n\n        /**\n         * Language associated with this Prism object\n         *\n         * @type {string}\n         */\n        let currentLanguage;\n\n        /**\n         * Object of start and end positions of blocks to be replaced\n         *\n         * @type {Object}\n         */\n        const replacementPositions = {};\n\n        /**\n         * Determines if the match passed in falls inside of an existing match.\n         * This prevents a regex pattern from matching inside of another pattern\n         * that matches a larger amount of code.\n         *\n         * For example this prevents a keyword from matching `function` if there\n         * is already a match for `function (.*)`.\n         *\n         * @param {number} start    start position of new match\n         * @param {number} end      end position of new match\n         * @return {boolean}\n         */\n        function _matchIsInsideOtherMatch(start, end) {\n            for (let key in replacementPositions) {\n                key = parseInt(key, 10);\n\n                // If this block completely overlaps with another block\n                // then we should remove the other block and return `false`.\n                if (hasCompleteOverlap(key, replacementPositions[key], start, end)) {\n                    delete replacementPositions[key];\n                    delete replacements[key];\n                }\n\n                if (intersects(key, replacementPositions[key], start, end)) {\n                    return true;\n                }\n            }\n\n            return false;\n        }\n\n        /**\n         * Takes a string of code and wraps it in a span tag based on the name\n         *\n         * @param {string} name        name of the pattern (ie keyword.regex)\n         * @param {string} code        block of code to wrap\n         * @param {string} globalClass class to apply to every span\n         * @return {string}\n         */\n        function _wrapCodeInSpan(name, code) {\n            let className = name.replace(/\\./g, ' ');\n\n            const globalClass = options.globalClass;\n            if (globalClass) {\n                className += ` ${globalClass}`;\n            }\n\n            return `<span class=\"${className}\">${code}</span>`;\n        }\n\n        /**\n         * Process replacements in the string of code to actually update\n         * the markup\n         *\n         * @param {string} code         the code to process replacements in\n         * @return {string}\n         */\n        function _processReplacements(code) {\n            const positions = keys(replacements);\n            for (const position of positions) {\n                const replacement = replacements[position];\n                code = replaceAtPosition(position, replacement.replace, replacement.with, code);\n            }\n            return code;\n        }\n\n        /**\n         * It is so we can create a new regex object for each call to\n         * _processPattern to avoid state carrying over when running exec\n         * multiple times.\n         *\n         * The global flag should not be carried over because we are simulating\n         * it by processing the regex in a loop so we only care about the first\n         * match in each string. This also seems to improve performance quite a\n         * bit.\n         *\n         * @param {RegExp} regex\n         * @return {string}\n         */\n        function _cloneRegex(regex) {\n            let flags = '';\n\n            if (regex.ignoreCase) {\n                flags += 'i';\n            }\n\n            if (regex.multiline) {\n                flags += 'm';\n            }\n\n            return new RegExp(regex.source, flags);\n        }\n\n        /**\n         * Matches a regex pattern against a block of code, finds all matches\n         * that should be processed, and stores the positions of where they\n         * should be replaced within the string.\n         *\n         * This is where pretty much all the work is done but it should not\n         * be called directly.\n         *\n         * @param {Object} pattern\n         * @param {string} code\n         * @param {number} offset\n         * @return {mixed}\n         */\n        function _processPattern(pattern, code, offset = 0) {\n            let regex = pattern.pattern;\n            if (!regex) {\n                return false;\n            }\n\n            // Since we are simulating global regex matching we need to also\n            // make sure to stop after one match if the pattern is not global\n            const shouldStop = !regex.global;\n\n            regex = _cloneRegex(regex);\n            const match = regex.exec(code);\n            if (!match) {\n                return false;\n            }\n\n            // Treat match 0 the same way as name\n            if (!pattern.name && pattern.matches && typeof pattern.matches[0] === 'string') {\n                pattern.name = pattern.matches[0];\n                delete pattern.matches[0];\n            }\n\n            let replacement = match[0];\n            const startPos = match.index + offset;\n            const endPos = match[0].length + startPos;\n\n            // In some cases when the regex matches a group such as \\s* it is\n            // possible for there to be a match, but have the start position\n            // equal the end position. In those cases we should be able to stop\n            // matching. Otherwise this can lead to an infinite loop.\n            if (startPos === endPos) {\n                return false;\n            }\n\n            // If this is not a child match and it falls inside of another\n            // match that already happened we should skip it and continue\n            // processing.\n            if (_matchIsInsideOtherMatch(startPos, endPos)) {\n                return {\n                    remaining: code.substr(endPos - offset),\n                    offset: endPos\n                };\n            }\n\n            /**\n             * Callback for when a match was successfully processed\n             *\n             * @param {string} repl\n             * @return {void}\n             */\n            function onMatchSuccess(repl) {\n\n                // If this match has a name then wrap it in a span tag\n                if (pattern.name) {\n                    repl = _wrapCodeInSpan(pattern.name, repl);\n                }\n\n                // For debugging\n                // console.log('Replace ' + match[0] + ' with ' + replacement + ' at position ' + startPos + ' to ' + endPos);\n\n                // Store what needs to be replaced with what at this position\n                replacements[startPos] = {\n                    'replace': match[0],\n                    'with': repl\n                };\n\n                // Store the range of this match so we can use it for\n                // comparisons with other matches later.\n                replacementPositions[startPos] = endPos;\n\n                if (shouldStop) {\n                    return false;\n                }\n\n                return {\n                    remaining: code.substr(endPos - offset),\n                    offset: endPos\n                };\n            }\n\n            /**\n             * Helper function for processing a sub group\n             *\n             * @param {number} groupKey      index of group\n             * @return {void}\n             */\n            function _processGroup(groupKey) {\n                const block = match[groupKey];\n\n                // If there is no match here then move on\n                if (!block) {\n                    return;\n                }\n\n                const group = pattern.matches[groupKey];\n                const language = group.language;\n\n                /**\n                 * Process group is what group we should use to actually process\n                 * this match group.\n                 *\n                 * For example if the subgroup pattern looks like this:\n                 *\n                 * 2: {\n                 *     'name': 'keyword',\n                 *     'pattern': /true/g\n                 * }\n                 *\n                 * then we use that as is, but if it looks like this:\n                 *\n                 * 2: {\n                 *     'name': 'keyword',\n                 *     'matches': {\n                 *          'name': 'special',\n                 *          'pattern': /whatever/g\n                 *      }\n                 * }\n                 *\n                 * we treat the 'matches' part as the pattern and keep\n                 * the name around to wrap it with later\n                 */\n                const groupToProcess = group.name && group.matches ? group.matches : group;\n\n                /**\n                 * Takes the code block matched at this group, replaces it\n                 * with the highlighted block, and optionally wraps it with\n                 * a span with a name\n                 *\n                 * @param {string} passedBlock\n                 * @param {string} replaceBlock\n                 * @param {string|null} matchName\n                 */\n                const _getReplacement = function(passedBlock, replaceBlock, matchName) {\n                    replacement = replaceAtPosition(indexOfGroup(match, groupKey), passedBlock, matchName ? _wrapCodeInSpan(matchName, replaceBlock) : replaceBlock, replacement);\n                    return;\n                };\n\n                // If this is a string then this match is directly mapped\n                // to selector so all we have to do is wrap it in a span\n                // and continue.\n                if (typeof group === 'string') {\n                    _getReplacement(block, block, group);\n                    return;\n                }\n\n                let localCode;\n                const prism = new Prism(options);\n\n                // If this is a sublanguage go and process the block using\n                // that language\n                if (language) {\n                    localCode = prism.refract(block, language);\n                    _getReplacement(block, localCode);\n                    return;\n                }\n\n                // The process group can be a single pattern or an array of\n                // patterns. `_processCodeWithPatterns` always expects an array\n                // so we convert it here.\n                localCode = prism.refract(block, currentLanguage, groupToProcess.length ? groupToProcess : [groupToProcess]);\n                _getReplacement(block, localCode, group.matches ? group.name : 0);\n            }\n\n            // If this pattern has sub matches for different groups in the regex\n            // then we should process them one at a time by running them through\n            // the _processGroup function to generate the new replacement.\n            //\n            // We use the `keys` function to run through them backwards because\n            // the match position of earlier matches will not change depending\n            // on what gets replaced in later matches.\n            const groupKeys = keys(pattern.matches);\n            for (const groupKey of groupKeys) {\n                _processGroup(groupKey);\n            }\n\n            // Finally, call `onMatchSuccess` with the replacement\n            return onMatchSuccess(replacement);\n        }\n\n        /**\n         * Processes a block of code using specified patterns\n         *\n         * @param {string} code\n         * @param {Array} patterns\n         * @return {string}\n         */\n        function _processCodeWithPatterns(code, patterns) {\n            for (const pattern of patterns) {\n                let result = _processPattern(pattern, code);\n                while (result) {\n                    result = _processPattern(pattern, result.remaining, result.offset);\n                }\n            }\n\n            // We are done processing the patterns so we should actually replace\n            // what needs to be replaced in the code.\n            return _processReplacements(code);\n        }\n\n        /**\n         * Returns a list of regex patterns for this language\n         *\n         * @param {string} language\n         * @return {Array}\n         */\n        function getPatternsForLanguage(language) {\n            let patterns = options.patterns[language] || [];\n            while (options.inheritenceMap[language]) {\n                language = options.inheritenceMap[language];\n                patterns = patterns.concat(options.patterns[language] || []);\n            }\n\n            return patterns;\n        }\n\n        /**\n         * Takes a string of code and highlights it according to the language\n         * specified\n         *\n         * @param {string} code\n         * @param {string} language\n         * @param {object} patterns optionally specify a list of patterns\n         * @return {string}\n         */\n        function _highlightBlockForLanguage(code, language, patterns) {\n            currentLanguage = language;\n            patterns = patterns || getPatternsForLanguage(language);\n            return _processCodeWithPatterns(htmlEntities(code), patterns);\n        }\n\n        this.refract = _highlightBlockForLanguage;\n    }\n}\n\nexport default Prism;\n","import Prism from './prism';\n\nexport default function rainbowWorker(e) {\n    const message = e.data;\n\n    const prism = new Prism(message.options);\n    const result = prism.refract(message.code, message.lang);\n\n    function _reply() {\n        self.postMessage({\n            id: message.id,\n            lang: message.lang,\n            result\n        });\n    }\n\n    if (message.isNode) {\n        _reply();\n        return;\n    }\n\n    setTimeout(() => {\n        _reply();\n    }, message.options.delay * 1000);\n}\n","/**\n * Copyright 2012-2016 Craig Campbell\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * Rainbow is a simple code syntax highlighter\n *\n * @see rainbowco.de\n */\nimport Prism from './prism';\nimport { isNode as utilIsNode, isWorker as utilIsWorker, createWorker, getLanguageForBlock } from './util';\nimport rainbowWorker from './worker';\n\n/**\n * An array of the language patterns specified for each language\n *\n * @type {Object}\n */\nconst patterns = {};\n\n/**\n * An object of languages mapping to what language they should inherit from\n *\n * @type {Object}\n */\nconst inheritenceMap = {};\n\n/**\n * A mapping of language aliases\n *\n * @type {Object}\n */\nconst aliases = {};\n\n/**\n * Representation of the actual rainbow object\n *\n * @type {Object}\n */\nlet Rainbow = {};\n\n/**\n * Callback to fire after each block is highlighted\n *\n * @type {null|Function}\n */\nlet onHighlightCallback;\n\n/**\n * Counter for block ids\n * @see https://github.com/ccampbell/rainbow/issues/207\n */\nlet id = 0;\n\nconst isNode = utilIsNode();\nconst isWorker = utilIsWorker();\n\nlet cachedWorker = null;\nfunction _getWorker() {\n    if (isNode || cachedWorker === null) {\n        cachedWorker = createWorker(rainbowWorker, Prism);\n    }\n\n    return cachedWorker;\n}\n\n/**\n * Helper for matching up callbacks directly with the\n * post message requests to a web worker.\n *\n * @param {object} message      data to send to web worker\n * @param {Function} callback   callback function for worker to reply to\n * @return {void}\n */\nfunction _messageWorker(message, callback) {\n    const worker = _getWorker();\n\n    function _listen(e) {\n        if (e.data.id === message.id) {\n            callback(e.data);\n            worker.removeEventListener('message', _listen);\n\n            // I realized down the road I might look at this and wonder what is going on\n            // so probably it is not a bad idea to leave a comment.\n            //\n            // This is needed because right now the node library for simulating web\n            // workers “web-worker” will keep the worker open and it causes\n            // scripts running from the command line to hang unless the worker is\n            // explicitly closed.\n            //\n            // This means for node we will spawn a new thread for every asynchronous\n            // block we are highlighting, but in the browser we will keep a single\n            // worker open for all requests.\n            if (isNode) {\n                worker.terminate();\n            }\n        }\n    }\n\n    worker.addEventListener('message', _listen);\n    worker.postMessage(message);\n}\n\n/**\n * Browser Only - Handles response from web worker, updates DOM with\n * resulting code, and fires callback\n *\n * @param {Element} element\n * @param {object} waitingOn\n * @param {Function} callback\n * @return {void}\n */\nfunction _generateHandler(element, waitingOn, callback) {\n    return function _handleResponseFromWorker(data) {\n        element.innerHTML = data.result;\n        element.classList.remove('loading');\n        element.classList.add('rainbow-show');\n\n        if (element.parentNode.tagName === 'PRE') {\n            element.parentNode.classList.remove('loading');\n            element.parentNode.classList.add('rainbow-show');\n        }\n\n        // element.addEventListener('animationend', (e) => {\n        //     if (e.animationName === 'fade-in') {\n        //         setTimeout(() => {\n        //             element.classList.remove('decrease-delay');\n        //         }, 1000);\n        //     }\n        // });\n\n        if (onHighlightCallback) {\n            onHighlightCallback(element, data.lang);\n        }\n\n        if (--waitingOn.c === 0) {\n            callback();\n        }\n    };\n}\n\n/**\n * Gets options needed to pass into Prism\n *\n * @param {object} options\n * @return {object}\n */\nfunction _getPrismOptions(options) {\n    return {\n        patterns,\n        inheritenceMap,\n        aliases,\n        globalClass: options.globalClass,\n        delay: !isNaN(options.delay) ? options.delay : 0\n    };\n}\n\n/**\n * Gets data to send to webworker\n *\n * @param  {string} code\n * @param  {string} lang\n * @return {object}\n */\nfunction _getWorkerData(code, lang) {\n    let options = {};\n    if (typeof lang === 'object') {\n        options = lang;\n        lang = options.language;\n    }\n\n    lang = aliases[lang] || lang;\n\n    const workerData = {\n        id: id++,\n        code,\n        lang,\n        options: _getPrismOptions(options),\n        isNode\n    };\n\n    return workerData;\n}\n\n/**\n * Browser Only - Sends messages to web worker to highlight elements passed\n * in\n *\n * @param {Array} codeBlocks\n * @param {Function} callback\n * @return {void}\n */\nfunction _highlightCodeBlocks(codeBlocks, callback) {\n    const waitingOn = { c: 0 };\n    for (const block of codeBlocks) {\n        const language = getLanguageForBlock(block);\n        if (block.classList.contains('rainbow') || !language) {\n            continue;\n        }\n\n        // This cancels the pending animation to fade the code in on load\n        // since we want to delay doing this until it is actually\n        // highlighted\n        block.classList.add('loading');\n        block.classList.add('rainbow');\n\n        // We need to make sure to also add the loading class to the pre tag\n        // because that is how we will know to show a preloader\n        if (block.parentNode.tagName === 'PRE') {\n            block.parentNode.classList.add('loading');\n        }\n\n        const globalClass = block.getAttribute('data-global-class');\n        const delay = parseInt(block.getAttribute('data-delay'), 10);\n\n        ++waitingOn.c;\n        _messageWorker(_getWorkerData(block.innerHTML, { language, globalClass, delay }), _generateHandler(block, waitingOn, callback));\n    }\n\n    if (waitingOn.c === 0) {\n        callback();\n    }\n}\n\nfunction _addPreloader(preBlock) {\n    const preloader = document.createElement('div');\n    preloader.className = 'preloader';\n    for (let i = 0; i < 7; i++) {\n        preloader.appendChild(document.createElement('div'));\n    }\n    preBlock.appendChild(preloader);\n}\n\n/**\n * Browser Only - Start highlighting all the code blocks\n *\n * @param {Element} node       HTMLElement to search within\n * @param {Function} callback\n * @return {void}\n */\nfunction _highlight(node, callback) {\n    callback = callback || function() {};\n\n    // The first argument can be an Event or a DOM Element.\n    //\n    // I was originally checking instanceof Event but that made it break\n    // when using mootools.\n    //\n    // @see https://github.com/ccampbell/rainbow/issues/32\n    node = node && typeof node.getElementsByTagName === 'function' ? node : document;\n\n    const preBlocks = node.getElementsByTagName('pre');\n    const codeBlocks = node.getElementsByTagName('code');\n    const finalPreBlocks = [];\n    const finalCodeBlocks = [];\n\n    // First loop through all pre blocks to find which ones to highlight\n    for (const preBlock of preBlocks) {\n        _addPreloader(preBlock);\n\n        // Strip whitespace around code tags when they are inside of a pre\n        // tag.  This makes the themes look better because you can't\n        // accidentally add extra linebreaks at the start and end.\n        //\n        // When the pre tag contains a code tag then strip any extra\n        // whitespace.\n        //\n        // For example:\n        //\n        // <pre>\n        //      <code>var foo = true;</code>\n        // </pre>\n        //\n        // will become:\n        //\n        // <pre><code>var foo = true;</code></pre>\n        //\n        // If you want to preserve whitespace you can use a pre tag on\n        // its own without a code tag inside of it.\n        if (preBlock.getElementsByTagName('code').length) {\n\n            // This fixes a race condition when Rainbow.color is called before\n            // the previous color call has finished.\n            if (!preBlock.getAttribute('data-trimmed')) {\n                preBlock.setAttribute('data-trimmed', true);\n                preBlock.innerHTML = preBlock.innerHTML.trim();\n            }\n            continue;\n        }\n\n        // If the pre block has no code blocks then we are going to want to\n        // process it directly.\n        finalPreBlocks.push(preBlock);\n    }\n\n    // @see http://stackoverflow.com/questions/2735067/how-to-convert-a-dom-node-list-to-an-array-in-javascript\n    // We are going to process all <code> blocks\n    for (const codeBlock of codeBlocks) {\n        finalCodeBlocks.push(codeBlock);\n    }\n\n    _highlightCodeBlocks(finalCodeBlocks.concat(finalPreBlocks), callback);\n}\n\n/**\n * Callback to let you do stuff in your app after a piece of code has\n * been highlighted\n *\n * @param {Function} callback\n * @return {void}\n */\nfunction onHighlight(callback) {\n    onHighlightCallback = callback;\n}\n\n/**\n * Extends the language pattern matches\n *\n * @param {string} language            name of language\n * @param {object} languagePatterns    object of patterns to add on\n * @param {string|undefined} inherits  optional language that this language\n *                                     should inherit rules from\n */\nfunction extend(language, languagePatterns, inherits) {\n\n    // If we extend a language again we shouldn't need to specify the\n    // inheritence for it. For example, if you are adding special highlighting\n    // for a javascript function that is not in the base javascript rules, you\n    // should be able to do\n    //\n    // Rainbow.extend('javascript', [ … ]);\n    //\n    // Without specifying a language it should inherit (generic in this case)\n    if (!inheritenceMap[language]) {\n        inheritenceMap[language] = inherits;\n    }\n\n    patterns[language] = languagePatterns.concat(patterns[language] || []);\n}\n\nfunction remove(language) {\n    delete inheritenceMap[language];\n    delete patterns[language];\n}\n\n/**\n * Starts the magic rainbow\n *\n * @return {void}\n */\nfunction color(...args) {\n\n    // If you want to straight up highlight a string you can pass the\n    // string of code, the language, and a callback function.\n    //\n    // Example:\n    //\n    // Rainbow.color(code, language, function(highlightedCode, language) {\n    //     // this code block is now highlighted\n    // });\n    if (typeof args[0] === 'string') {\n        const workerData = _getWorkerData(args[0], args[1]);\n        _messageWorker(workerData, (function(cb) {\n            return function(data) {\n                if (cb) {\n                    cb(data.result, data.lang);\n                }\n            };\n        }(args[2])));\n        return;\n    }\n\n    // If you pass a callback function then we rerun the color function\n    // on all the code and call the callback function on complete.\n    //\n    // Example:\n    //\n    // Rainbow.color(function() {\n    //     console.log('All matching tags on the page are now highlighted');\n    // });\n    if (typeof args[0] === 'function') {\n        _highlight(0, args[0]);\n        return;\n    }\n\n    // Otherwise we use whatever node you passed in with an optional\n    // callback function as the second parameter.\n    //\n    // Example:\n    //\n    // var preElement = document.createElement('pre');\n    // var codeElement = document.createElement('code');\n    // codeElement.setAttribute('data-language', 'javascript');\n    // codeElement.innerHTML = '// Here is some JavaScript';\n    // preElement.appendChild(codeElement);\n    // Rainbow.color(preElement, function() {\n    //     // New element is now highlighted\n    // });\n    //\n    // If you don't pass an element it will default to `document`\n    _highlight(args[0], args[1]);\n}\n\n/**\n * Method to add an alias for an existing language.\n *\n * For example if you want to have \"coffee\" map to \"coffeescript\"\n *\n * @see https://github.com/ccampbell/rainbow/issues/154\n * @param {string} alias\n * @param {string} originalLanguage\n * @return {void}\n */\nfunction addAlias(alias, originalLanguage) {\n    aliases[alias] = originalLanguage;\n}\n\n/**\n * public methods\n */\nRainbow = {\n    extend,\n    remove,\n    onHighlight,\n    addAlias,\n    color\n};\n\nif (isNode) {\n    Rainbow.colorSync = function(code, lang) {\n        const workerData = _getWorkerData(code, lang);\n        const prism = new Prism(workerData.options);\n        return prism.refract(workerData.code, workerData.lang);\n    };\n}\n\n// In the browser hook it up to color on page load\nif (!isNode && !isWorker) {\n    document.addEventListener('DOMContentLoaded', (event) => {\n        if (!Rainbow.defer) {\n            Rainbow.color(event);\n        }\n    }, false);\n}\n\n// From a node worker, handle the postMessage requests to it\nif (isWorker) {\n    self.onmessage = rainbowWorker;\n}\n\nexport default Rainbow;\n"],"names":["isNode","isWorker","let","const","utilIsNode","utilIsWorker"],"mappings":"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"}